From 38535d84da862172f1fa05d3319c4dd0ac8a90db Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 13 Dec 2016 12:36:40 +1300
Subject: [PATCH 01/66] FEATURE: DataObject scaffolding

---
 README.md                                     |   304 +-
 _config/config.yml                            |    26 +
 client/dist/graphiql.js                       | 54508 ++++++++++++++++
 phpunit.xml                                   |     1 +
 src/FieldCreator.php                          |     2 +-
 src/Manager.php                               |   122 +-
 .../Creators/DataObjectTypeCreator.php        |    76 +
 .../Creators/MutationOperationCreator.php     |    26 +
 .../Creators/OperationCreatorTrait.php        |    96 +
 .../Creators/QueryOperationCreator.php        |    30 +
 src/Scaffolding/DataObjectTypeTrait.php       |    88 +
 src/Scaffolding/OperationList.php             |    82 +
 src/Scaffolding/ResolverInterface.php         |    21 +
 .../Scaffolders/CreateOperationScaffolder.php |    93 +
 .../Scaffolders/DataObjectScaffolder.php      |   338 +
 .../Scaffolders/DeleteOperationScaffolder.php |    50 +
 .../Scaffolders/GraphQLScaffolder.php         |   160 +
 .../Scaffolders/ManagerMutatorInterface.php   |    18 +
 .../Scaffolders/MutationScaffolder.php        |    42 +
 .../Scaffolders/OperationScaffolder.php       |   137 +
 .../Scaffolders/QueryScaffolder.php           |    42 +
 .../Scaffolders/ReadOperationScaffolder.php   |    54 +
 .../Scaffolders/ScaffolderInterface.php       |    18 +
 .../Scaffolders/UpdateOperationScaffolder.php |   102 +
 src/Scaffolding/ScaffoldingProvider.php       |    17 +
 src/Scaffolding/Util/ArgsParser.php           |    56 +
 src/Scaffolding/Util/TypeParser.php           |   118 +
 tests/Fake/DataObjectFake.php                 |    11 +-
 tests/Fake/FakeResolver.php                   |    14 +
 tests/ScaffoldingTest.php                     |   731 +
 30 files changed, 57324 insertions(+), 59 deletions(-)
 create mode 100644 _config/config.yml
 create mode 100644 client/dist/graphiql.js
 create mode 100644 src/Scaffolding/Creators/DataObjectTypeCreator.php
 create mode 100644 src/Scaffolding/Creators/MutationOperationCreator.php
 create mode 100644 src/Scaffolding/Creators/OperationCreatorTrait.php
 create mode 100644 src/Scaffolding/Creators/QueryOperationCreator.php
 create mode 100644 src/Scaffolding/DataObjectTypeTrait.php
 create mode 100644 src/Scaffolding/OperationList.php
 create mode 100644 src/Scaffolding/ResolverInterface.php
 create mode 100644 src/Scaffolding/Scaffolders/CreateOperationScaffolder.php
 create mode 100644 src/Scaffolding/Scaffolders/DataObjectScaffolder.php
 create mode 100644 src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php
 create mode 100644 src/Scaffolding/Scaffolders/GraphQLScaffolder.php
 create mode 100644 src/Scaffolding/Scaffolders/ManagerMutatorInterface.php
 create mode 100644 src/Scaffolding/Scaffolders/MutationScaffolder.php
 create mode 100644 src/Scaffolding/Scaffolders/OperationScaffolder.php
 create mode 100644 src/Scaffolding/Scaffolders/QueryScaffolder.php
 create mode 100644 src/Scaffolding/Scaffolders/ReadOperationScaffolder.php
 create mode 100644 src/Scaffolding/Scaffolders/ScaffolderInterface.php
 create mode 100644 src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php
 create mode 100644 src/Scaffolding/ScaffoldingProvider.php
 create mode 100644 src/Scaffolding/Util/ArgsParser.php
 create mode 100644 src/Scaffolding/Util/TypeParser.php
 create mode 100644 tests/Fake/FakeResolver.php
 create mode 100644 tests/ScaffoldingTest.php

diff --git a/README.md b/README.md
index cd8c4c1a5..f8669440c 100644
--- a/README.md
+++ b/README.md
@@ -492,6 +492,305 @@ This will create a new member with an email address, which you can pass in as
 query variables: `{"Email": "test@test.com"}`. It'll return the new `ID`
 property of the created member.
 
+## Scaffolding DataObjects into the Schema
+
+Making a DataObject accessible through the GraphQL API involves quite a bit of boilerplate. In the above example, we can see that creating endpoints for a query and a mutation requires creating three new classes, along with an update to the configuration, and we haven't even dealt with data relations yet. For applications that require a lot of business logic and specific functionality, an architecture like this affords the developer a lot of control, but for developers who just want to make a given model accessible through GraphQL with some basic Create, Read, Update, and Delete operations, scaffolding them can save a lot of time and reduce the clutter in your project.
+
+Scaffolding DataObjects can be achieved in two non-exclusive ways:
+
+* Via executable code (procedurally)
+* Via the config layer (declaratively)
+
+The example code will show demonstrate both methods for each section.
+
+### Our example
+
+For these examples, we'll imagine we have the following model:
+
+```php
+namespace My\Project;
+
+class Post extends DataObject {
+
+  private static $db = [
+  	'Title' => 'Varchar',
+  	'Content' => 'HTMLText'
+  ];
+
+  private static $has_one = [
+  	'Author' => 'SilverStripe\Security\Member'
+  ];
+
+  private static $many_many = [
+  	'Files' => 'SilverStripe\Assets\File'
+  ];
+}
+```
+
+### Scaffolding DataObjects through procedural code
+
+The GraphQL `Manager` class will bootstrap itself with any scaffolders that are registered in its config. These scaffolders must implement the `ScaffoldingProvider` interface. A logical place to add this code may be in your DataObject, but it could be anywhere.
+
+As a `ScaffoldingProvider`, the class must now offer the `provideGraphQLScaffolding()` method.
+
+```php
+namespace My\Project;
+use SilverStripe\GraphQL\Scaffolding\ScaffoldingProvider;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
+
+class Post extends DataObject implements ScaffoldingProvider {
+	//...
+    public function provideGraphQLScaffolding(GraphQLScaffolder $scaffolder)
+    {
+    	// update the scaffolder here
+	}
+}
+```
+
+In order to register the scaffolding provider with the manager, we'll need to make an update to the config.
+
+```yaml
+SilverStripe\GraphQL:
+  schema:
+    scaffolding_providers:
+      - My\Project\Post
+```
+
+### Scaffolding DataObjects through the Config layer
+
+Many of the declarations you make through procedural code can be done via YAML. If you don't have any logic in your scaffolding, using the YAML approach may make more sense.
+
+We'll need to define a `scaffolding` node in the `SilverStripe\GraphQL.schema` setting.
+
+```yaml
+SilverStripe\GraphQL:
+  schema:
+    scaffolding:
+      ## scaffolding goes here
+
+```
+
+### Exposing a DataObject to GraphQL
+
+Let's now expose the `Post` type. We'll choose the fields we want to offer, along with a simple query and mutation.
+
+**Code**:
+```php
+class Post extends DataObject implements ScaffoldingProvider {
+	//...
+    public function provideGraphQLScaffolding(GraphQLScaffolder $scaffolder)
+    {
+    	$scaffolder->dataObject(Post::class)
+    		->addFields(['ID','Title','Content'])
+    		->query('readPosts', function() {
+    			return Post::get()->limit(10);
+    		});
+    	$scaffolder->dataObject(Post::class)
+    		->mutation('updatePostTitle')
+    		->addArgs([
+    			'ID' => 'ID!',
+    			'NewTitle' => 'String!'
+    		])
+    		->setResolver(function($obj, $args) {
+    			$post = Post::get()->byID($args['ID']);
+    			$post->Title = $args['NewTitle'];
+    			$post->write();
+
+    			return $post;
+    		});
+
+    	return $scaffolder;
+	}
+}
+```
+
+**YAML**:
+```
+SilverStripe\GraphQL:
+  schema:
+    scaffolding_providers:
+      - MyFamily\Model\Post
+    scaffolding:
+      My\Project\Post:
+        fields: [ID, Title, Content]
+        queries:
+          readPosts:
+            resolver: MyResolver
+        mutations:
+          updatePostTitle:
+            args:
+              ID: 'ID!'
+              NewTitle: 'String!'
+            resolver: MyResolver
+```
+
+We can now access the posts via GraphQL.
+```
+query {
+	readPosts {
+		Title
+    	Content
+  }
+}
+```
+
+```
+mutation UpdatePostTitle($ID: ID!, $NewTitle: String!) {
+	updatePostTitle(ID:$ID, NewTitle: $NewTitle) {
+		Title
+	}
+}
+```
+
+#### Using a custom resolver
+
+The simplest way to add a resolver is via an anonymous function, passed as the optional second parameter to `mutation()` or `query()`, or via the `setResolver()` method. Resolvers may also exist in class definitions that implement the `ResolverInterface`.
+
+**When using the YAML approach, custom resolver classes are compulsory**, since you can't define closures in YAML.
+
+
+```php
+namespace My\Project;
+use SilverStripe\GraphQL\Scaffolding\ResolverInterface;
+
+class MyResolver implements ResolverInterface
+{
+    public function resolve($object, $args, $context, $info)
+    {
+		$post = Post::get()->byID($args['ID']);
+		$post->Title = $args['NewTitle'];
+		$post->write();    	
+	}
+}
+```
+
+This resolver class may now be assigned as either an instance, or a string to the query or mutation definition.
+
+```php
+	$scaffolder->dataObject(Post::class)
+		->mutation('updatePostTitle')
+		->setResolver(MyResolver::class);
+```
+Or...
+```php
+	$scaffolder->dataObject(Post::class)
+		->mutation('updatePostTitle')
+		->setResolver(new MyResolver());
+```
+
+#### Adding related objects
+
+Let's make the post author and attached files accessible through GraphQL. This requires only one small change.
+
+**Code**:
+```php
+	$scaffolder->dataObject(Post::class)
+		->addFields(['ID','Title','Content','Author','Files'])
+```
+
+**YAML**:
+```
+SilverStripe\GraphQL:
+  schema:
+    scaffolding:
+      My\Project\Post:
+        fields: [ID, Title, Content, Author, Files]
+```
+
+Relations are treated just like fields, and the new types are automatically detected, and added to the schema. By default, these new types offer only `ID` as an exposed field (a configuration setting), so we'll probably want to customise that a bit. 
+
+**Code**:
+```php
+	$scaffolder->dataObject(Post::class)
+		->addFields(['ID','Title','Content','Author','Files'])
+		//...
+	$scaffolder->dataObject(Member::class)
+		->addFields(['Name','Email','Groups']); // creates new type "Group"
+	$scaffolder->dataObject(File::class)
+		->addFields(['Filename']);
+	$scaffolder->dataObject(Group::class)
+		->addFields(['Title']);
+```
+
+**YAML**:
+```
+SilverStripe\GraphQL:
+  schema:
+    scaffolding:
+      My\Project\Post:
+        fields: [ID, Title, Content, Author, Files]
+        queries:
+          # ...
+        mutations:
+          # ...        
+      SilverStripe\Security\Member:
+        fields: [Name, Email, Groups]
+      SilverStripe\Assets\File:
+        fields: [Filename]
+      SilverStripe\Security\Group:
+        fields: [Title]
+
+```
+
+None of these new types have queries or mutations associated with them, but we can now access them as data related to our `Post` object.
+
+Notice that we're able to use the computational method 'Name', which resolves to 'getName()' on the Member object. Fields are not necessarily one-to-one with `$db`. They are simply any public method on the DataObject that returns a `DataList`, `DataObject`, or `DBField`.
+
+```
+query {
+	readPosts {
+		Title
+		Content
+		Author {
+			Name
+			Groups {
+				Title
+			}
+		}
+		Files {
+			Filename
+		}
+	}
+}
+```
+
+### Ready-made CRUD operations
+
+Even with the fluency of scaffolding, many of these operations may look the same, and the resolver functions may start to get repetitive with each simple read, create, edit, delete operation we offer. For basic CRUD definitions, you can use the operations that come bundled with the scaffolder and save a lot configuration effort.
+
+These ready-made operations will automatically generate input types and add them to your schema. They offer very basic functionality that checks for permission and performs a simple CRUD operation on your DataObject.
+
+
+**Code:**
+```php
+	$scaffolder->dataObject(Post::class)
+		->addFields(['ID','Title','Content','Author','Files'])
+		->query(GraphQLScaffolder::READ)
+		->mutation(GraphQLScaffolder::UPDATE)
+		->mutation(GraphQLScaffolder::DELETE)
+		->mutation(GraphQLScaffolder::CREATE)
+```
+
+For YAML, the API is slightly different. You'll need the `operations` setting for this.
+
+**YAML**:
+```yaml
+SilverStripe\GraphQL:
+  schema:
+    scaffolding:
+      My\Project\Post:
+        operations: [CREATE, READ, UPDATE, DELETE]
+```
+
+> As shorthand, the expression `[CREATE, READ, UPDATE, DELETE]` can also be expressed as `operations: all`.
+
+We now have a new queries and mutations with automatically generated names:
+
+* readPosts
+* createPost(Input: PostCreateInputType)
+* updatePost(ID: ID!, Input: PostUpdateInputType)
+* deletePost(ID: ID!)
+
 ### Define Interfaces
 
 TODO
@@ -577,8 +876,9 @@ php -r 'echo base64_encode("hello:world");'
  * Permission checks
  * Input/constraint validation on mutations (with third-party validator)
  * CSRF protection (or token-based auth)
- * Generate CRUD operations based on DataObject reflection
- * Generate DataObject relationship CRUD operations
  * Create Enum GraphQL types from DBEnum
  * Date casting
  * Schema serialisation/caching (performance)
+ * Scaffolding description, deprecation attributes
+ * Remove operations/fields via YAML
+ * Refine CRUD operations
diff --git a/_config/config.yml b/_config/config.yml
new file mode 100644
index 000000000..8723b7017
--- /dev/null
+++ b/_config/config.yml
@@ -0,0 +1,26 @@
+---
+Name: graphqlconfig
+---
+SilverStripe\GraphQL\Scaffolding\Scaffolders\DataObjectScaffolder:
+  default_fields:
+    ID: ID
+    
+## Map DB fields to GraphQL types
+SilverStripe\ORM\FieldType\DBField:
+  # fallback
+  graphql_type: 'String'
+
+SilverStripe\ORM\FieldType\DBInt:
+  graphql_type: 'Int'
+
+SilverStripe\ORM\FieldType\DBBoolean:
+  graphql_type: 'Boolean'
+
+SilverStripe\ORM\FieldType\DBFloat:
+  graphql_type: 'Float'
+
+SilverStripe\ORM\FieldType\DBPrimaryKey:
+  graphql_type: 'ID'
+
+SilverStripe\ORM\FieldType\DBForeignKey:
+  graphql_type: 'ID'
diff --git a/client/dist/graphiql.js b/client/dist/graphiql.js
new file mode 100644
index 000000000..51fe115e3
--- /dev/null
+++ b/client/dist/graphiql.js
@@ -0,0 +1,54508 @@
+/******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId])
+/******/ 			return installedModules[moduleId].exports;
+
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			exports: {},
+/******/ 			id: moduleId,
+/******/ 			loaded: false
+/******/ 		};
+
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+
+/******/ 		// Flag the module as loaded
+/******/ 		module.loaded = true;
+
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+
+
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(0);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var _react = __webpack_require__(1);
+
+	var _react2 = _interopRequireDefault(_react);
+
+	var _reactDom = __webpack_require__(32);
+
+	var _graphiql = __webpack_require__(183);
+
+	var _graphiql2 = _interopRequireDefault(_graphiql);
+
+	var _isomorphicFetch = __webpack_require__(308);
+
+	var _isomorphicFetch2 = _interopRequireDefault(_isomorphicFetch);
+
+	__webpack_require__(310);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function graphQLFetcher(graphQLParams) {
+	  var baseURL = document.querySelector('base').href;
+	  return (0, _isomorphicFetch2.default)(baseURL + '/' + GRAPHQL_ROUTE + '/', {
+	    method: 'post',
+	    headers: { 'Content-Type': 'application/json' },
+	    body: JSON.stringify(graphQLParams),
+	    credentials: 'same-origin'
+	  }).then(function (response) {
+	    return response.json();
+	  });
+	}
+
+	document.addEventListener('DOMContentLoaded', function () {
+	  (0, _reactDom.render)(_react2.default.createElement(_graphiql2.default, { fetcher: graphQLFetcher }), document.getElementById('graphiql'));
+	});
+
+/***/ },
+/* 1 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	module.exports = __webpack_require__(2);
+
+
+/***/ },
+/* 2 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _assign = __webpack_require__(4);
+
+	var ReactChildren = __webpack_require__(5);
+	var ReactComponent = __webpack_require__(18);
+	var ReactPureComponent = __webpack_require__(21);
+	var ReactClass = __webpack_require__(22);
+	var ReactDOMFactories = __webpack_require__(24);
+	var ReactElement = __webpack_require__(9);
+	var ReactPropTypes = __webpack_require__(29);
+	var ReactVersion = __webpack_require__(30);
+
+	var onlyChild = __webpack_require__(31);
+	var warning = __webpack_require__(11);
+
+	var createElement = ReactElement.createElement;
+	var createFactory = ReactElement.createFactory;
+	var cloneElement = ReactElement.cloneElement;
+
+	if (process.env.NODE_ENV !== 'production') {
+	  var ReactElementValidator = __webpack_require__(25);
+	  createElement = ReactElementValidator.createElement;
+	  createFactory = ReactElementValidator.createFactory;
+	  cloneElement = ReactElementValidator.cloneElement;
+	}
+
+	var __spread = _assign;
+
+	if (process.env.NODE_ENV !== 'production') {
+	  var warned = false;
+	  __spread = function () {
+	    process.env.NODE_ENV !== 'production' ? warning(warned, 'React.__spread is deprecated and should not be used. Use ' + 'Object.assign directly or another helper function with similar ' + 'semantics. You may be seeing this warning due to your compiler. ' + 'See https://fb.me/react-spread-deprecation for more details.') : void 0;
+	    warned = true;
+	    return _assign.apply(null, arguments);
+	  };
+	}
+
+	var React = {
+
+	  // Modern
+
+	  Children: {
+	    map: ReactChildren.map,
+	    forEach: ReactChildren.forEach,
+	    count: ReactChildren.count,
+	    toArray: ReactChildren.toArray,
+	    only: onlyChild
+	  },
+
+	  Component: ReactComponent,
+	  PureComponent: ReactPureComponent,
+
+	  createElement: createElement,
+	  cloneElement: cloneElement,
+	  isValidElement: ReactElement.isValidElement,
+
+	  // Classic
+
+	  PropTypes: ReactPropTypes,
+	  createClass: ReactClass.createClass,
+	  createFactory: createFactory,
+	  createMixin: function (mixin) {
+	    // Currently a noop. Will be used to validate and trace mixins.
+	    return mixin;
+	  },
+
+	  // This looks DOM specific but these are actually isomorphic helpers
+	  // since they are just generating DOM strings.
+	  DOM: ReactDOMFactories,
+
+	  version: ReactVersion,
+
+	  // Deprecated hook for JSX spread, don't use this for anything.
+	  __spread: __spread
+	};
+
+	module.exports = React;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 3 */
+/***/ function(module, exports) {
+
+	// shim for using process in browser
+	var process = module.exports = {};
+
+	// cached from whatever global is present so that test runners that stub it
+	// don't break things.  But we need to wrap it in a try catch in case it is
+	// wrapped in strict mode code which doesn't define any globals.  It's inside a
+	// function because try/catches deoptimize in certain engines.
+
+	var cachedSetTimeout;
+	var cachedClearTimeout;
+
+	function defaultSetTimout() {
+	    throw new Error('setTimeout has not been defined');
+	}
+	function defaultClearTimeout () {
+	    throw new Error('clearTimeout has not been defined');
+	}
+	(function () {
+	    try {
+	        if (typeof setTimeout === 'function') {
+	            cachedSetTimeout = setTimeout;
+	        } else {
+	            cachedSetTimeout = defaultSetTimout;
+	        }
+	    } catch (e) {
+	        cachedSetTimeout = defaultSetTimout;
+	    }
+	    try {
+	        if (typeof clearTimeout === 'function') {
+	            cachedClearTimeout = clearTimeout;
+	        } else {
+	            cachedClearTimeout = defaultClearTimeout;
+	        }
+	    } catch (e) {
+	        cachedClearTimeout = defaultClearTimeout;
+	    }
+	} ())
+	function runTimeout(fun) {
+	    if (cachedSetTimeout === setTimeout) {
+	        //normal enviroments in sane situations
+	        return setTimeout(fun, 0);
+	    }
+	    // if setTimeout wasn't available but was latter defined
+	    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+	        cachedSetTimeout = setTimeout;
+	        return setTimeout(fun, 0);
+	    }
+	    try {
+	        // when when somebody has screwed with setTimeout but no I.E. maddness
+	        return cachedSetTimeout(fun, 0);
+	    } catch(e){
+	        try {
+	            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+	            return cachedSetTimeout.call(null, fun, 0);
+	        } catch(e){
+	            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+	            return cachedSetTimeout.call(this, fun, 0);
+	        }
+	    }
+
+
+	}
+	function runClearTimeout(marker) {
+	    if (cachedClearTimeout === clearTimeout) {
+	        //normal enviroments in sane situations
+	        return clearTimeout(marker);
+	    }
+	    // if clearTimeout wasn't available but was latter defined
+	    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+	        cachedClearTimeout = clearTimeout;
+	        return clearTimeout(marker);
+	    }
+	    try {
+	        // when when somebody has screwed with setTimeout but no I.E. maddness
+	        return cachedClearTimeout(marker);
+	    } catch (e){
+	        try {
+	            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
+	            return cachedClearTimeout.call(null, marker);
+	        } catch (e){
+	            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+	            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+	            return cachedClearTimeout.call(this, marker);
+	        }
+	    }
+
+
+
+	}
+	var queue = [];
+	var draining = false;
+	var currentQueue;
+	var queueIndex = -1;
+
+	function cleanUpNextTick() {
+	    if (!draining || !currentQueue) {
+	        return;
+	    }
+	    draining = false;
+	    if (currentQueue.length) {
+	        queue = currentQueue.concat(queue);
+	    } else {
+	        queueIndex = -1;
+	    }
+	    if (queue.length) {
+	        drainQueue();
+	    }
+	}
+
+	function drainQueue() {
+	    if (draining) {
+	        return;
+	    }
+	    var timeout = runTimeout(cleanUpNextTick);
+	    draining = true;
+
+	    var len = queue.length;
+	    while(len) {
+	        currentQueue = queue;
+	        queue = [];
+	        while (++queueIndex < len) {
+	            if (currentQueue) {
+	                currentQueue[queueIndex].run();
+	            }
+	        }
+	        queueIndex = -1;
+	        len = queue.length;
+	    }
+	    currentQueue = null;
+	    draining = false;
+	    runClearTimeout(timeout);
+	}
+
+	process.nextTick = function (fun) {
+	    var args = new Array(arguments.length - 1);
+	    if (arguments.length > 1) {
+	        for (var i = 1; i < arguments.length; i++) {
+	            args[i - 1] = arguments[i];
+	        }
+	    }
+	    queue.push(new Item(fun, args));
+	    if (queue.length === 1 && !draining) {
+	        runTimeout(drainQueue);
+	    }
+	};
+
+	// v8 likes predictible objects
+	function Item(fun, array) {
+	    this.fun = fun;
+	    this.array = array;
+	}
+	Item.prototype.run = function () {
+	    this.fun.apply(null, this.array);
+	};
+	process.title = 'browser';
+	process.browser = true;
+	process.env = {};
+	process.argv = [];
+	process.version = ''; // empty string to avoid regexp issues
+	process.versions = {};
+
+	function noop() {}
+
+	process.on = noop;
+	process.addListener = noop;
+	process.once = noop;
+	process.off = noop;
+	process.removeListener = noop;
+	process.removeAllListeners = noop;
+	process.emit = noop;
+
+	process.binding = function (name) {
+	    throw new Error('process.binding is not supported');
+	};
+
+	process.cwd = function () { return '/' };
+	process.chdir = function (dir) {
+	    throw new Error('process.chdir is not supported');
+	};
+	process.umask = function() { return 0; };
+
+
+/***/ },
+/* 4 */
+/***/ function(module, exports) {
+
+	'use strict';
+	/* eslint-disable no-unused-vars */
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+	function toObject(val) {
+		if (val === null || val === undefined) {
+			throw new TypeError('Object.assign cannot be called with null or undefined');
+		}
+
+		return Object(val);
+	}
+
+	function shouldUseNative() {
+		try {
+			if (!Object.assign) {
+				return false;
+			}
+
+			// Detect buggy property enumeration order in older V8 versions.
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=4118
+			var test1 = new String('abc');  // eslint-disable-line
+			test1[5] = 'de';
+			if (Object.getOwnPropertyNames(test1)[0] === '5') {
+				return false;
+			}
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+			var test2 = {};
+			for (var i = 0; i < 10; i++) {
+				test2['_' + String.fromCharCode(i)] = i;
+			}
+			var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+				return test2[n];
+			});
+			if (order2.join('') !== '0123456789') {
+				return false;
+			}
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+			var test3 = {};
+			'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+				test3[letter] = letter;
+			});
+			if (Object.keys(Object.assign({}, test3)).join('') !==
+					'abcdefghijklmnopqrst') {
+				return false;
+			}
+
+			return true;
+		} catch (e) {
+			// We don't expect any of the above to throw, but better to be safe.
+			return false;
+		}
+	}
+
+	module.exports = shouldUseNative() ? Object.assign : function (target, source) {
+		var from;
+		var to = toObject(target);
+		var symbols;
+
+		for (var s = 1; s < arguments.length; s++) {
+			from = Object(arguments[s]);
+
+			for (var key in from) {
+				if (hasOwnProperty.call(from, key)) {
+					to[key] = from[key];
+				}
+			}
+
+			if (Object.getOwnPropertySymbols) {
+				symbols = Object.getOwnPropertySymbols(from);
+				for (var i = 0; i < symbols.length; i++) {
+					if (propIsEnumerable.call(from, symbols[i])) {
+						to[symbols[i]] = from[symbols[i]];
+					}
+				}
+			}
+		}
+
+		return to;
+	};
+
+
+/***/ },
+/* 5 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var PooledClass = __webpack_require__(6);
+	var ReactElement = __webpack_require__(9);
+
+	var emptyFunction = __webpack_require__(12);
+	var traverseAllChildren = __webpack_require__(15);
+
+	var twoArgumentPooler = PooledClass.twoArgumentPooler;
+	var fourArgumentPooler = PooledClass.fourArgumentPooler;
+
+	var userProvidedKeyEscapeRegex = /\/+/g;
+	function escapeUserProvidedKey(text) {
+	  return ('' + text).replace(userProvidedKeyEscapeRegex, '$&/');
+	}
+
+	/**
+	 * PooledClass representing the bookkeeping associated with performing a child
+	 * traversal. Allows avoiding binding callbacks.
+	 *
+	 * @constructor ForEachBookKeeping
+	 * @param {!function} forEachFunction Function to perform traversal with.
+	 * @param {?*} forEachContext Context to perform context with.
+	 */
+	function ForEachBookKeeping(forEachFunction, forEachContext) {
+	  this.func = forEachFunction;
+	  this.context = forEachContext;
+	  this.count = 0;
+	}
+	ForEachBookKeeping.prototype.destructor = function () {
+	  this.func = null;
+	  this.context = null;
+	  this.count = 0;
+	};
+	PooledClass.addPoolingTo(ForEachBookKeeping, twoArgumentPooler);
+
+	function forEachSingleChild(bookKeeping, child, name) {
+	  var func = bookKeeping.func,
+	      context = bookKeeping.context;
+
+	  func.call(context, child, bookKeeping.count++);
+	}
+
+	/**
+	 * Iterates through children that are typically specified as `props.children`.
+	 *
+	 * See https://facebook.github.io/react/docs/top-level-api.html#react.children.foreach
+	 *
+	 * The provided forEachFunc(child, index) will be called for each
+	 * leaf child.
+	 *
+	 * @param {?*} children Children tree container.
+	 * @param {function(*, int)} forEachFunc
+	 * @param {*} forEachContext Context for forEachContext.
+	 */
+	function forEachChildren(children, forEachFunc, forEachContext) {
+	  if (children == null) {
+	    return children;
+	  }
+	  var traverseContext = ForEachBookKeeping.getPooled(forEachFunc, forEachContext);
+	  traverseAllChildren(children, forEachSingleChild, traverseContext);
+	  ForEachBookKeeping.release(traverseContext);
+	}
+
+	/**
+	 * PooledClass representing the bookkeeping associated with performing a child
+	 * mapping. Allows avoiding binding callbacks.
+	 *
+	 * @constructor MapBookKeeping
+	 * @param {!*} mapResult Object containing the ordered map of results.
+	 * @param {!function} mapFunction Function to perform mapping with.
+	 * @param {?*} mapContext Context to perform mapping with.
+	 */
+	function MapBookKeeping(mapResult, keyPrefix, mapFunction, mapContext) {
+	  this.result = mapResult;
+	  this.keyPrefix = keyPrefix;
+	  this.func = mapFunction;
+	  this.context = mapContext;
+	  this.count = 0;
+	}
+	MapBookKeeping.prototype.destructor = function () {
+	  this.result = null;
+	  this.keyPrefix = null;
+	  this.func = null;
+	  this.context = null;
+	  this.count = 0;
+	};
+	PooledClass.addPoolingTo(MapBookKeeping, fourArgumentPooler);
+
+	function mapSingleChildIntoContext(bookKeeping, child, childKey) {
+	  var result = bookKeeping.result,
+	      keyPrefix = bookKeeping.keyPrefix,
+	      func = bookKeeping.func,
+	      context = bookKeeping.context;
+
+
+	  var mappedChild = func.call(context, child, bookKeeping.count++);
+	  if (Array.isArray(mappedChild)) {
+	    mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, emptyFunction.thatReturnsArgument);
+	  } else if (mappedChild != null) {
+	    if (ReactElement.isValidElement(mappedChild)) {
+	      mappedChild = ReactElement.cloneAndReplaceKey(mappedChild,
+	      // Keep both the (mapped) and old keys if they differ, just as
+	      // traverseAllChildren used to do for objects as children
+	      keyPrefix + (mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey(mappedChild.key) + '/' : '') + childKey);
+	    }
+	    result.push(mappedChild);
+	  }
+	}
+
+	function mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {
+	  var escapedPrefix = '';
+	  if (prefix != null) {
+	    escapedPrefix = escapeUserProvidedKey(prefix) + '/';
+	  }
+	  var traverseContext = MapBookKeeping.getPooled(array, escapedPrefix, func, context);
+	  traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);
+	  MapBookKeeping.release(traverseContext);
+	}
+
+	/**
+	 * Maps children that are typically specified as `props.children`.
+	 *
+	 * See https://facebook.github.io/react/docs/top-level-api.html#react.children.map
+	 *
+	 * The provided mapFunction(child, key, index) will be called for each
+	 * leaf child.
+	 *
+	 * @param {?*} children Children tree container.
+	 * @param {function(*, int)} func The map function.
+	 * @param {*} context Context for mapFunction.
+	 * @return {object} Object containing the ordered map of results.
+	 */
+	function mapChildren(children, func, context) {
+	  if (children == null) {
+	    return children;
+	  }
+	  var result = [];
+	  mapIntoWithKeyPrefixInternal(children, result, null, func, context);
+	  return result;
+	}
+
+	function forEachSingleChildDummy(traverseContext, child, name) {
+	  return null;
+	}
+
+	/**
+	 * Count the number of children that are typically specified as
+	 * `props.children`.
+	 *
+	 * See https://facebook.github.io/react/docs/top-level-api.html#react.children.count
+	 *
+	 * @param {?*} children Children tree container.
+	 * @return {number} The number of children.
+	 */
+	function countChildren(children, context) {
+	  return traverseAllChildren(children, forEachSingleChildDummy, null);
+	}
+
+	/**
+	 * Flatten a children object (typically specified as `props.children`) and
+	 * return an array with appropriately re-keyed children.
+	 *
+	 * See https://facebook.github.io/react/docs/top-level-api.html#react.children.toarray
+	 */
+	function toArray(children) {
+	  var result = [];
+	  mapIntoWithKeyPrefixInternal(children, result, null, emptyFunction.thatReturnsArgument);
+	  return result;
+	}
+
+	var ReactChildren = {
+	  forEach: forEachChildren,
+	  map: mapChildren,
+	  mapIntoWithKeyPrefixInternal: mapIntoWithKeyPrefixInternal,
+	  count: countChildren,
+	  toArray: toArray
+	};
+
+	module.exports = ReactChildren;
+
+/***/ },
+/* 6 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(7);
+
+	var invariant = __webpack_require__(8);
+
+	/**
+	 * 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 threeArgumentPooler = function (a1, a2, a3) {
+	  var Klass = this;
+	  if (Klass.instancePool.length) {
+	    var instance = Klass.instancePool.pop();
+	    Klass.call(instance, a1, a2, a3);
+	    return instance;
+	  } else {
+	    return new Klass(a1, a2, a3);
+	  }
+	};
+
+	var fourArgumentPooler = function (a1, a2, a3, a4) {
+	  var Klass = this;
+	  if (Klass.instancePool.length) {
+	    var instance = Klass.instancePool.pop();
+	    Klass.call(instance, a1, a2, a3, a4);
+	    return instance;
+	  } else {
+	    return new Klass(a1, a2, a3, a4);
+	  }
+	};
+
+	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;
+	  !(instance instanceof Klass) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Trying to release an instance into a pool of a different type.') : _prodInvariant('25') : void 0;
+	  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.
+	 *
+	 * @param {Function} CopyConstructor Constructor that can be used to reset.
+	 * @param {Function} pooler Customizable pooler.
+	 */
+	var addPoolingTo = function (CopyConstructor, pooler) {
+	  // Casting as any so that flow ignores the actual implementation and trusts
+	  // it to match the type we declared
+	  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,
+	  threeArgumentPooler: threeArgumentPooler,
+	  fourArgumentPooler: fourArgumentPooler,
+	  fiveArgumentPooler: fiveArgumentPooler
+	};
+
+	module.exports = PooledClass;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 7 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+	'use strict';
+
+	/**
+	 * WARNING: DO NOT manually require this module.
+	 * This is a replacement for `invariant(...)` used by the error code system
+	 * and will _only_ be required by the corresponding babel pass.
+	 * It always throws.
+	 */
+
+	function reactProdInvariant(code) {
+	  var argCount = arguments.length - 1;
+
+	  var message = 'Minified React error #' + code + '; visit ' + 'http://facebook.github.io/react/docs/error-decoder.html?invariant=' + code;
+
+	  for (var argIdx = 0; argIdx < argCount; argIdx++) {
+	    message += '&args[]=' + encodeURIComponent(arguments[argIdx + 1]);
+	  }
+
+	  message += ' for the full message or use the non-minified dev environment' + ' for full errors and additional helpful warnings.';
+
+	  var error = new Error(message);
+	  error.name = 'Invariant Violation';
+	  error.framesToPop = 1; // we don't care about reactProdInvariant's own frame
+
+	  throw error;
+	}
+
+	module.exports = reactProdInvariant;
+
+/***/ },
+/* 8 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	/**
+	 * Use invariant() to assert state which your program assumes to be true.
+	 *
+	 * Provide sprintf-style format (only %s is supported) 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, format, a, b, c, d, e, f) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    if (format === undefined) {
+	      throw new Error('invariant requires an error message argument');
+	    }
+	  }
+
+	  if (!condition) {
+	    var error;
+	    if (format === undefined) {
+	      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
+	    } else {
+	      var args = [a, b, c, d, e, f];
+	      var argIndex = 0;
+	      error = new Error(format.replace(/%s/g, function () {
+	        return args[argIndex++];
+	      }));
+	      error.name = 'Invariant Violation';
+	    }
+
+	    error.framesToPop = 1; // we don't care about invariant's own frame
+	    throw error;
+	  }
+	}
+
+	module.exports = invariant;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 9 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2014-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _assign = __webpack_require__(4);
+
+	var ReactCurrentOwner = __webpack_require__(10);
+
+	var warning = __webpack_require__(11);
+	var canDefineProperty = __webpack_require__(13);
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+	var REACT_ELEMENT_TYPE = __webpack_require__(14);
+
+	var RESERVED_PROPS = {
+	  key: true,
+	  ref: true,
+	  __self: true,
+	  __source: true
+	};
+
+	var specialPropKeyWarningShown, specialPropRefWarningShown;
+
+	function hasValidRef(config) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    if (hasOwnProperty.call(config, 'ref')) {
+	      var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;
+	      if (getter && getter.isReactWarning) {
+	        return false;
+	      }
+	    }
+	  }
+	  return config.ref !== undefined;
+	}
+
+	function hasValidKey(config) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    if (hasOwnProperty.call(config, 'key')) {
+	      var getter = Object.getOwnPropertyDescriptor(config, 'key').get;
+	      if (getter && getter.isReactWarning) {
+	        return false;
+	      }
+	    }
+	  }
+	  return config.key !== undefined;
+	}
+
+	function defineKeyPropWarningGetter(props, displayName) {
+	  var warnAboutAccessingKey = function () {
+	    if (!specialPropKeyWarningShown) {
+	      specialPropKeyWarningShown = true;
+	      process.env.NODE_ENV !== 'production' ? warning(false, '%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName) : void 0;
+	    }
+	  };
+	  warnAboutAccessingKey.isReactWarning = true;
+	  Object.defineProperty(props, 'key', {
+	    get: warnAboutAccessingKey,
+	    configurable: true
+	  });
+	}
+
+	function defineRefPropWarningGetter(props, displayName) {
+	  var warnAboutAccessingRef = function () {
+	    if (!specialPropRefWarningShown) {
+	      specialPropRefWarningShown = true;
+	      process.env.NODE_ENV !== 'production' ? warning(false, '%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName) : void 0;
+	    }
+	  };
+	  warnAboutAccessingRef.isReactWarning = true;
+	  Object.defineProperty(props, 'ref', {
+	    get: warnAboutAccessingRef,
+	    configurable: true
+	  });
+	}
+
+	/**
+	 * Factory method to create a new React element. This no longer adheres to
+	 * the class pattern, so do not use new to call it. Also, no instanceof check
+	 * will work. Instead test $$typeof field against Symbol.for('react.element') to check
+	 * if something is a React Element.
+	 *
+	 * @param {*} type
+	 * @param {*} key
+	 * @param {string|object} ref
+	 * @param {*} self A *temporary* helper to detect places where `this` is
+	 * different from the `owner` when React.createElement is called, so that we
+	 * can warn. We want to get rid of owner and replace string `ref`s with arrow
+	 * functions, and as long as `this` and owner are the same, there will be no
+	 * change in behavior.
+	 * @param {*} source An annotation object (added by a transpiler or otherwise)
+	 * indicating filename, line number, and/or other information.
+	 * @param {*} owner
+	 * @param {*} props
+	 * @internal
+	 */
+	var ReactElement = function (type, key, ref, self, source, owner, props) {
+	  var element = {
+	    // This tag allow us to uniquely identify this as a React Element
+	    $$typeof: REACT_ELEMENT_TYPE,
+
+	    // Built-in properties that belong on the element
+	    type: type,
+	    key: key,
+	    ref: ref,
+	    props: props,
+
+	    // Record the component responsible for creating this element.
+	    _owner: owner
+	  };
+
+	  if (process.env.NODE_ENV !== 'production') {
+	    // The validation flag is currently mutative. We put it on
+	    // an external backing store so that we can freeze the whole object.
+	    // This can be replaced with a WeakMap once they are implemented in
+	    // commonly used development environments.
+	    element._store = {};
+
+	    // To make comparing ReactElements easier for testing purposes, we make
+	    // the validation flag non-enumerable (where possible, which should
+	    // include every environment we run tests in), so the test framework
+	    // ignores it.
+	    if (canDefineProperty) {
+	      Object.defineProperty(element._store, 'validated', {
+	        configurable: false,
+	        enumerable: false,
+	        writable: true,
+	        value: false
+	      });
+	      // self and source are DEV only properties.
+	      Object.defineProperty(element, '_self', {
+	        configurable: false,
+	        enumerable: false,
+	        writable: false,
+	        value: self
+	      });
+	      // Two elements created in two different places should be considered
+	      // equal for testing purposes and therefore we hide it from enumeration.
+	      Object.defineProperty(element, '_source', {
+	        configurable: false,
+	        enumerable: false,
+	        writable: false,
+	        value: source
+	      });
+	    } else {
+	      element._store.validated = false;
+	      element._self = self;
+	      element._source = source;
+	    }
+	    if (Object.freeze) {
+	      Object.freeze(element.props);
+	      Object.freeze(element);
+	    }
+	  }
+
+	  return element;
+	};
+
+	/**
+	 * Create and return a new ReactElement of the given type.
+	 * See https://facebook.github.io/react/docs/top-level-api.html#react.createelement
+	 */
+	ReactElement.createElement = function (type, config, children) {
+	  var propName;
+
+	  // Reserved names are extracted
+	  var props = {};
+
+	  var key = null;
+	  var ref = null;
+	  var self = null;
+	  var source = null;
+
+	  if (config != null) {
+	    if (hasValidRef(config)) {
+	      ref = config.ref;
+	    }
+	    if (hasValidKey(config)) {
+	      key = '' + config.key;
+	    }
+
+	    self = config.__self === undefined ? null : config.__self;
+	    source = config.__source === undefined ? null : config.__source;
+	    // Remaining properties are added to a new props object
+	    for (propName in config) {
+	      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+	        props[propName] = config[propName];
+	      }
+	    }
+	  }
+
+	  // Children can be more than one argument, and those are transferred onto
+	  // the newly allocated props object.
+	  var childrenLength = arguments.length - 2;
+	  if (childrenLength === 1) {
+	    props.children = children;
+	  } else if (childrenLength > 1) {
+	    var childArray = Array(childrenLength);
+	    for (var i = 0; i < childrenLength; i++) {
+	      childArray[i] = arguments[i + 2];
+	    }
+	    if (process.env.NODE_ENV !== 'production') {
+	      if (Object.freeze) {
+	        Object.freeze(childArray);
+	      }
+	    }
+	    props.children = childArray;
+	  }
+
+	  // Resolve default props
+	  if (type && type.defaultProps) {
+	    var defaultProps = type.defaultProps;
+	    for (propName in defaultProps) {
+	      if (props[propName] === undefined) {
+	        props[propName] = defaultProps[propName];
+	      }
+	    }
+	  }
+	  if (process.env.NODE_ENV !== 'production') {
+	    if (key || ref) {
+	      if (typeof props.$$typeof === 'undefined' || props.$$typeof !== REACT_ELEMENT_TYPE) {
+	        var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;
+	        if (key) {
+	          defineKeyPropWarningGetter(props, displayName);
+	        }
+	        if (ref) {
+	          defineRefPropWarningGetter(props, displayName);
+	        }
+	      }
+	    }
+	  }
+	  return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
+	};
+
+	/**
+	 * Return a function that produces ReactElements of a given type.
+	 * See https://facebook.github.io/react/docs/top-level-api.html#react.createfactory
+	 */
+	ReactElement.createFactory = function (type) {
+	  var factory = ReactElement.createElement.bind(null, type);
+	  // Expose the type on the factory and the prototype so that it can be
+	  // easily accessed on elements. E.g. `<Foo />.type === Foo`.
+	  // This should not be named `constructor` since this may not be the function
+	  // that created the element, and it may not even be a constructor.
+	  // Legacy hook TODO: Warn if this is accessed
+	  factory.type = type;
+	  return factory;
+	};
+
+	ReactElement.cloneAndReplaceKey = function (oldElement, newKey) {
+	  var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
+
+	  return newElement;
+	};
+
+	/**
+	 * Clone and return a new ReactElement using element as the starting point.
+	 * See https://facebook.github.io/react/docs/top-level-api.html#react.cloneelement
+	 */
+	ReactElement.cloneElement = function (element, config, children) {
+	  var propName;
+
+	  // Original props are copied
+	  var props = _assign({}, element.props);
+
+	  // Reserved names are extracted
+	  var key = element.key;
+	  var ref = element.ref;
+	  // Self is preserved since the owner is preserved.
+	  var self = element._self;
+	  // Source is preserved since cloneElement is unlikely to be targeted by a
+	  // transpiler, and the original source is probably a better indicator of the
+	  // true owner.
+	  var source = element._source;
+
+	  // Owner will be preserved, unless ref is overridden
+	  var owner = element._owner;
+
+	  if (config != null) {
+	    if (hasValidRef(config)) {
+	      // Silently steal the ref from the parent.
+	      ref = config.ref;
+	      owner = ReactCurrentOwner.current;
+	    }
+	    if (hasValidKey(config)) {
+	      key = '' + config.key;
+	    }
+
+	    // Remaining properties override existing props
+	    var defaultProps;
+	    if (element.type && element.type.defaultProps) {
+	      defaultProps = element.type.defaultProps;
+	    }
+	    for (propName in config) {
+	      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+	        if (config[propName] === undefined && defaultProps !== undefined) {
+	          // Resolve default props
+	          props[propName] = defaultProps[propName];
+	        } else {
+	          props[propName] = config[propName];
+	        }
+	      }
+	    }
+	  }
+
+	  // Children can be more than one argument, and those are transferred onto
+	  // the newly allocated props object.
+	  var childrenLength = arguments.length - 2;
+	  if (childrenLength === 1) {
+	    props.children = children;
+	  } else if (childrenLength > 1) {
+	    var childArray = Array(childrenLength);
+	    for (var i = 0; i < childrenLength; i++) {
+	      childArray[i] = arguments[i + 2];
+	    }
+	    props.children = childArray;
+	  }
+
+	  return ReactElement(element.type, key, ref, self, source, owner, props);
+	};
+
+	/**
+	 * Verifies the object is a ReactElement.
+	 * See https://facebook.github.io/react/docs/top-level-api.html#react.isvalidelement
+	 * @param {?object} object
+	 * @return {boolean} True if `object` is a valid component.
+	 * @final
+	 */
+	ReactElement.isValidElement = function (object) {
+	  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+	};
+
+	module.exports = ReactElement;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 10 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'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;
+
+/***/ },
+/* 11 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2014-2015, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var emptyFunction = __webpack_require__(12);
+
+	/**
+	 * Similar to invariant but only logs a warning if the condition is not met.
+	 * This can be used to log issues in development environments in critical
+	 * paths. Removing the logging code for production environments will keep the
+	 * same logic and follow the same code paths.
+	 */
+
+	var warning = emptyFunction;
+
+	if (process.env.NODE_ENV !== 'production') {
+	  (function () {
+	    var printWarning = function printWarning(format) {
+	      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+	        args[_key - 1] = arguments[_key];
+	      }
+
+	      var argIndex = 0;
+	      var message = 'Warning: ' + format.replace(/%s/g, function () {
+	        return args[argIndex++];
+	      });
+	      if (typeof console !== 'undefined') {
+	        console.error(message);
+	      }
+	      try {
+	        // --- Welcome to debugging React ---
+	        // This error was thrown as a convenience so that you can use this stack
+	        // to find the callsite that caused this warning to fire.
+	        throw new Error(message);
+	      } catch (x) {}
+	    };
+
+	    warning = function warning(condition, format) {
+	      if (format === undefined) {
+	        throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
+	      }
+
+	      if (format.indexOf('Failed Composite propType: ') === 0) {
+	        return; // Ignore CompositeComponent proptype check.
+	      }
+
+	      if (!condition) {
+	        for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+	          args[_key2 - 2] = arguments[_key2];
+	        }
+
+	        printWarning.apply(undefined, [format].concat(args));
+	      }
+	    };
+	  })();
+	}
+
+	module.exports = warning;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 12 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	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.
+	 */
+	var emptyFunction = function emptyFunction() {};
+
+	emptyFunction.thatReturns = makeEmptyFunction;
+	emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
+	emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
+	emptyFunction.thatReturnsNull = makeEmptyFunction(null);
+	emptyFunction.thatReturnsThis = function () {
+	  return this;
+	};
+	emptyFunction.thatReturnsArgument = function (arg) {
+	  return arg;
+	};
+
+	module.exports = emptyFunction;
+
+/***/ },
+/* 13 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var canDefineProperty = false;
+	if (process.env.NODE_ENV !== 'production') {
+	  try {
+	    // $FlowFixMe https://github.com/facebook/flow/issues/285
+	    Object.defineProperty({}, 'x', { get: function () {} });
+	    canDefineProperty = true;
+	  } catch (x) {
+	    // IE will fail on defineProperty
+	  }
+	}
+
+	module.exports = canDefineProperty;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 14 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2014-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	// The Symbol used to tag the ReactElement type. If there is no native Symbol
+	// nor polyfill, then a plain number is used for performance.
+
+	var REACT_ELEMENT_TYPE = typeof Symbol === 'function' && Symbol['for'] && Symbol['for']('react.element') || 0xeac7;
+
+	module.exports = REACT_ELEMENT_TYPE;
+
+/***/ },
+/* 15 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(7);
+
+	var ReactCurrentOwner = __webpack_require__(10);
+	var REACT_ELEMENT_TYPE = __webpack_require__(14);
+
+	var getIteratorFn = __webpack_require__(16);
+	var invariant = __webpack_require__(8);
+	var KeyEscapeUtils = __webpack_require__(17);
+	var warning = __webpack_require__(11);
+
+	var SEPARATOR = '.';
+	var SUBSEPARATOR = ':';
+
+	/**
+	 * This is inlined from ReactElement since this file is shared between
+	 * isomorphic and renderers. We could extract this to a
+	 *
+	 */
+
+	/**
+	 * TODO: Test that a single child and an array with one item have the same key
+	 * pattern.
+	 */
+
+	var didWarnAboutMaps = false;
+
+	/**
+	 * 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}
+	 */
+	function getComponentKey(component, index) {
+	  // Do some typechecking here since we call this blindly. We want to ensure
+	  // that we don't block potential future ES APIs.
+	  if (component && typeof component === 'object' && component.key != null) {
+	    // Explicit key
+	    return KeyEscapeUtils.escape(component.key);
+	  }
+	  // Implicit key determined by the index in the set
+	  return index.toString(36);
+	}
+
+	/**
+	 * @param {?*} children Children tree container.
+	 * @param {!string} nameSoFar Name of the key path so far.
+	 * @param {!function} callback Callback to invoke with each child found.
+	 * @param {?*} traverseContext Used to pass information throughout the traversal
+	 * process.
+	 * @return {!number} The number of children in this subtree.
+	 */
+	function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {
+	  var type = typeof children;
+
+	  if (type === 'undefined' || type === 'boolean') {
+	    // All of the above are perceived as null.
+	    children = null;
+	  }
+
+	  if (children === null || type === 'string' || type === 'number' ||
+	  // The following is inlined from ReactElement. This means we can optimize
+	  // some checks. React Fiber also inlines this logic for similar purposes.
+	  type === 'object' && children.$$typeof === REACT_ELEMENT_TYPE) {
+	    callback(traverseContext, children,
+	    // 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.
+	    nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);
+	    return 1;
+	  }
+
+	  var child;
+	  var nextName;
+	  var subtreeCount = 0; // Count of children found in the current subtree.
+	  var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;
+
+	  if (Array.isArray(children)) {
+	    for (var i = 0; i < children.length; i++) {
+	      child = children[i];
+	      nextName = nextNamePrefix + getComponentKey(child, i);
+	      subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
+	    }
+	  } else {
+	    var iteratorFn = getIteratorFn(children);
+	    if (iteratorFn) {
+	      var iterator = iteratorFn.call(children);
+	      var step;
+	      if (iteratorFn !== children.entries) {
+	        var ii = 0;
+	        while (!(step = iterator.next()).done) {
+	          child = step.value;
+	          nextName = nextNamePrefix + getComponentKey(child, ii++);
+	          subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
+	        }
+	      } else {
+	        if (process.env.NODE_ENV !== 'production') {
+	          var mapsAsChildrenAddendum = '';
+	          if (ReactCurrentOwner.current) {
+	            var mapsAsChildrenOwnerName = ReactCurrentOwner.current.getName();
+	            if (mapsAsChildrenOwnerName) {
+	              mapsAsChildrenAddendum = ' Check the render method of `' + mapsAsChildrenOwnerName + '`.';
+	            }
+	          }
+	          process.env.NODE_ENV !== 'production' ? warning(didWarnAboutMaps, 'Using Maps as children is not yet fully supported. It is an ' + 'experimental feature that might be removed. Convert it to a ' + 'sequence / iterable of keyed ReactElements instead.%s', mapsAsChildrenAddendum) : void 0;
+	          didWarnAboutMaps = true;
+	        }
+	        // Iterator will provide entry [k,v] tuples rather than values.
+	        while (!(step = iterator.next()).done) {
+	          var entry = step.value;
+	          if (entry) {
+	            child = entry[1];
+	            nextName = nextNamePrefix + KeyEscapeUtils.escape(entry[0]) + SUBSEPARATOR + getComponentKey(child, 0);
+	            subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
+	          }
+	        }
+	      }
+	    } else if (type === 'object') {
+	      var addendum = '';
+	      if (process.env.NODE_ENV !== 'production') {
+	        addendum = ' If you meant to render a collection of children, use an array ' + 'instead or wrap the object using createFragment(object) from the ' + 'React add-ons.';
+	        if (children._isReactElement) {
+	          addendum = ' It looks like you\'re using an element created by a different ' + 'version of React. Make sure to use only one copy of React.';
+	        }
+	        if (ReactCurrentOwner.current) {
+	          var name = ReactCurrentOwner.current.getName();
+	          if (name) {
+	            addendum += ' Check the render method of `' + name + '`.';
+	          }
+	        }
+	      }
+	      var childrenString = String(children);
+	       true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum) : _prodInvariant('31', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum) : void 0;
+	    }
+	  }
+
+	  return subtreeCount;
+	}
+
+	/**
+	 * Traverses children that are typically specified as `props.children`, but
+	 * might also be specified through attributes:
+	 *
+	 * - `traverseAllChildren(this.props.children, ...)`
+	 * - `traverseAllChildren(this.props.leftPanelChildren, ...)`
+	 *
+	 * The `traverseContext` is an optional argument that is passed through the
+	 * entire traversal. It can be used to store accumulations or anything else that
+	 * the callback might find relevant.
+	 *
+	 * @param {?*} children Children tree object.
+	 * @param {!function} callback To invoke upon traversing each child.
+	 * @param {?*} traverseContext Context for traversal.
+	 * @return {!number} The number of children in this subtree.
+	 */
+	function traverseAllChildren(children, callback, traverseContext) {
+	  if (children == null) {
+	    return 0;
+	  }
+
+	  return traverseAllChildrenImpl(children, '', callback, traverseContext);
+	}
+
+	module.exports = traverseAllChildren;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 16 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	/* global Symbol */
+
+	var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
+	var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
+
+	/**
+	 * Returns the iterator method function contained on the iterable object.
+	 *
+	 * Be sure to invoke the function with the iterable as context:
+	 *
+	 *     var iteratorFn = getIteratorFn(myIterable);
+	 *     if (iteratorFn) {
+	 *       var iterator = iteratorFn.call(myIterable);
+	 *       ...
+	 *     }
+	 *
+	 * @param {?object} maybeIterable
+	 * @return {?function}
+	 */
+	function getIteratorFn(maybeIterable) {
+	  var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
+	  if (typeof iteratorFn === 'function') {
+	    return iteratorFn;
+	  }
+	}
+
+	module.exports = getIteratorFn;
+
+/***/ },
+/* 17 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	/**
+	 * Escape and wrap key so it is safe to use as a reactid
+	 *
+	 * @param {string} key to be escaped.
+	 * @return {string} the escaped key.
+	 */
+
+	function escape(key) {
+	  var escapeRegex = /[=:]/g;
+	  var escaperLookup = {
+	    '=': '=0',
+	    ':': '=2'
+	  };
+	  var escapedString = ('' + key).replace(escapeRegex, function (match) {
+	    return escaperLookup[match];
+	  });
+
+	  return '$' + escapedString;
+	}
+
+	/**
+	 * Unescape and unwrap key for human-readable display
+	 *
+	 * @param {string} key to unescape.
+	 * @return {string} the unescaped key.
+	 */
+	function unescape(key) {
+	  var unescapeRegex = /(=0|=2)/g;
+	  var unescaperLookup = {
+	    '=0': '=',
+	    '=2': ':'
+	  };
+	  var keySubstring = key[0] === '.' && key[1] === '$' ? key.substring(2) : key.substring(1);
+
+	  return ('' + keySubstring).replace(unescapeRegex, function (match) {
+	    return unescaperLookup[match];
+	  });
+	}
+
+	var KeyEscapeUtils = {
+	  escape: escape,
+	  unescape: unescape
+	};
+
+	module.exports = KeyEscapeUtils;
+
+/***/ },
+/* 18 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(7);
+
+	var ReactNoopUpdateQueue = __webpack_require__(19);
+
+	var canDefineProperty = __webpack_require__(13);
+	var emptyObject = __webpack_require__(20);
+	var invariant = __webpack_require__(8);
+	var warning = __webpack_require__(11);
+
+	/**
+	 * Base class helpers for the updating state of a component.
+	 */
+	function ReactComponent(props, context, updater) {
+	  this.props = props;
+	  this.context = context;
+	  this.refs = emptyObject;
+	  // We initialize the default updater but the real one gets injected by the
+	  // renderer.
+	  this.updater = updater || ReactNoopUpdateQueue;
+	}
+
+	ReactComponent.prototype.isReactComponent = {};
+
+	/**
+	 * Sets a subset of the state. Always use this 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.
+	 *
+	 * There is no guarantee that calls to `setState` will run synchronously,
+	 * as they may eventually be batched together.  You can provide an optional
+	 * callback that will be executed when the call to setState is actually
+	 * completed.
+	 *
+	 * When a function is provided to setState, it will be called at some point in
+	 * the future (not synchronously). It will be called with the up to date
+	 * component arguments (state, props, context). These values can be different
+	 * from this.* because your function may be called after receiveProps but before
+	 * shouldComponentUpdate, and this new state, props, and context will not yet be
+	 * assigned to this.
+	 *
+	 * @param {object|function} partialState Next partial state or function to
+	 *        produce next partial state to be merged with current state.
+	 * @param {?function} callback Called after state is updated.
+	 * @final
+	 * @protected
+	 */
+	ReactComponent.prototype.setState = function (partialState, callback) {
+	  !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'setState(...): takes an object of state variables to update or a function which returns an object of state variables.') : _prodInvariant('85') : void 0;
+	  this.updater.enqueueSetState(this, partialState);
+	  if (callback) {
+	    this.updater.enqueueCallback(this, callback, 'setState');
+	  }
+	};
+
+	/**
+	 * 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 `shouldComponentUpdate`, but it will invoke
+	 * `componentWillUpdate` and `componentDidUpdate`.
+	 *
+	 * @param {?function} callback Called after update is complete.
+	 * @final
+	 * @protected
+	 */
+	ReactComponent.prototype.forceUpdate = function (callback) {
+	  this.updater.enqueueForceUpdate(this);
+	  if (callback) {
+	    this.updater.enqueueCallback(this, callback, 'forceUpdate');
+	  }
+	};
+
+	/**
+	 * Deprecated APIs. These APIs used to exist on classic React classes but since
+	 * we would like to deprecate them, we're not going to move them over to this
+	 * modern base class. Instead, we define a getter that warns if it's accessed.
+	 */
+	if (process.env.NODE_ENV !== 'production') {
+	  var deprecatedAPIs = {
+	    isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],
+	    replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']
+	  };
+	  var defineDeprecationWarning = function (methodName, info) {
+	    if (canDefineProperty) {
+	      Object.defineProperty(ReactComponent.prototype, methodName, {
+	        get: function () {
+	          process.env.NODE_ENV !== 'production' ? warning(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]) : void 0;
+	          return undefined;
+	        }
+	      });
+	    }
+	  };
+	  for (var fnName in deprecatedAPIs) {
+	    if (deprecatedAPIs.hasOwnProperty(fnName)) {
+	      defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
+	    }
+	  }
+	}
+
+	module.exports = ReactComponent;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 19 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2015-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var warning = __webpack_require__(11);
+
+	function warnNoop(publicInstance, callerName) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    var constructor = publicInstance.constructor;
+	    process.env.NODE_ENV !== 'production' ? warning(false, '%s(...): Can only update a mounted or mounting component. ' + 'This usually means you called %s() on an unmounted component. ' + 'This is a no-op. Please check the code for the %s component.', callerName, callerName, constructor && (constructor.displayName || constructor.name) || 'ReactClass') : void 0;
+	  }
+	}
+
+	/**
+	 * This is the abstract API for an update queue.
+	 */
+	var ReactNoopUpdateQueue = {
+
+	  /**
+	   * Checks whether or not this composite component is mounted.
+	   * @param {ReactClass} publicInstance The instance we want to test.
+	   * @return {boolean} True if mounted, false otherwise.
+	   * @protected
+	   * @final
+	   */
+	  isMounted: function (publicInstance) {
+	    return false;
+	  },
+
+	  /**
+	   * Enqueue a callback that will be executed after all the pending updates
+	   * have processed.
+	   *
+	   * @param {ReactClass} publicInstance The instance to use as `this` context.
+	   * @param {?function} callback Called after state is updated.
+	   * @internal
+	   */
+	  enqueueCallback: function (publicInstance, callback) {},
+
+	  /**
+	   * 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 `shouldComponentUpdate`, but it will invoke
+	   * `componentWillUpdate` and `componentDidUpdate`.
+	   *
+	   * @param {ReactClass} publicInstance The instance that should rerender.
+	   * @internal
+	   */
+	  enqueueForceUpdate: function (publicInstance) {
+	    warnNoop(publicInstance, 'forceUpdate');
+	  },
+
+	  /**
+	   * 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 {ReactClass} publicInstance The instance that should rerender.
+	   * @param {object} completeState Next state.
+	   * @internal
+	   */
+	  enqueueReplaceState: function (publicInstance, completeState) {
+	    warnNoop(publicInstance, 'replaceState');
+	  },
+
+	  /**
+	   * Sets a subset of the state. This only exists because _pendingState is
+	   * internal. This provides a merging strategy that is not available to deep
+	   * properties which is confusing. TODO: Expose pendingState or don't use it
+	   * during the merge.
+	   *
+	   * @param {ReactClass} publicInstance The instance that should rerender.
+	   * @param {object} partialState Next partial state to be merged with state.
+	   * @internal
+	   */
+	  enqueueSetState: function (publicInstance, partialState) {
+	    warnNoop(publicInstance, 'setState');
+	  }
+	};
+
+	module.exports = ReactNoopUpdateQueue;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 20 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var emptyObject = {};
+
+	if (process.env.NODE_ENV !== 'production') {
+	  Object.freeze(emptyObject);
+	}
+
+	module.exports = emptyObject;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 21 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _assign = __webpack_require__(4);
+
+	var ReactComponent = __webpack_require__(18);
+	var ReactNoopUpdateQueue = __webpack_require__(19);
+
+	var emptyObject = __webpack_require__(20);
+
+	/**
+	 * Base class helpers for the updating state of a component.
+	 */
+	function ReactPureComponent(props, context, updater) {
+	  // Duplicated from ReactComponent.
+	  this.props = props;
+	  this.context = context;
+	  this.refs = emptyObject;
+	  // We initialize the default updater but the real one gets injected by the
+	  // renderer.
+	  this.updater = updater || ReactNoopUpdateQueue;
+	}
+
+	function ComponentDummy() {}
+	ComponentDummy.prototype = ReactComponent.prototype;
+	ReactPureComponent.prototype = new ComponentDummy();
+	ReactPureComponent.prototype.constructor = ReactPureComponent;
+	// Avoid an extra prototype jump for these methods.
+	_assign(ReactPureComponent.prototype, ReactComponent.prototype);
+	ReactPureComponent.prototype.isPureReactComponent = true;
+
+	module.exports = ReactPureComponent;
+
+/***/ },
+/* 22 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(7),
+	    _assign = __webpack_require__(4);
+
+	var ReactComponent = __webpack_require__(18);
+	var ReactElement = __webpack_require__(9);
+	var ReactPropTypeLocationNames = __webpack_require__(23);
+	var ReactNoopUpdateQueue = __webpack_require__(19);
+
+	var emptyObject = __webpack_require__(20);
+	var invariant = __webpack_require__(8);
+	var warning = __webpack_require__(11);
+
+	var MIXINS_KEY = 'mixins';
+
+	// Helper function to allow the creation of anonymous functions which do not
+	// have .name set to the name of the variable being assigned to.
+	function identity(fn) {
+	  return fn;
+	}
+
+	/**
+	 * Policies that describe methods in `ReactClassInterface`.
+	 */
+
+
+	var injectedMixins = [];
+
+	/**
+	 * Composite components are higher-level components that compose other composite
+	 * or host components.
+	 *
+	 * To create a new type of `ReactClass`, 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 `ReactClassInterface` for
+	 * more the comprehensive protocol. Any other properties and methods in the
+	 * class specification will be available on the prototype.
+	 *
+	 * @interface ReactClassInterface
+	 * @internal
+	 */
+	var ReactClassInterface = {
+
+	  /**
+	   * An array of Mixin objects to include when defining your component.
+	   *
+	   * @type {array}
+	   * @optional
+	   */
+	  mixins: 'DEFINE_MANY',
+
+	  /**
+	   * An object containing properties and methods that should be defined on
+	   * the component's constructor instead of its prototype (static methods).
+	   *
+	   * @type {object}
+	   * @optional
+	   */
+	  statics: 'DEFINE_MANY',
+
+	  /**
+	   * Definition of prop types for this component.
+	   *
+	   * @type {object}
+	   * @optional
+	   */
+	  propTypes: 'DEFINE_MANY',
+
+	  /**
+	   * Definition of context types for this component.
+	   *
+	   * @type {object}
+	   * @optional
+	   */
+	  contextTypes: 'DEFINE_MANY',
+
+	  /**
+	   * Definition of context types this component sets for its children.
+	   *
+	   * @type {object}
+	   * @optional
+	   */
+	  childContextTypes: 'DEFINE_MANY',
+
+	  // ==== Definition methods ====
+
+	  /**
+	   * 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`.
+	   *
+	   * @return {object}
+	   * @optional
+	   */
+	  getDefaultProps: 'DEFINE_MANY_MERGED',
+
+	  /**
+	   * 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: 'DEFINE_MANY_MERGED',
+
+	  /**
+	   * @return {object}
+	   * @optional
+	   */
+	  getChildContext: 'DEFINE_MANY_MERGED',
+
+	  /**
+	   * 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: '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: '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: '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, nextContext) {
+	   *     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: 'DEFINE_MANY',
+
+	  /**
+	   * Invoked while deciding if the component should be updated as a result of
+	   * receiving new props, state and/or context.
+	   *
+	   * Use this as an opportunity to `return false` when you're certain that the
+	   * transition to the new props/state/context will not require a component
+	   * update.
+	   *
+	   *   shouldComponentUpdate: function(nextProps, nextState, nextContext) {
+	   *     return !equal(nextProps, this.props) ||
+	   *       !equal(nextState, this.state) ||
+	   *       !equal(nextContext, this.context);
+	   *   }
+	   *
+	   * @param {object} nextProps
+	   * @param {?object} nextState
+	   * @param {?object} nextContext
+	   * @return {boolean} True if the component should update.
+	   * @optional
+	   */
+	  shouldComponentUpdate: 'DEFINE_ONCE',
+
+	  /**
+	   * Invoked when the component is about to update due to a transition from
+	   * `this.props`, `this.state` and `this.context` to `nextProps`, `nextState`
+	   * and `nextContext`.
+	   *
+	   * 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 {?object} nextContext
+	   * @param {ReactReconcileTransaction} transaction
+	   * @optional
+	   */
+	  componentWillUpdate: '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 {?object} prevContext
+	   * @param {DOMElement} rootNode DOM element representing the component.
+	   * @optional
+	   */
+	  componentDidUpdate: '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: '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: 'OVERRIDE_BASE'
+
+	};
+
+	/**
+	 * Mapping from class specification keys to special processing functions.
+	 *
+	 * Although these are declared like instance properties in the specification
+	 * when defining classes using `React.createClass`, they are actually static
+	 * and are accessible on the constructor instead of the prototype. Despite
+	 * being static, they must be defined outside of the "statics" key under
+	 * which all other static methods are defined.
+	 */
+	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]);
+	      }
+	    }
+	  },
+	  childContextTypes: function (Constructor, childContextTypes) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      validateTypeDef(Constructor, childContextTypes, 'childContext');
+	    }
+	    Constructor.childContextTypes = _assign({}, Constructor.childContextTypes, childContextTypes);
+	  },
+	  contextTypes: function (Constructor, contextTypes) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      validateTypeDef(Constructor, contextTypes, 'context');
+	    }
+	    Constructor.contextTypes = _assign({}, Constructor.contextTypes, contextTypes);
+	  },
+	  /**
+	   * Special case getDefaultProps which should move into statics but requires
+	   * automatic merging.
+	   */
+	  getDefaultProps: function (Constructor, getDefaultProps) {
+	    if (Constructor.getDefaultProps) {
+	      Constructor.getDefaultProps = createMergedResultFunction(Constructor.getDefaultProps, getDefaultProps);
+	    } else {
+	      Constructor.getDefaultProps = getDefaultProps;
+	    }
+	  },
+	  propTypes: function (Constructor, propTypes) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      validateTypeDef(Constructor, propTypes, 'prop');
+	    }
+	    Constructor.propTypes = _assign({}, Constructor.propTypes, propTypes);
+	  },
+	  statics: function (Constructor, statics) {
+	    mixStaticSpecIntoComponent(Constructor, statics);
+	  },
+	  autobind: function () {} };
+
+	function validateTypeDef(Constructor, typeDef, location) {
+	  for (var propName in typeDef) {
+	    if (typeDef.hasOwnProperty(propName)) {
+	      // use a warning instead of an invariant so components
+	      // don't show up in prod but only in __DEV__
+	      process.env.NODE_ENV !== 'production' ? warning(typeof typeDef[propName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'React.PropTypes.', Constructor.displayName || 'ReactClass', ReactPropTypeLocationNames[location], propName) : void 0;
+	    }
+	  }
+	}
+
+	function validateMethodOverride(isAlreadyDefined, name) {
+	  var specPolicy = ReactClassInterface.hasOwnProperty(name) ? ReactClassInterface[name] : null;
+
+	  // Disallow overriding of base class methods unless explicitly allowed.
+	  if (ReactClassMixin.hasOwnProperty(name)) {
+	    !(specPolicy === 'OVERRIDE_BASE') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClassInterface: You are attempting to override `%s` from your class specification. Ensure that your method names do not overlap with React methods.', name) : _prodInvariant('73', name) : void 0;
+	  }
+
+	  // Disallow defining methods more than once unless explicitly allowed.
+	  if (isAlreadyDefined) {
+	    !(specPolicy === 'DEFINE_MANY' || specPolicy === 'DEFINE_MANY_MERGED') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClassInterface: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.', name) : _prodInvariant('74', name) : void 0;
+	  }
+	}
+
+	/**
+	 * Mixin helper which handles policy validation and reserved
+	 * specification keys when building React classes.
+	 */
+	function mixSpecIntoComponent(Constructor, spec) {
+	  if (!spec) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      var typeofSpec = typeof spec;
+	      var isMixinValid = typeofSpec === 'object' && spec !== null;
+
+	      process.env.NODE_ENV !== 'production' ? warning(isMixinValid, '%s: You\'re attempting to include a mixin that is either null ' + 'or not an object. Check the mixins included by the component, ' + 'as well as any mixins they include themselves. ' + 'Expected object but got %s.', Constructor.displayName || 'ReactClass', spec === null ? null : typeofSpec) : void 0;
+	    }
+
+	    return;
+	  }
+
+	  !(typeof spec !== 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: You\'re attempting to use a component class or function as a mixin. Instead, just use a regular object.') : _prodInvariant('75') : void 0;
+	  !!ReactElement.isValidElement(spec) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: You\'re attempting to use a component as a mixin. Instead, just use a regular object.') : _prodInvariant('76') : void 0;
+
+	  var proto = Constructor.prototype;
+	  var autoBindPairs = proto.__reactAutoBindPairs;
+
+	  // By handling mixins before any other properties, we ensure the same
+	  // chaining order is applied to methods with DEFINE_MANY policy, whether
+	  // mixins are listed before or after these methods in the spec.
+	  if (spec.hasOwnProperty(MIXINS_KEY)) {
+	    RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins);
+	  }
+
+	  for (var name in spec) {
+	    if (!spec.hasOwnProperty(name)) {
+	      continue;
+	    }
+
+	    if (name === MIXINS_KEY) {
+	      // We have already handled mixins in a special case above.
+	      continue;
+	    }
+
+	    var property = spec[name];
+	    var isAlreadyDefined = proto.hasOwnProperty(name);
+	    validateMethodOverride(isAlreadyDefined, name);
+
+	    if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {
+	      RESERVED_SPEC_KEYS[name](Constructor, property);
+	    } else {
+	      // Setup methods on prototype:
+	      // The following member methods should not be automatically bound:
+	      // 1. Expected ReactClass methods (in the "interface").
+	      // 2. Overridden methods (that were mixed in).
+	      var isReactClassMethod = ReactClassInterface.hasOwnProperty(name);
+	      var isFunction = typeof property === 'function';
+	      var shouldAutoBind = isFunction && !isReactClassMethod && !isAlreadyDefined && spec.autobind !== false;
+
+	      if (shouldAutoBind) {
+	        autoBindPairs.push(name, property);
+	        proto[name] = property;
+	      } else {
+	        if (isAlreadyDefined) {
+	          var specPolicy = ReactClassInterface[name];
+
+	          // These cases should already be caught by validateMethodOverride.
+	          !(isReactClassMethod && (specPolicy === 'DEFINE_MANY_MERGED' || specPolicy === 'DEFINE_MANY')) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: Unexpected spec policy %s for key %s when mixing in component specs.', specPolicy, name) : _prodInvariant('77', specPolicy, name) : void 0;
+
+	          // For methods which are defined more than once, call the existing
+	          // methods before calling the new property, merging if appropriate.
+	          if (specPolicy === 'DEFINE_MANY_MERGED') {
+	            proto[name] = createMergedResultFunction(proto[name], property);
+	          } else if (specPolicy === 'DEFINE_MANY') {
+	            proto[name] = createChainedFunction(proto[name], property);
+	          }
+	        } else {
+	          proto[name] = property;
+	          if (process.env.NODE_ENV !== 'production') {
+	            // Add verbose displayName to the function, which helps when looking
+	            // at profiling tools.
+	            if (typeof property === 'function' && spec.displayName) {
+	              proto[name].displayName = spec.displayName + '_' + name;
+	            }
+	          }
+	        }
+	      }
+	    }
+	  }
+	}
+
+	function mixStaticSpecIntoComponent(Constructor, statics) {
+	  if (!statics) {
+	    return;
+	  }
+	  for (var name in statics) {
+	    var property = statics[name];
+	    if (!statics.hasOwnProperty(name)) {
+	      continue;
+	    }
+
+	    var isReserved = name in RESERVED_SPEC_KEYS;
+	    !!isReserved ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: You are attempting to define a reserved property, `%s`, that shouldn\'t be on the "statics" key. Define it as an instance property instead; it will still be accessible on the constructor.', name) : _prodInvariant('78', name) : void 0;
+
+	    var isInherited = name in Constructor;
+	    !!isInherited ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.', name) : _prodInvariant('79', name) : void 0;
+	    Constructor[name] = property;
+	  }
+	}
+
+	/**
+	 * Merge two objects, but throw if both contain the same key.
+	 *
+	 * @param {object} one The first object, which is mutated.
+	 * @param {object} two The second object
+	 * @return {object} one after it has been mutated to contain everything in two.
+	 */
+	function mergeIntoWithNoDuplicateKeys(one, two) {
+	  !(one && two && typeof one === 'object' && typeof two === 'object') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.') : _prodInvariant('80') : void 0;
+
+	  for (var key in two) {
+	    if (two.hasOwnProperty(key)) {
+	      !(one[key] === undefined) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'mergeIntoWithNoDuplicateKeys(): Tried to merge two objects with the same key: `%s`. This conflict may be due to a mixin; in particular, this may be caused by two getInitialState() or getDefaultProps() methods returning objects with clashing keys.', key) : _prodInvariant('81', key) : void 0;
+	      one[key] = two[key];
+	    }
+	  }
+	  return one;
+	}
+
+	/**
+	 * Creates a function that invokes two functions and merges their return values.
+	 *
+	 * @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 createMergedResultFunction(one, two) {
+	  return function mergedResult() {
+	    var a = one.apply(this, arguments);
+	    var b = two.apply(this, arguments);
+	    if (a == null) {
+	      return b;
+	    } else if (b == null) {
+	      return a;
+	    }
+	    var c = {};
+	    mergeIntoWithNoDuplicateKeys(c, a);
+	    mergeIntoWithNoDuplicateKeys(c, b);
+	    return c;
+	  };
+	}
+
+	/**
+	 * 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() {
+	    one.apply(this, arguments);
+	    two.apply(this, arguments);
+	  };
+	}
+
+	/**
+	 * Binds a method to the component.
+	 *
+	 * @param {object} component Component whose method is going to be bound.
+	 * @param {function} method Method to be bound.
+	 * @return {function} The bound method.
+	 */
+	function bindAutoBindMethod(component, method) {
+	  var boundMethod = method.bind(component);
+	  if (process.env.NODE_ENV !== 'production') {
+	    boundMethod.__reactBoundContext = component;
+	    boundMethod.__reactBoundMethod = method;
+	    boundMethod.__reactBoundArguments = null;
+	    var componentName = component.constructor.displayName;
+	    var _bind = boundMethod.bind;
+	    boundMethod.bind = function (newThis) {
+	      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+	        args[_key - 1] = arguments[_key];
+	      }
+
+	      // User is trying to bind() an autobound method; we effectively will
+	      // ignore the value of "this" that the user is trying to use, so
+	      // let's warn.
+	      if (newThis !== component && newThis !== null) {
+	        process.env.NODE_ENV !== 'production' ? warning(false, 'bind(): React component methods may only be bound to the ' + 'component instance. See %s', componentName) : void 0;
+	      } else if (!args.length) {
+	        process.env.NODE_ENV !== 'production' ? warning(false, 'bind(): You are binding a component method to the component. ' + 'React does this for you automatically in a high-performance ' + 'way, so you can safely remove this call. See %s', componentName) : void 0;
+	        return boundMethod;
+	      }
+	      var reboundMethod = _bind.apply(boundMethod, arguments);
+	      reboundMethod.__reactBoundContext = component;
+	      reboundMethod.__reactBoundMethod = method;
+	      reboundMethod.__reactBoundArguments = args;
+	      return reboundMethod;
+	    };
+	  }
+	  return boundMethod;
+	}
+
+	/**
+	 * Binds all auto-bound methods in a component.
+	 *
+	 * @param {object} component Component whose method is going to be bound.
+	 */
+	function bindAutoBindMethods(component) {
+	  var pairs = component.__reactAutoBindPairs;
+	  for (var i = 0; i < pairs.length; i += 2) {
+	    var autoBindKey = pairs[i];
+	    var method = pairs[i + 1];
+	    component[autoBindKey] = bindAutoBindMethod(component, method);
+	  }
+	}
+
+	/**
+	 * Add more to the ReactClass base class. These are all legacy features and
+	 * therefore not already part of the modern ReactComponent.
+	 */
+	var ReactClassMixin = {
+
+	  /**
+	   * TODO: This will be deprecated because state should always keep a consistent
+	   * type signature and the only use case for this, is to avoid that.
+	   */
+	  replaceState: function (newState, callback) {
+	    this.updater.enqueueReplaceState(this, newState);
+	    if (callback) {
+	      this.updater.enqueueCallback(this, callback, 'replaceState');
+	    }
+	  },
+
+	  /**
+	   * Checks whether or not this composite component is mounted.
+	   * @return {boolean} True if mounted, false otherwise.
+	   * @protected
+	   * @final
+	   */
+	  isMounted: function () {
+	    return this.updater.isMounted(this);
+	  }
+	};
+
+	var ReactClassComponent = function () {};
+	_assign(ReactClassComponent.prototype, ReactComponent.prototype, ReactClassMixin);
+
+	/**
+	 * Module for creating composite components.
+	 *
+	 * @class ReactClass
+	 */
+	var ReactClass = {
+
+	  /**
+	   * Creates a composite component class given a class specification.
+	   * See https://facebook.github.io/react/docs/top-level-api.html#react.createclass
+	   *
+	   * @param {object} spec Class specification (which must define `render`).
+	   * @return {function} Component constructor function.
+	   * @public
+	   */
+	  createClass: function (spec) {
+	    // To keep our warnings more understandable, we'll use a little hack here to
+	    // ensure that Constructor.name !== 'Constructor'. This makes sure we don't
+	    // unnecessarily identify a class without displayName as 'Constructor'.
+	    var Constructor = identity(function (props, context, updater) {
+	      // This constructor gets overridden by mocks. The argument is used
+	      // by mocks to assert on what gets mounted.
+
+	      if (process.env.NODE_ENV !== 'production') {
+	        process.env.NODE_ENV !== 'production' ? warning(this instanceof Constructor, 'Something is calling a React component directly. Use a factory or ' + 'JSX instead. See: https://fb.me/react-legacyfactory') : void 0;
+	      }
+
+	      // Wire up auto-binding
+	      if (this.__reactAutoBindPairs.length) {
+	        bindAutoBindMethods(this);
+	      }
+
+	      this.props = props;
+	      this.context = context;
+	      this.refs = emptyObject;
+	      this.updater = updater || ReactNoopUpdateQueue;
+
+	      this.state = null;
+
+	      // ReactClasses doesn't have constructors. Instead, they use the
+	      // getInitialState and componentWillMount methods for initialization.
+
+	      var initialState = this.getInitialState ? this.getInitialState() : null;
+	      if (process.env.NODE_ENV !== 'production') {
+	        // We allow auto-mocks to proceed as if they're returning null.
+	        if (initialState === undefined && this.getInitialState._isMockFunction) {
+	          // This is probably bad practice. Consider warning here and
+	          // deprecating this convenience.
+	          initialState = null;
+	        }
+	      }
+	      !(typeof initialState === 'object' && !Array.isArray(initialState)) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.getInitialState(): must return an object or null', Constructor.displayName || 'ReactCompositeComponent') : _prodInvariant('82', Constructor.displayName || 'ReactCompositeComponent') : void 0;
+
+	      this.state = initialState;
+	    });
+	    Constructor.prototype = new ReactClassComponent();
+	    Constructor.prototype.constructor = Constructor;
+	    Constructor.prototype.__reactAutoBindPairs = [];
+
+	    injectedMixins.forEach(mixSpecIntoComponent.bind(null, Constructor));
+
+	    mixSpecIntoComponent(Constructor, spec);
+
+	    // Initialize the defaultProps property after all mixins have been merged.
+	    if (Constructor.getDefaultProps) {
+	      Constructor.defaultProps = Constructor.getDefaultProps();
+	    }
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      // This is a tag to indicate that the use of these method names is ok,
+	      // since it's used with createClass. If it's not, then it's likely a
+	      // mistake so we'll warn you to use the static property, property
+	      // initializer or constructor respectively.
+	      if (Constructor.getDefaultProps) {
+	        Constructor.getDefaultProps.isReactClassApproved = {};
+	      }
+	      if (Constructor.prototype.getInitialState) {
+	        Constructor.prototype.getInitialState.isReactClassApproved = {};
+	      }
+	    }
+
+	    !Constructor.prototype.render ? process.env.NODE_ENV !== 'production' ? invariant(false, 'createClass(...): Class specification must implement a `render` method.') : _prodInvariant('83') : void 0;
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      process.env.NODE_ENV !== 'production' ? warning(!Constructor.prototype.componentShouldUpdate, '%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', spec.displayName || 'A component') : void 0;
+	      process.env.NODE_ENV !== 'production' ? warning(!Constructor.prototype.componentWillRecieveProps, '%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', spec.displayName || 'A component') : void 0;
+	    }
+
+	    // Reduce time spent doing lookups by setting these on the prototype.
+	    for (var methodName in ReactClassInterface) {
+	      if (!Constructor.prototype[methodName]) {
+	        Constructor.prototype[methodName] = null;
+	      }
+	    }
+
+	    return Constructor;
+	  },
+
+	  injection: {
+	    injectMixin: function (mixin) {
+	      injectedMixins.push(mixin);
+	    }
+	  }
+
+	};
+
+	module.exports = ReactClass;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 23 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var ReactPropTypeLocationNames = {};
+
+	if (process.env.NODE_ENV !== 'production') {
+	  ReactPropTypeLocationNames = {
+	    prop: 'prop',
+	    context: 'context',
+	    childContext: 'child context'
+	  };
+	}
+
+	module.exports = ReactPropTypeLocationNames;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 24 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ReactElement = __webpack_require__(9);
+
+	/**
+	 * Create a factory that creates HTML tag elements.
+	 *
+	 * @private
+	 */
+	var createDOMFactory = ReactElement.createFactory;
+	if (process.env.NODE_ENV !== 'production') {
+	  var ReactElementValidator = __webpack_require__(25);
+	  createDOMFactory = ReactElementValidator.createFactory;
+	}
+
+	/**
+	 * Creates a mapping from supported HTML tags to `ReactDOMComponent` classes.
+	 * This is also accessible via `React.DOM`.
+	 *
+	 * @public
+	 */
+	var ReactDOMFactories = {
+	  a: createDOMFactory('a'),
+	  abbr: createDOMFactory('abbr'),
+	  address: createDOMFactory('address'),
+	  area: createDOMFactory('area'),
+	  article: createDOMFactory('article'),
+	  aside: createDOMFactory('aside'),
+	  audio: createDOMFactory('audio'),
+	  b: createDOMFactory('b'),
+	  base: createDOMFactory('base'),
+	  bdi: createDOMFactory('bdi'),
+	  bdo: createDOMFactory('bdo'),
+	  big: createDOMFactory('big'),
+	  blockquote: createDOMFactory('blockquote'),
+	  body: createDOMFactory('body'),
+	  br: createDOMFactory('br'),
+	  button: createDOMFactory('button'),
+	  canvas: createDOMFactory('canvas'),
+	  caption: createDOMFactory('caption'),
+	  cite: createDOMFactory('cite'),
+	  code: createDOMFactory('code'),
+	  col: createDOMFactory('col'),
+	  colgroup: createDOMFactory('colgroup'),
+	  data: createDOMFactory('data'),
+	  datalist: createDOMFactory('datalist'),
+	  dd: createDOMFactory('dd'),
+	  del: createDOMFactory('del'),
+	  details: createDOMFactory('details'),
+	  dfn: createDOMFactory('dfn'),
+	  dialog: createDOMFactory('dialog'),
+	  div: createDOMFactory('div'),
+	  dl: createDOMFactory('dl'),
+	  dt: createDOMFactory('dt'),
+	  em: createDOMFactory('em'),
+	  embed: createDOMFactory('embed'),
+	  fieldset: createDOMFactory('fieldset'),
+	  figcaption: createDOMFactory('figcaption'),
+	  figure: createDOMFactory('figure'),
+	  footer: createDOMFactory('footer'),
+	  form: createDOMFactory('form'),
+	  h1: createDOMFactory('h1'),
+	  h2: createDOMFactory('h2'),
+	  h3: createDOMFactory('h3'),
+	  h4: createDOMFactory('h4'),
+	  h5: createDOMFactory('h5'),
+	  h6: createDOMFactory('h6'),
+	  head: createDOMFactory('head'),
+	  header: createDOMFactory('header'),
+	  hgroup: createDOMFactory('hgroup'),
+	  hr: createDOMFactory('hr'),
+	  html: createDOMFactory('html'),
+	  i: createDOMFactory('i'),
+	  iframe: createDOMFactory('iframe'),
+	  img: createDOMFactory('img'),
+	  input: createDOMFactory('input'),
+	  ins: createDOMFactory('ins'),
+	  kbd: createDOMFactory('kbd'),
+	  keygen: createDOMFactory('keygen'),
+	  label: createDOMFactory('label'),
+	  legend: createDOMFactory('legend'),
+	  li: createDOMFactory('li'),
+	  link: createDOMFactory('link'),
+	  main: createDOMFactory('main'),
+	  map: createDOMFactory('map'),
+	  mark: createDOMFactory('mark'),
+	  menu: createDOMFactory('menu'),
+	  menuitem: createDOMFactory('menuitem'),
+	  meta: createDOMFactory('meta'),
+	  meter: createDOMFactory('meter'),
+	  nav: createDOMFactory('nav'),
+	  noscript: createDOMFactory('noscript'),
+	  object: createDOMFactory('object'),
+	  ol: createDOMFactory('ol'),
+	  optgroup: createDOMFactory('optgroup'),
+	  option: createDOMFactory('option'),
+	  output: createDOMFactory('output'),
+	  p: createDOMFactory('p'),
+	  param: createDOMFactory('param'),
+	  picture: createDOMFactory('picture'),
+	  pre: createDOMFactory('pre'),
+	  progress: createDOMFactory('progress'),
+	  q: createDOMFactory('q'),
+	  rp: createDOMFactory('rp'),
+	  rt: createDOMFactory('rt'),
+	  ruby: createDOMFactory('ruby'),
+	  s: createDOMFactory('s'),
+	  samp: createDOMFactory('samp'),
+	  script: createDOMFactory('script'),
+	  section: createDOMFactory('section'),
+	  select: createDOMFactory('select'),
+	  small: createDOMFactory('small'),
+	  source: createDOMFactory('source'),
+	  span: createDOMFactory('span'),
+	  strong: createDOMFactory('strong'),
+	  style: createDOMFactory('style'),
+	  sub: createDOMFactory('sub'),
+	  summary: createDOMFactory('summary'),
+	  sup: createDOMFactory('sup'),
+	  table: createDOMFactory('table'),
+	  tbody: createDOMFactory('tbody'),
+	  td: createDOMFactory('td'),
+	  textarea: createDOMFactory('textarea'),
+	  tfoot: createDOMFactory('tfoot'),
+	  th: createDOMFactory('th'),
+	  thead: createDOMFactory('thead'),
+	  time: createDOMFactory('time'),
+	  title: createDOMFactory('title'),
+	  tr: createDOMFactory('tr'),
+	  track: createDOMFactory('track'),
+	  u: createDOMFactory('u'),
+	  ul: createDOMFactory('ul'),
+	  'var': createDOMFactory('var'),
+	  video: createDOMFactory('video'),
+	  wbr: createDOMFactory('wbr'),
+
+	  // SVG
+	  circle: createDOMFactory('circle'),
+	  clipPath: createDOMFactory('clipPath'),
+	  defs: createDOMFactory('defs'),
+	  ellipse: createDOMFactory('ellipse'),
+	  g: createDOMFactory('g'),
+	  image: createDOMFactory('image'),
+	  line: createDOMFactory('line'),
+	  linearGradient: createDOMFactory('linearGradient'),
+	  mask: createDOMFactory('mask'),
+	  path: createDOMFactory('path'),
+	  pattern: createDOMFactory('pattern'),
+	  polygon: createDOMFactory('polygon'),
+	  polyline: createDOMFactory('polyline'),
+	  radialGradient: createDOMFactory('radialGradient'),
+	  rect: createDOMFactory('rect'),
+	  stop: createDOMFactory('stop'),
+	  svg: createDOMFactory('svg'),
+	  text: createDOMFactory('text'),
+	  tspan: createDOMFactory('tspan')
+	};
+
+	module.exports = ReactDOMFactories;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 25 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2014-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	/**
+	 * ReactElementValidator provides a wrapper around a element factory
+	 * which validates the props passed to the element. This is intended to be
+	 * used only in DEV and could be replaced by a static type checker for languages
+	 * that support it.
+	 */
+
+	'use strict';
+
+	var ReactCurrentOwner = __webpack_require__(10);
+	var ReactComponentTreeHook = __webpack_require__(26);
+	var ReactElement = __webpack_require__(9);
+
+	var checkReactTypeSpec = __webpack_require__(27);
+
+	var canDefineProperty = __webpack_require__(13);
+	var getIteratorFn = __webpack_require__(16);
+	var warning = __webpack_require__(11);
+
+	function getDeclarationErrorAddendum() {
+	  if (ReactCurrentOwner.current) {
+	    var name = ReactCurrentOwner.current.getName();
+	    if (name) {
+	      return ' Check the render method of `' + name + '`.';
+	    }
+	  }
+	  return '';
+	}
+
+	/**
+	 * Warn if there's no key explicitly set on dynamic arrays of children or
+	 * object keys are not valid. This allows us to keep track of children between
+	 * updates.
+	 */
+	var ownerHasKeyUseWarning = {};
+
+	function getCurrentComponentErrorInfo(parentType) {
+	  var info = getDeclarationErrorAddendum();
+
+	  if (!info) {
+	    var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;
+	    if (parentName) {
+	      info = ' Check the top-level render call using <' + parentName + '>.';
+	    }
+	  }
+	  return info;
+	}
+
+	/**
+	 * Warn if the element doesn't have an explicit key assigned to it.
+	 * This element is in an array. The array could grow and shrink or be
+	 * reordered. All children that haven't already been validated are required to
+	 * have a "key" property assigned to it. Error statuses are cached so a warning
+	 * will only be shown once.
+	 *
+	 * @internal
+	 * @param {ReactElement} element Element that requires a key.
+	 * @param {*} parentType element's parent's type.
+	 */
+	function validateExplicitKey(element, parentType) {
+	  if (!element._store || element._store.validated || element.key != null) {
+	    return;
+	  }
+	  element._store.validated = true;
+
+	  var memoizer = ownerHasKeyUseWarning.uniqueKey || (ownerHasKeyUseWarning.uniqueKey = {});
+
+	  var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
+	  if (memoizer[currentComponentErrorInfo]) {
+	    return;
+	  }
+	  memoizer[currentComponentErrorInfo] = true;
+
+	  // 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.
+	  var childOwner = '';
+	  if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
+	    // Give the component that originally created this child.
+	    childOwner = ' It was passed a child from ' + element._owner.getName() + '.';
+	  }
+
+	  process.env.NODE_ENV !== 'production' ? warning(false, 'Each child in an array or iterator should have a unique "key" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.%s', currentComponentErrorInfo, childOwner, ReactComponentTreeHook.getCurrentStackAddendum(element)) : void 0;
+	}
+
+	/**
+	 * Ensure that every element either is passed in a static location, in an
+	 * array with an explicit keys property defined, or in an object literal
+	 * with valid key property.
+	 *
+	 * @internal
+	 * @param {ReactNode} node Statically passed child of any type.
+	 * @param {*} parentType node's parent's type.
+	 */
+	function validateChildKeys(node, parentType) {
+	  if (typeof node !== 'object') {
+	    return;
+	  }
+	  if (Array.isArray(node)) {
+	    for (var i = 0; i < node.length; i++) {
+	      var child = node[i];
+	      if (ReactElement.isValidElement(child)) {
+	        validateExplicitKey(child, parentType);
+	      }
+	    }
+	  } else if (ReactElement.isValidElement(node)) {
+	    // This element was passed in a valid location.
+	    if (node._store) {
+	      node._store.validated = true;
+	    }
+	  } else if (node) {
+	    var iteratorFn = getIteratorFn(node);
+	    // Entry iterators provide implicit keys.
+	    if (iteratorFn) {
+	      if (iteratorFn !== node.entries) {
+	        var iterator = iteratorFn.call(node);
+	        var step;
+	        while (!(step = iterator.next()).done) {
+	          if (ReactElement.isValidElement(step.value)) {
+	            validateExplicitKey(step.value, parentType);
+	          }
+	        }
+	      }
+	    }
+	  }
+	}
+
+	/**
+	 * Given an element, validate that its props follow the propTypes definition,
+	 * provided by the type.
+	 *
+	 * @param {ReactElement} element
+	 */
+	function validatePropTypes(element) {
+	  var componentClass = element.type;
+	  if (typeof componentClass !== 'function') {
+	    return;
+	  }
+	  var name = componentClass.displayName || componentClass.name;
+	  if (componentClass.propTypes) {
+	    checkReactTypeSpec(componentClass.propTypes, element.props, 'prop', name, element, null);
+	  }
+	  if (typeof componentClass.getDefaultProps === 'function') {
+	    process.env.NODE_ENV !== 'production' ? warning(componentClass.getDefaultProps.isReactClassApproved, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.') : void 0;
+	  }
+	}
+
+	var ReactElementValidator = {
+
+	  createElement: function (type, props, children) {
+	    var validType = typeof type === 'string' || typeof type === 'function';
+	    // We warn in this case but don't throw. We expect the element creation to
+	    // succeed and there will likely be errors in render.
+	    if (!validType) {
+	      process.env.NODE_ENV !== 'production' ? warning(false, 'React.createElement: type should not be null, undefined, boolean, or ' + 'number. It should be a string (for DOM elements) or a ReactClass ' + '(for composite components).%s', getDeclarationErrorAddendum()) : void 0;
+	    }
+
+	    var element = ReactElement.createElement.apply(this, arguments);
+
+	    // The result can be nullish if a mock or a custom function is used.
+	    // TODO: Drop this when these are no longer allowed as the type argument.
+	    if (element == null) {
+	      return element;
+	    }
+
+	    // Skip key warning if the type isn't valid since our key validation logic
+	    // doesn't expect a non-string/function type and can throw confusing errors.
+	    // We don't want exception behavior to differ between dev and prod.
+	    // (Rendering will throw with a helpful message and as soon as the type is
+	    // fixed, the key warnings will appear.)
+	    if (validType) {
+	      for (var i = 2; i < arguments.length; i++) {
+	        validateChildKeys(arguments[i], type);
+	      }
+	    }
+
+	    validatePropTypes(element);
+
+	    return element;
+	  },
+
+	  createFactory: function (type) {
+	    var validatedFactory = ReactElementValidator.createElement.bind(null, type);
+	    // Legacy hook TODO: Warn if this is accessed
+	    validatedFactory.type = type;
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      if (canDefineProperty) {
+	        Object.defineProperty(validatedFactory, 'type', {
+	          enumerable: false,
+	          get: function () {
+	            process.env.NODE_ENV !== 'production' ? warning(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.') : void 0;
+	            Object.defineProperty(this, 'type', {
+	              value: type
+	            });
+	            return type;
+	          }
+	        });
+	      }
+	    }
+
+	    return validatedFactory;
+	  },
+
+	  cloneElement: function (element, props, children) {
+	    var newElement = ReactElement.cloneElement.apply(this, arguments);
+	    for (var i = 2; i < arguments.length; i++) {
+	      validateChildKeys(arguments[i], newElement.type);
+	    }
+	    validatePropTypes(newElement);
+	    return newElement;
+	  }
+
+	};
+
+	module.exports = ReactElementValidator;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 26 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2016-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(7);
+
+	var ReactCurrentOwner = __webpack_require__(10);
+
+	var invariant = __webpack_require__(8);
+	var warning = __webpack_require__(11);
+
+	function isNative(fn) {
+	  // Based on isNative() from Lodash
+	  var funcToString = Function.prototype.toString;
+	  var hasOwnProperty = Object.prototype.hasOwnProperty;
+	  var reIsNative = RegExp('^' + funcToString
+	  // Take an example native function source for comparison
+	  .call(hasOwnProperty)
+	  // Strip regex characters so we can use it for regex
+	  .replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
+	  // Remove hasOwnProperty from the template to make it generic
+	  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$');
+	  try {
+	    var source = funcToString.call(fn);
+	    return reIsNative.test(source);
+	  } catch (err) {
+	    return false;
+	  }
+	}
+
+	var canUseCollections =
+	// Array.from
+	typeof Array.from === 'function' &&
+	// Map
+	typeof Map === 'function' && isNative(Map) &&
+	// Map.prototype.keys
+	Map.prototype != null && typeof Map.prototype.keys === 'function' && isNative(Map.prototype.keys) &&
+	// Set
+	typeof Set === 'function' && isNative(Set) &&
+	// Set.prototype.keys
+	Set.prototype != null && typeof Set.prototype.keys === 'function' && isNative(Set.prototype.keys);
+
+	var setItem;
+	var getItem;
+	var removeItem;
+	var getItemIDs;
+	var addRoot;
+	var removeRoot;
+	var getRootIDs;
+
+	if (canUseCollections) {
+	  var itemMap = new Map();
+	  var rootIDSet = new Set();
+
+	  setItem = function (id, item) {
+	    itemMap.set(id, item);
+	  };
+	  getItem = function (id) {
+	    return itemMap.get(id);
+	  };
+	  removeItem = function (id) {
+	    itemMap['delete'](id);
+	  };
+	  getItemIDs = function () {
+	    return Array.from(itemMap.keys());
+	  };
+
+	  addRoot = function (id) {
+	    rootIDSet.add(id);
+	  };
+	  removeRoot = function (id) {
+	    rootIDSet['delete'](id);
+	  };
+	  getRootIDs = function () {
+	    return Array.from(rootIDSet.keys());
+	  };
+	} else {
+	  var itemByKey = {};
+	  var rootByKey = {};
+
+	  // Use non-numeric keys to prevent V8 performance issues:
+	  // https://github.com/facebook/react/pull/7232
+	  var getKeyFromID = function (id) {
+	    return '.' + id;
+	  };
+	  var getIDFromKey = function (key) {
+	    return parseInt(key.substr(1), 10);
+	  };
+
+	  setItem = function (id, item) {
+	    var key = getKeyFromID(id);
+	    itemByKey[key] = item;
+	  };
+	  getItem = function (id) {
+	    var key = getKeyFromID(id);
+	    return itemByKey[key];
+	  };
+	  removeItem = function (id) {
+	    var key = getKeyFromID(id);
+	    delete itemByKey[key];
+	  };
+	  getItemIDs = function () {
+	    return Object.keys(itemByKey).map(getIDFromKey);
+	  };
+
+	  addRoot = function (id) {
+	    var key = getKeyFromID(id);
+	    rootByKey[key] = true;
+	  };
+	  removeRoot = function (id) {
+	    var key = getKeyFromID(id);
+	    delete rootByKey[key];
+	  };
+	  getRootIDs = function () {
+	    return Object.keys(rootByKey).map(getIDFromKey);
+	  };
+	}
+
+	var unmountedIDs = [];
+
+	function purgeDeep(id) {
+	  var item = getItem(id);
+	  if (item) {
+	    var childIDs = item.childIDs;
+
+	    removeItem(id);
+	    childIDs.forEach(purgeDeep);
+	  }
+	}
+
+	function describeComponentFrame(name, source, ownerName) {
+	  return '\n    in ' + (name || 'Unknown') + (source ? ' (at ' + source.fileName.replace(/^.*[\\\/]/, '') + ':' + source.lineNumber + ')' : ownerName ? ' (created by ' + ownerName + ')' : '');
+	}
+
+	function getDisplayName(element) {
+	  if (element == null) {
+	    return '#empty';
+	  } else if (typeof element === 'string' || typeof element === 'number') {
+	    return '#text';
+	  } else if (typeof element.type === 'string') {
+	    return element.type;
+	  } else {
+	    return element.type.displayName || element.type.name || 'Unknown';
+	  }
+	}
+
+	function describeID(id) {
+	  var name = ReactComponentTreeHook.getDisplayName(id);
+	  var element = ReactComponentTreeHook.getElement(id);
+	  var ownerID = ReactComponentTreeHook.getOwnerID(id);
+	  var ownerName;
+	  if (ownerID) {
+	    ownerName = ReactComponentTreeHook.getDisplayName(ownerID);
+	  }
+	  process.env.NODE_ENV !== 'production' ? warning(element, 'ReactComponentTreeHook: Missing React element for debugID %s when ' + 'building stack', id) : void 0;
+	  return describeComponentFrame(name, element && element._source, ownerName);
+	}
+
+	var ReactComponentTreeHook = {
+	  onSetChildren: function (id, nextChildIDs) {
+	    var item = getItem(id);
+	    !item ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Item must have been set') : _prodInvariant('144') : void 0;
+	    item.childIDs = nextChildIDs;
+
+	    for (var i = 0; i < nextChildIDs.length; i++) {
+	      var nextChildID = nextChildIDs[i];
+	      var nextChild = getItem(nextChildID);
+	      !nextChild ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected hook events to fire for the child before its parent includes it in onSetChildren().') : _prodInvariant('140') : void 0;
+	      !(nextChild.childIDs != null || typeof nextChild.element !== 'object' || nextChild.element == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected onSetChildren() to fire for a container child before its parent includes it in onSetChildren().') : _prodInvariant('141') : void 0;
+	      !nextChild.isMounted ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected onMountComponent() to fire for the child before its parent includes it in onSetChildren().') : _prodInvariant('71') : void 0;
+	      if (nextChild.parentID == null) {
+	        nextChild.parentID = id;
+	        // TODO: This shouldn't be necessary but mounting a new root during in
+	        // componentWillMount currently causes not-yet-mounted components to
+	        // be purged from our tree data so their parent id is missing.
+	      }
+	      !(nextChild.parentID === id) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected onBeforeMountComponent() parent and onSetChildren() to be consistent (%s has parents %s and %s).', nextChildID, nextChild.parentID, id) : _prodInvariant('142', nextChildID, nextChild.parentID, id) : void 0;
+	    }
+	  },
+	  onBeforeMountComponent: function (id, element, parentID) {
+	    var item = {
+	      element: element,
+	      parentID: parentID,
+	      text: null,
+	      childIDs: [],
+	      isMounted: false,
+	      updateCount: 0
+	    };
+	    setItem(id, item);
+	  },
+	  onBeforeUpdateComponent: function (id, element) {
+	    var item = getItem(id);
+	    if (!item || !item.isMounted) {
+	      // We may end up here as a result of setState() in componentWillUnmount().
+	      // In this case, ignore the element.
+	      return;
+	    }
+	    item.element = element;
+	  },
+	  onMountComponent: function (id) {
+	    var item = getItem(id);
+	    !item ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Item must have been set') : _prodInvariant('144') : void 0;
+	    item.isMounted = true;
+	    var isRoot = item.parentID === 0;
+	    if (isRoot) {
+	      addRoot(id);
+	    }
+	  },
+	  onUpdateComponent: function (id) {
+	    var item = getItem(id);
+	    if (!item || !item.isMounted) {
+	      // We may end up here as a result of setState() in componentWillUnmount().
+	      // In this case, ignore the element.
+	      return;
+	    }
+	    item.updateCount++;
+	  },
+	  onUnmountComponent: function (id) {
+	    var item = getItem(id);
+	    if (item) {
+	      // We need to check if it exists.
+	      // `item` might not exist if it is inside an error boundary, and a sibling
+	      // error boundary child threw while mounting. Then this instance never
+	      // got a chance to mount, but it still gets an unmounting event during
+	      // the error boundary cleanup.
+	      item.isMounted = false;
+	      var isRoot = item.parentID === 0;
+	      if (isRoot) {
+	        removeRoot(id);
+	      }
+	    }
+	    unmountedIDs.push(id);
+	  },
+	  purgeUnmountedComponents: function () {
+	    if (ReactComponentTreeHook._preventPurging) {
+	      // Should only be used for testing.
+	      return;
+	    }
+
+	    for (var i = 0; i < unmountedIDs.length; i++) {
+	      var id = unmountedIDs[i];
+	      purgeDeep(id);
+	    }
+	    unmountedIDs.length = 0;
+	  },
+	  isMounted: function (id) {
+	    var item = getItem(id);
+	    return item ? item.isMounted : false;
+	  },
+	  getCurrentStackAddendum: function (topElement) {
+	    var info = '';
+	    if (topElement) {
+	      var name = getDisplayName(topElement);
+	      var owner = topElement._owner;
+	      info += describeComponentFrame(name, topElement._source, owner && owner.getName());
+	    }
+
+	    var currentOwner = ReactCurrentOwner.current;
+	    var id = currentOwner && currentOwner._debugID;
+
+	    info += ReactComponentTreeHook.getStackAddendumByID(id);
+	    return info;
+	  },
+	  getStackAddendumByID: function (id) {
+	    var info = '';
+	    while (id) {
+	      info += describeID(id);
+	      id = ReactComponentTreeHook.getParentID(id);
+	    }
+	    return info;
+	  },
+	  getChildIDs: function (id) {
+	    var item = getItem(id);
+	    return item ? item.childIDs : [];
+	  },
+	  getDisplayName: function (id) {
+	    var element = ReactComponentTreeHook.getElement(id);
+	    if (!element) {
+	      return null;
+	    }
+	    return getDisplayName(element);
+	  },
+	  getElement: function (id) {
+	    var item = getItem(id);
+	    return item ? item.element : null;
+	  },
+	  getOwnerID: function (id) {
+	    var element = ReactComponentTreeHook.getElement(id);
+	    if (!element || !element._owner) {
+	      return null;
+	    }
+	    return element._owner._debugID;
+	  },
+	  getParentID: function (id) {
+	    var item = getItem(id);
+	    return item ? item.parentID : null;
+	  },
+	  getSource: function (id) {
+	    var item = getItem(id);
+	    var element = item ? item.element : null;
+	    var source = element != null ? element._source : null;
+	    return source;
+	  },
+	  getText: function (id) {
+	    var element = ReactComponentTreeHook.getElement(id);
+	    if (typeof element === 'string') {
+	      return element;
+	    } else if (typeof element === 'number') {
+	      return '' + element;
+	    } else {
+	      return null;
+	    }
+	  },
+	  getUpdateCount: function (id) {
+	    var item = getItem(id);
+	    return item ? item.updateCount : 0;
+	  },
+
+
+	  getRootIDs: getRootIDs,
+	  getRegisteredIDs: getItemIDs
+	};
+
+	module.exports = ReactComponentTreeHook;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 27 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(7);
+
+	var ReactPropTypeLocationNames = __webpack_require__(23);
+	var ReactPropTypesSecret = __webpack_require__(28);
+
+	var invariant = __webpack_require__(8);
+	var warning = __webpack_require__(11);
+
+	var ReactComponentTreeHook;
+
+	if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV === 'test') {
+	  // Temporary hack.
+	  // Inline requires don't work well with Jest:
+	  // https://github.com/facebook/react/issues/7240
+	  // Remove the inline requires when we don't need them anymore:
+	  // https://github.com/facebook/react/pull/7178
+	  ReactComponentTreeHook = __webpack_require__(26);
+	}
+
+	var loggedTypeFailures = {};
+
+	/**
+	 * Assert that the values match with the type specs.
+	 * Error messages are memorized and will only be shown once.
+	 *
+	 * @param {object} typeSpecs Map of name to a ReactPropType
+	 * @param {object} values Runtime values that need to be type-checked
+	 * @param {string} location e.g. "prop", "context", "child context"
+	 * @param {string} componentName Name of the component for error messages.
+	 * @param {?object} element The React element that is being type-checked
+	 * @param {?number} debugID The React component instance that is being type-checked
+	 * @private
+	 */
+	function checkReactTypeSpec(typeSpecs, values, location, componentName, element, debugID) {
+	  for (var typeSpecName in typeSpecs) {
+	    if (typeSpecs.hasOwnProperty(typeSpecName)) {
+	      var error;
+	      // Prop type validation may throw. In case they do, we don't want to
+	      // fail the render phase where it didn't fail before. So we log it.
+	      // After these have been cleaned up, we'll let them throw.
+	      try {
+	        // This is intentionally an invariant that gets caught. It's the same
+	        // behavior as without this statement except with a better message.
+	        !(typeof typeSpecs[typeSpecName] === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s: %s type `%s` is invalid; it must be a function, usually from React.PropTypes.', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName) : _prodInvariant('84', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName) : void 0;
+	        error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+	      } catch (ex) {
+	        error = ex;
+	      }
+	      process.env.NODE_ENV !== 'production' ? warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName, typeof error) : void 0;
+	      if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+	        // Only monitor this failure once because there tends to be a lot of the
+	        // same error.
+	        loggedTypeFailures[error.message] = true;
+
+	        var componentStackInfo = '';
+
+	        if (process.env.NODE_ENV !== 'production') {
+	          if (!ReactComponentTreeHook) {
+	            ReactComponentTreeHook = __webpack_require__(26);
+	          }
+	          if (debugID !== null) {
+	            componentStackInfo = ReactComponentTreeHook.getStackAddendumByID(debugID);
+	          } else if (element !== null) {
+	            componentStackInfo = ReactComponentTreeHook.getCurrentStackAddendum(element);
+	          }
+	        }
+
+	        process.env.NODE_ENV !== 'production' ? warning(false, 'Failed %s type: %s%s', location, error.message, componentStackInfo) : void 0;
+	      }
+	    }
+	  }
+	}
+
+	module.exports = checkReactTypeSpec;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 28 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+
+	module.exports = ReactPropTypesSecret;
+
+/***/ },
+/* 29 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ReactElement = __webpack_require__(9);
+	var ReactPropTypeLocationNames = __webpack_require__(23);
+	var ReactPropTypesSecret = __webpack_require__(28);
+
+	var emptyFunction = __webpack_require__(12);
+	var getIteratorFn = __webpack_require__(16);
+	var warning = __webpack_require__(11);
+
+	/**
+	 * Collection of methods that allow declaration and validation of props that are
+	 * supplied to React components. Example usage:
+	 *
+	 *   var Props = require('ReactPropTypes');
+	 *   var MyArticle = React.createClass({
+	 *     propTypes: {
+	 *       // 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|func|object|number|string|oneOf([...])|instanceOf(...)
+	 *   decl := ReactPropTypes.{type}(.isRequired)?
+	 *
+	 * Each and every declaration produces a function with the same signature. This
+	 * allows the creation of custom validation functions. For example:
+	 *
+	 *  var MyLink = React.createClass({
+	 *    propTypes: {
+	 *      // An optional string or URI prop named "href".
+	 *      href: function(props, propName, componentName) {
+	 *        var propValue = props[propName];
+	 *        if (propValue != null && typeof propValue !== 'string' &&
+	 *            !(propValue instanceof URI)) {
+	 *          return new Error(
+	 *            'Expected a string or an URI for ' + propName + ' in ' +
+	 *            componentName
+	 *          );
+	 *        }
+	 *      }
+	 *    },
+	 *    render: function() {...}
+	 *  });
+	 *
+	 * @internal
+	 */
+
+	var ANONYMOUS = '<<anonymous>>';
+
+	var ReactPropTypes = {
+	  array: createPrimitiveTypeChecker('array'),
+	  bool: createPrimitiveTypeChecker('boolean'),
+	  func: createPrimitiveTypeChecker('function'),
+	  number: createPrimitiveTypeChecker('number'),
+	  object: createPrimitiveTypeChecker('object'),
+	  string: createPrimitiveTypeChecker('string'),
+	  symbol: createPrimitiveTypeChecker('symbol'),
+
+	  any: createAnyTypeChecker(),
+	  arrayOf: createArrayOfTypeChecker,
+	  element: createElementTypeChecker(),
+	  instanceOf: createInstanceTypeChecker,
+	  node: createNodeChecker(),
+	  objectOf: createObjectOfTypeChecker,
+	  oneOf: createEnumTypeChecker,
+	  oneOfType: createUnionTypeChecker,
+	  shape: createShapeTypeChecker
+	};
+
+	/**
+	 * inlined Object.is polyfill to avoid requiring consumers ship their own
+	 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+	 */
+	/*eslint-disable no-self-compare*/
+	function is(x, y) {
+	  // SameValue algorithm
+	  if (x === y) {
+	    // Steps 1-5, 7-10
+	    // Steps 6.b-6.e: +0 != -0
+	    return x !== 0 || 1 / x === 1 / y;
+	  } else {
+	    // Step 6.a: NaN == NaN
+	    return x !== x && y !== y;
+	  }
+	}
+	/*eslint-enable no-self-compare*/
+
+	/**
+	 * We use an Error-like object for backward compatibility as people may call
+	 * PropTypes directly and inspect their output. However we don't use real
+	 * Errors anymore. We don't inspect their stack anyway, and creating them
+	 * is prohibitively expensive if they are created too often, such as what
+	 * happens in oneOfType() for any type before the one that matched.
+	 */
+	function PropTypeError(message) {
+	  this.message = message;
+	  this.stack = '';
+	}
+	// Make `instanceof Error` still work for returned errors.
+	PropTypeError.prototype = Error.prototype;
+
+	function createChainableTypeChecker(validate) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    var manualPropTypeCallCache = {};
+	  }
+	  function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
+	    componentName = componentName || ANONYMOUS;
+	    propFullName = propFullName || propName;
+	    if (process.env.NODE_ENV !== 'production') {
+	      if (secret !== ReactPropTypesSecret && typeof console !== 'undefined') {
+	        var cacheKey = componentName + ':' + propName;
+	        if (!manualPropTypeCallCache[cacheKey]) {
+	          process.env.NODE_ENV !== 'production' ? warning(false, 'You are manually calling a React.PropTypes validation ' + 'function for the `%s` prop on `%s`. This is deprecated ' + 'and will not work in production with the next major version. ' + 'You may be seeing this warning due to a third-party PropTypes ' + 'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.', propFullName, componentName) : void 0;
+	          manualPropTypeCallCache[cacheKey] = true;
+	        }
+	      }
+	    }
+	    if (props[propName] == null) {
+	      var locationName = ReactPropTypeLocationNames[location];
+	      if (isRequired) {
+	        if (props[propName] === null) {
+	          return new PropTypeError('The ' + locationName + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
+	        }
+	        return new PropTypeError('The ' + locationName + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
+	      }
+	      return null;
+	    } else {
+	      return validate(props, propName, componentName, location, propFullName);
+	    }
+	  }
+
+	  var chainedCheckType = checkType.bind(null, false);
+	  chainedCheckType.isRequired = checkType.bind(null, true);
+
+	  return chainedCheckType;
+	}
+
+	function createPrimitiveTypeChecker(expectedType) {
+	  function validate(props, propName, componentName, location, propFullName, secret) {
+	    var propValue = props[propName];
+	    var propType = getPropType(propValue);
+	    if (propType !== expectedType) {
+	      var locationName = ReactPropTypeLocationNames[location];
+	      // `propValue` being instance of, say, date/regexp, pass the 'object'
+	      // check, but we can offer a more precise error message here rather than
+	      // 'of type `object`'.
+	      var preciseType = getPreciseType(propValue);
+
+	      return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));
+	    }
+	    return null;
+	  }
+	  return createChainableTypeChecker(validate);
+	}
+
+	function createAnyTypeChecker() {
+	  return createChainableTypeChecker(emptyFunction.thatReturns(null));
+	}
+
+	function createArrayOfTypeChecker(typeChecker) {
+	  function validate(props, propName, componentName, location, propFullName) {
+	    if (typeof typeChecker !== 'function') {
+	      return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
+	    }
+	    var propValue = props[propName];
+	    if (!Array.isArray(propValue)) {
+	      var locationName = ReactPropTypeLocationNames[location];
+	      var propType = getPropType(propValue);
+	      return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
+	    }
+	    for (var i = 0; i < propValue.length; i++) {
+	      var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);
+	      if (error instanceof Error) {
+	        return error;
+	      }
+	    }
+	    return null;
+	  }
+	  return createChainableTypeChecker(validate);
+	}
+
+	function createElementTypeChecker() {
+	  function validate(props, propName, componentName, location, propFullName) {
+	    var propValue = props[propName];
+	    if (!ReactElement.isValidElement(propValue)) {
+	      var locationName = ReactPropTypeLocationNames[location];
+	      var propType = getPropType(propValue);
+	      return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
+	    }
+	    return null;
+	  }
+	  return createChainableTypeChecker(validate);
+	}
+
+	function createInstanceTypeChecker(expectedClass) {
+	  function validate(props, propName, componentName, location, propFullName) {
+	    if (!(props[propName] instanceof expectedClass)) {
+	      var locationName = ReactPropTypeLocationNames[location];
+	      var expectedClassName = expectedClass.name || ANONYMOUS;
+	      var actualClassName = getClassName(props[propName]);
+	      return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
+	    }
+	    return null;
+	  }
+	  return createChainableTypeChecker(validate);
+	}
+
+	function createEnumTypeChecker(expectedValues) {
+	  if (!Array.isArray(expectedValues)) {
+	    process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOf, expected an instance of array.') : void 0;
+	    return emptyFunction.thatReturnsNull;
+	  }
+
+	  function validate(props, propName, componentName, location, propFullName) {
+	    var propValue = props[propName];
+	    for (var i = 0; i < expectedValues.length; i++) {
+	      if (is(propValue, expectedValues[i])) {
+	        return null;
+	      }
+	    }
+
+	    var locationName = ReactPropTypeLocationNames[location];
+	    var valuesString = JSON.stringify(expectedValues);
+	    return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
+	  }
+	  return createChainableTypeChecker(validate);
+	}
+
+	function createObjectOfTypeChecker(typeChecker) {
+	  function validate(props, propName, componentName, location, propFullName) {
+	    if (typeof typeChecker !== 'function') {
+	      return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
+	    }
+	    var propValue = props[propName];
+	    var propType = getPropType(propValue);
+	    if (propType !== 'object') {
+	      var locationName = ReactPropTypeLocationNames[location];
+	      return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
+	    }
+	    for (var key in propValue) {
+	      if (propValue.hasOwnProperty(key)) {
+	        var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+	        if (error instanceof Error) {
+	          return error;
+	        }
+	      }
+	    }
+	    return null;
+	  }
+	  return createChainableTypeChecker(validate);
+	}
+
+	function createUnionTypeChecker(arrayOfTypeCheckers) {
+	  if (!Array.isArray(arrayOfTypeCheckers)) {
+	    process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
+	    return emptyFunction.thatReturnsNull;
+	  }
+
+	  function validate(props, propName, componentName, location, propFullName) {
+	    for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+	      var checker = arrayOfTypeCheckers[i];
+	      if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {
+	        return null;
+	      }
+	    }
+
+	    var locationName = ReactPropTypeLocationNames[location];
+	    return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));
+	  }
+	  return createChainableTypeChecker(validate);
+	}
+
+	function createNodeChecker() {
+	  function validate(props, propName, componentName, location, propFullName) {
+	    if (!isNode(props[propName])) {
+	      var locationName = ReactPropTypeLocationNames[location];
+	      return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
+	    }
+	    return null;
+	  }
+	  return createChainableTypeChecker(validate);
+	}
+
+	function createShapeTypeChecker(shapeTypes) {
+	  function validate(props, propName, componentName, location, propFullName) {
+	    var propValue = props[propName];
+	    var propType = getPropType(propValue);
+	    if (propType !== 'object') {
+	      var locationName = ReactPropTypeLocationNames[location];
+	      return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
+	    }
+	    for (var key in shapeTypes) {
+	      var checker = shapeTypes[key];
+	      if (!checker) {
+	        continue;
+	      }
+	      var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+	      if (error) {
+	        return error;
+	      }
+	    }
+	    return null;
+	  }
+	  return createChainableTypeChecker(validate);
+	}
+
+	function isNode(propValue) {
+	  switch (typeof propValue) {
+	    case 'number':
+	    case 'string':
+	    case 'undefined':
+	      return true;
+	    case 'boolean':
+	      return !propValue;
+	    case 'object':
+	      if (Array.isArray(propValue)) {
+	        return propValue.every(isNode);
+	      }
+	      if (propValue === null || ReactElement.isValidElement(propValue)) {
+	        return true;
+	      }
+
+	      var iteratorFn = getIteratorFn(propValue);
+	      if (iteratorFn) {
+	        var iterator = iteratorFn.call(propValue);
+	        var step;
+	        if (iteratorFn !== propValue.entries) {
+	          while (!(step = iterator.next()).done) {
+	            if (!isNode(step.value)) {
+	              return false;
+	            }
+	          }
+	        } else {
+	          // Iterator will provide entry [k,v] tuples rather than values.
+	          while (!(step = iterator.next()).done) {
+	            var entry = step.value;
+	            if (entry) {
+	              if (!isNode(entry[1])) {
+	                return false;
+	              }
+	            }
+	          }
+	        }
+	      } else {
+	        return false;
+	      }
+
+	      return true;
+	    default:
+	      return false;
+	  }
+	}
+
+	function isSymbol(propType, propValue) {
+	  // Native Symbol.
+	  if (propType === 'symbol') {
+	    return true;
+	  }
+
+	  // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
+	  if (propValue['@@toStringTag'] === 'Symbol') {
+	    return true;
+	  }
+
+	  // Fallback for non-spec compliant Symbols which are polyfilled.
+	  if (typeof Symbol === 'function' && propValue instanceof Symbol) {
+	    return true;
+	  }
+
+	  return false;
+	}
+
+	// Equivalent of `typeof` but with special handling for array and regexp.
+	function getPropType(propValue) {
+	  var propType = typeof propValue;
+	  if (Array.isArray(propValue)) {
+	    return 'array';
+	  }
+	  if (propValue instanceof RegExp) {
+	    // Old webkits (at least until Android 4.0) return 'function' rather than
+	    // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
+	    // passes PropTypes.object.
+	    return 'object';
+	  }
+	  if (isSymbol(propType, propValue)) {
+	    return 'symbol';
+	  }
+	  return propType;
+	}
+
+	// This handles more types than `getPropType`. Only used for error messages.
+	// See `createPrimitiveTypeChecker`.
+	function getPreciseType(propValue) {
+	  var propType = getPropType(propValue);
+	  if (propType === 'object') {
+	    if (propValue instanceof Date) {
+	      return 'date';
+	    } else if (propValue instanceof RegExp) {
+	      return 'regexp';
+	    }
+	  }
+	  return propType;
+	}
+
+	// Returns class name of the object, if any.
+	function getClassName(propValue) {
+	  if (!propValue.constructor || !propValue.constructor.name) {
+	    return ANONYMOUS;
+	  }
+	  return propValue.constructor.name;
+	}
+
+	module.exports = ReactPropTypes;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 30 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	module.exports = '15.4.1';
+
+/***/ },
+/* 31 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(7);
+
+	var ReactElement = __webpack_require__(9);
+
+	var invariant = __webpack_require__(8);
+
+	/**
+	 * Returns the first child in a collection of children and verifies that there
+	 * is only one child in the collection.
+	 *
+	 * See https://facebook.github.io/react/docs/top-level-api.html#react.children.only
+	 *
+	 * The current implementation of this 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 {ReactElement} The first and only `ReactElement` contained in the
+	 * structure.
+	 */
+	function onlyChild(children) {
+	  !ReactElement.isValidElement(children) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'React.Children.only expected to receive a single React element child.') : _prodInvariant('143') : void 0;
+	  return children;
+	}
+
+	module.exports = onlyChild;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 32 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	module.exports = __webpack_require__(33);
+
+
+/***/ },
+/* 33 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	/* globals __REACT_DEVTOOLS_GLOBAL_HOOK__*/
+
+	'use strict';
+
+	var ReactDOMComponentTree = __webpack_require__(34);
+	var ReactDefaultInjection = __webpack_require__(39);
+	var ReactMount = __webpack_require__(171);
+	var ReactReconciler = __webpack_require__(63);
+	var ReactUpdates = __webpack_require__(60);
+	var ReactVersion = __webpack_require__(176);
+
+	var findDOMNode = __webpack_require__(177);
+	var getHostComponentFromComposite = __webpack_require__(178);
+	var renderSubtreeIntoContainer = __webpack_require__(179);
+	var warning = __webpack_require__(47);
+
+	ReactDefaultInjection.inject();
+
+	var ReactDOM = {
+	  findDOMNode: findDOMNode,
+	  render: ReactMount.render,
+	  unmountComponentAtNode: ReactMount.unmountComponentAtNode,
+	  version: ReactVersion,
+
+	  /* eslint-disable camelcase */
+	  unstable_batchedUpdates: ReactUpdates.batchedUpdates,
+	  unstable_renderSubtreeIntoContainer: renderSubtreeIntoContainer
+	};
+
+	// Inject the runtime into a devtools global hook regardless of browser.
+	// Allows for debugging when the hook is injected on the page.
+	if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.inject === 'function') {
+	  __REACT_DEVTOOLS_GLOBAL_HOOK__.inject({
+	    ComponentTree: {
+	      getClosestInstanceFromNode: ReactDOMComponentTree.getClosestInstanceFromNode,
+	      getNodeFromInstance: function (inst) {
+	        // inst is an internal instance (but could be a composite)
+	        if (inst._renderedComponent) {
+	          inst = getHostComponentFromComposite(inst);
+	        }
+	        if (inst) {
+	          return ReactDOMComponentTree.getNodeFromInstance(inst);
+	        } else {
+	          return null;
+	        }
+	      }
+	    },
+	    Mount: ReactMount,
+	    Reconciler: ReactReconciler
+	  });
+	}
+
+	if (process.env.NODE_ENV !== 'production') {
+	  var ExecutionEnvironment = __webpack_require__(51);
+	  if (ExecutionEnvironment.canUseDOM && window.top === window.self) {
+
+	    // First check if devtools is not installed
+	    if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {
+	      // If we're in Chrome or Firefox, provide a download link if not installed.
+	      if (navigator.userAgent.indexOf('Chrome') > -1 && navigator.userAgent.indexOf('Edge') === -1 || navigator.userAgent.indexOf('Firefox') > -1) {
+	        // Firefox does not have the issue with devtools loaded over file://
+	        var showFileUrlMessage = window.location.protocol.indexOf('http') === -1 && navigator.userAgent.indexOf('Firefox') === -1;
+	        console.debug('Download the React DevTools ' + (showFileUrlMessage ? 'and use an HTTP server (instead of a file: URL) ' : '') + 'for a better development experience: ' + 'https://fb.me/react-devtools');
+	      }
+	    }
+
+	    var testFunc = function testFn() {};
+	    process.env.NODE_ENV !== 'production' ? warning((testFunc.name || testFunc.toString()).indexOf('testFn') !== -1, 'It looks like you\'re using a minified copy of the development build ' + 'of React. When deploying React apps to production, make sure to use ' + 'the production build which skips development warnings and is faster. ' + 'See https://fb.me/react-minification for more details.') : void 0;
+
+	    // If we're in IE8, check to see if we are in compatibility mode and provide
+	    // information on preventing compatibility mode
+	    var ieCompatibilityMode = document.documentMode && document.documentMode < 8;
+
+	    process.env.NODE_ENV !== 'production' ? warning(!ieCompatibilityMode, 'Internet Explorer is running in compatibility mode; please add the ' + 'following tag to your HTML to prevent this from happening: ' + '<meta http-equiv="X-UA-Compatible" content="IE=edge" />') : void 0;
+
+	    var expectedFeatures = [
+	    // shims
+	    Array.isArray, Array.prototype.every, Array.prototype.forEach, Array.prototype.indexOf, Array.prototype.map, Date.now, Function.prototype.bind, Object.keys, String.prototype.trim];
+
+	    for (var i = 0; i < expectedFeatures.length; i++) {
+	      if (!expectedFeatures[i]) {
+	        process.env.NODE_ENV !== 'production' ? warning(false, 'One or more ES5 shims expected by React are not available: ' + 'https://fb.me/react-warning-polyfills') : void 0;
+	        break;
+	      }
+	    }
+	  }
+	}
+
+	if (process.env.NODE_ENV !== 'production') {
+	  var ReactInstrumentation = __webpack_require__(66);
+	  var ReactDOMUnknownPropertyHook = __webpack_require__(180);
+	  var ReactDOMNullInputValuePropHook = __webpack_require__(181);
+	  var ReactDOMInvalidARIAHook = __webpack_require__(182);
+
+	  ReactInstrumentation.debugTool.addHook(ReactDOMUnknownPropertyHook);
+	  ReactInstrumentation.debugTool.addHook(ReactDOMNullInputValuePropHook);
+	  ReactInstrumentation.debugTool.addHook(ReactDOMInvalidARIAHook);
+	}
+
+	module.exports = ReactDOM;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 34 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var DOMProperty = __webpack_require__(36);
+	var ReactDOMComponentFlags = __webpack_require__(38);
+
+	var invariant = __webpack_require__(37);
+
+	var ATTR_NAME = DOMProperty.ID_ATTRIBUTE_NAME;
+	var Flags = ReactDOMComponentFlags;
+
+	var internalInstanceKey = '__reactInternalInstance$' + Math.random().toString(36).slice(2);
+
+	/**
+	 * Drill down (through composites and empty components) until we get a host or
+	 * host text component.
+	 *
+	 * This is pretty polymorphic but unavoidable with the current structure we have
+	 * for `_renderedChildren`.
+	 */
+	function getRenderedHostOrTextFromComponent(component) {
+	  var rendered;
+	  while (rendered = component._renderedComponent) {
+	    component = rendered;
+	  }
+	  return component;
+	}
+
+	/**
+	 * Populate `_hostNode` on the rendered host/text component with the given
+	 * DOM node. The passed `inst` can be a composite.
+	 */
+	function precacheNode(inst, node) {
+	  var hostInst = getRenderedHostOrTextFromComponent(inst);
+	  hostInst._hostNode = node;
+	  node[internalInstanceKey] = hostInst;
+	}
+
+	function uncacheNode(inst) {
+	  var node = inst._hostNode;
+	  if (node) {
+	    delete node[internalInstanceKey];
+	    inst._hostNode = null;
+	  }
+	}
+
+	/**
+	 * Populate `_hostNode` on each child of `inst`, assuming that the children
+	 * match up with the DOM (element) children of `node`.
+	 *
+	 * We cache entire levels at once to avoid an n^2 problem where we access the
+	 * children of a node sequentially and have to walk from the start to our target
+	 * node every time.
+	 *
+	 * Since we update `_renderedChildren` and the actual DOM at (slightly)
+	 * different times, we could race here and see a newer `_renderedChildren` than
+	 * the DOM nodes we see. To avoid this, ReactMultiChild calls
+	 * `prepareToManageChildren` before we change `_renderedChildren`, at which
+	 * time the container's child nodes are always cached (until it unmounts).
+	 */
+	function precacheChildNodes(inst, node) {
+	  if (inst._flags & Flags.hasCachedChildNodes) {
+	    return;
+	  }
+	  var children = inst._renderedChildren;
+	  var childNode = node.firstChild;
+	  outer: for (var name in children) {
+	    if (!children.hasOwnProperty(name)) {
+	      continue;
+	    }
+	    var childInst = children[name];
+	    var childID = getRenderedHostOrTextFromComponent(childInst)._domID;
+	    if (childID === 0) {
+	      // We're currently unmounting this child in ReactMultiChild; skip it.
+	      continue;
+	    }
+	    // We assume the child nodes are in the same order as the child instances.
+	    for (; childNode !== null; childNode = childNode.nextSibling) {
+	      if (childNode.nodeType === 1 && childNode.getAttribute(ATTR_NAME) === String(childID) || childNode.nodeType === 8 && childNode.nodeValue === ' react-text: ' + childID + ' ' || childNode.nodeType === 8 && childNode.nodeValue === ' react-empty: ' + childID + ' ') {
+	        precacheNode(childInst, childNode);
+	        continue outer;
+	      }
+	    }
+	    // We reached the end of the DOM children without finding an ID match.
+	     true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Unable to find element with ID %s.', childID) : _prodInvariant('32', childID) : void 0;
+	  }
+	  inst._flags |= Flags.hasCachedChildNodes;
+	}
+
+	/**
+	 * Given a DOM node, return the closest ReactDOMComponent or
+	 * ReactDOMTextComponent instance ancestor.
+	 */
+	function getClosestInstanceFromNode(node) {
+	  if (node[internalInstanceKey]) {
+	    return node[internalInstanceKey];
+	  }
+
+	  // Walk up the tree until we find an ancestor whose instance we have cached.
+	  var parents = [];
+	  while (!node[internalInstanceKey]) {
+	    parents.push(node);
+	    if (node.parentNode) {
+	      node = node.parentNode;
+	    } else {
+	      // Top of the tree. This node must not be part of a React tree (or is
+	      // unmounted, potentially).
+	      return null;
+	    }
+	  }
+
+	  var closest;
+	  var inst;
+	  for (; node && (inst = node[internalInstanceKey]); node = parents.pop()) {
+	    closest = inst;
+	    if (parents.length) {
+	      precacheChildNodes(inst, node);
+	    }
+	  }
+
+	  return closest;
+	}
+
+	/**
+	 * Given a DOM node, return the ReactDOMComponent or ReactDOMTextComponent
+	 * instance, or null if the node was not rendered by this React.
+	 */
+	function getInstanceFromNode(node) {
+	  var inst = getClosestInstanceFromNode(node);
+	  if (inst != null && inst._hostNode === node) {
+	    return inst;
+	  } else {
+	    return null;
+	  }
+	}
+
+	/**
+	 * Given a ReactDOMComponent or ReactDOMTextComponent, return the corresponding
+	 * DOM node.
+	 */
+	function getNodeFromInstance(inst) {
+	  // Without this first invariant, passing a non-DOM-component triggers the next
+	  // invariant for a missing parent, which is super confusing.
+	  !(inst._hostNode !== undefined) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getNodeFromInstance: Invalid argument.') : _prodInvariant('33') : void 0;
+
+	  if (inst._hostNode) {
+	    return inst._hostNode;
+	  }
+
+	  // Walk up the tree until we find an ancestor whose DOM node we have cached.
+	  var parents = [];
+	  while (!inst._hostNode) {
+	    parents.push(inst);
+	    !inst._hostParent ? process.env.NODE_ENV !== 'production' ? invariant(false, 'React DOM tree root should always have a node reference.') : _prodInvariant('34') : void 0;
+	    inst = inst._hostParent;
+	  }
+
+	  // Now parents contains each ancestor that does *not* have a cached native
+	  // node, and `inst` is the deepest ancestor that does.
+	  for (; parents.length; inst = parents.pop()) {
+	    precacheChildNodes(inst, inst._hostNode);
+	  }
+
+	  return inst._hostNode;
+	}
+
+	var ReactDOMComponentTree = {
+	  getClosestInstanceFromNode: getClosestInstanceFromNode,
+	  getInstanceFromNode: getInstanceFromNode,
+	  getNodeFromInstance: getNodeFromInstance,
+	  precacheChildNodes: precacheChildNodes,
+	  precacheNode: precacheNode,
+	  uncacheNode: uncacheNode
+	};
+
+	module.exports = ReactDOMComponentTree;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 35 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+	'use strict';
+
+	/**
+	 * WARNING: DO NOT manually require this module.
+	 * This is a replacement for `invariant(...)` used by the error code system
+	 * and will _only_ be required by the corresponding babel pass.
+	 * It always throws.
+	 */
+
+	function reactProdInvariant(code) {
+	  var argCount = arguments.length - 1;
+
+	  var message = 'Minified React error #' + code + '; visit ' + 'http://facebook.github.io/react/docs/error-decoder.html?invariant=' + code;
+
+	  for (var argIdx = 0; argIdx < argCount; argIdx++) {
+	    message += '&args[]=' + encodeURIComponent(arguments[argIdx + 1]);
+	  }
+
+	  message += ' for the full message or use the non-minified dev environment' + ' for full errors and additional helpful warnings.';
+
+	  var error = new Error(message);
+	  error.name = 'Invariant Violation';
+	  error.framesToPop = 1; // we don't care about reactProdInvariant's own frame
+
+	  throw error;
+	}
+
+	module.exports = reactProdInvariant;
+
+/***/ },
+/* 36 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var invariant = __webpack_require__(37);
+
+	function checkMask(value, bitmask) {
+	  return (value & bitmask) === bitmask;
+	}
+
+	var DOMPropertyInjection = {
+	  /**
+	   * Mapping from normalized, camelcased property names to a configuration that
+	   * specifies how the associated DOM property should be accessed or rendered.
+	   */
+	  MUST_USE_PROPERTY: 0x1,
+	  HAS_BOOLEAN_VALUE: 0x4,
+	  HAS_NUMERIC_VALUE: 0x8,
+	  HAS_POSITIVE_NUMERIC_VALUE: 0x10 | 0x8,
+	  HAS_OVERLOADED_BOOLEAN_VALUE: 0x20,
+
+	  /**
+	   * Inject some specialized knowledge about the DOM. This takes a config object
+	   * with the following properties:
+	   *
+	   * isCustomAttribute: function that given an attribute name will return true
+	   * if it can be inserted into the DOM verbatim. Useful for data-* or aria-*
+	   * attributes where it's impossible to enumerate all of the possible
+	   * attribute names,
+	   *
+	   * Properties: object mapping DOM property name to one of the
+	   * DOMPropertyInjection constants or null. If your attribute isn't in here,
+	   * it won't get written to the DOM.
+	   *
+	   * DOMAttributeNames: object mapping React attribute name to the DOM
+	   * attribute name. Attribute names not specified use the **lowercase**
+	   * normalized name.
+	   *
+	   * DOMAttributeNamespaces: object mapping React attribute name to the DOM
+	   * attribute namespace URL. (Attribute names not specified use no namespace.)
+	   *
+	   * DOMPropertyNames: similar to DOMAttributeNames but for DOM properties.
+	   * Property names not specified use the normalized name.
+	   *
+	   * DOMMutationMethods: Properties that require special mutation methods. If
+	   * `value` is undefined, the mutation method should unset the property.
+	   *
+	   * @param {object} domPropertyConfig the config as described above.
+	   */
+	  injectDOMPropertyConfig: function (domPropertyConfig) {
+	    var Injection = DOMPropertyInjection;
+	    var Properties = domPropertyConfig.Properties || {};
+	    var DOMAttributeNamespaces = domPropertyConfig.DOMAttributeNamespaces || {};
+	    var DOMAttributeNames = domPropertyConfig.DOMAttributeNames || {};
+	    var DOMPropertyNames = domPropertyConfig.DOMPropertyNames || {};
+	    var DOMMutationMethods = domPropertyConfig.DOMMutationMethods || {};
+
+	    if (domPropertyConfig.isCustomAttribute) {
+	      DOMProperty._isCustomAttributeFunctions.push(domPropertyConfig.isCustomAttribute);
+	    }
+
+	    for (var propName in Properties) {
+	      !!DOMProperty.properties.hasOwnProperty(propName) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'injectDOMPropertyConfig(...): You\'re trying to inject DOM property \'%s\' which has already been injected. You may be accidentally injecting the same DOM property config twice, or you may be injecting two configs that have conflicting property names.', propName) : _prodInvariant('48', propName) : void 0;
+
+	      var lowerCased = propName.toLowerCase();
+	      var propConfig = Properties[propName];
+
+	      var propertyInfo = {
+	        attributeName: lowerCased,
+	        attributeNamespace: null,
+	        propertyName: propName,
+	        mutationMethod: null,
+
+	        mustUseProperty: checkMask(propConfig, Injection.MUST_USE_PROPERTY),
+	        hasBooleanValue: checkMask(propConfig, Injection.HAS_BOOLEAN_VALUE),
+	        hasNumericValue: checkMask(propConfig, Injection.HAS_NUMERIC_VALUE),
+	        hasPositiveNumericValue: checkMask(propConfig, Injection.HAS_POSITIVE_NUMERIC_VALUE),
+	        hasOverloadedBooleanValue: checkMask(propConfig, Injection.HAS_OVERLOADED_BOOLEAN_VALUE)
+	      };
+	      !(propertyInfo.hasBooleanValue + propertyInfo.hasNumericValue + propertyInfo.hasOverloadedBooleanValue <= 1) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'DOMProperty: Value can be one of boolean, overloaded boolean, or numeric value, but not a combination: %s', propName) : _prodInvariant('50', propName) : void 0;
+
+	      if (process.env.NODE_ENV !== 'production') {
+	        DOMProperty.getPossibleStandardName[lowerCased] = propName;
+	      }
+
+	      if (DOMAttributeNames.hasOwnProperty(propName)) {
+	        var attributeName = DOMAttributeNames[propName];
+	        propertyInfo.attributeName = attributeName;
+	        if (process.env.NODE_ENV !== 'production') {
+	          DOMProperty.getPossibleStandardName[attributeName] = propName;
+	        }
+	      }
+
+	      if (DOMAttributeNamespaces.hasOwnProperty(propName)) {
+	        propertyInfo.attributeNamespace = DOMAttributeNamespaces[propName];
+	      }
+
+	      if (DOMPropertyNames.hasOwnProperty(propName)) {
+	        propertyInfo.propertyName = DOMPropertyNames[propName];
+	      }
+
+	      if (DOMMutationMethods.hasOwnProperty(propName)) {
+	        propertyInfo.mutationMethod = DOMMutationMethods[propName];
+	      }
+
+	      DOMProperty.properties[propName] = propertyInfo;
+	    }
+	  }
+	};
+
+	/* eslint-disable max-len */
+	var ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
+	/* eslint-enable max-len */
+
+	/**
+	 * 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 = {
+
+	  ID_ATTRIBUTE_NAME: 'data-reactid',
+	  ROOT_ATTRIBUTE_NAME: 'data-reactroot',
+
+	  ATTRIBUTE_NAME_START_CHAR: ATTRIBUTE_NAME_START_CHAR,
+	  ATTRIBUTE_NAME_CHAR: ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040',
+
+	  /**
+	   * Map from property "standard name" to an object with info about how to set
+	   * the property in the DOM. Each object contains:
+	   *
+	   * attributeName:
+	   *   Used when rendering markup or with `*Attribute()`.
+	   * attributeNamespace
+	   * propertyName:
+	   *   Used on DOM node instances. (This includes properties that mutate due to
+	   *   external factors.)
+	   * mutationMethod:
+	   *   If non-null, used instead of the property or `setAttribute()` after
+	   *   initial render.
+	   * mustUseProperty:
+	   *   Whether the property must be accessed and mutated as an object property.
+	   * hasBooleanValue:
+	   *   Whether the property should be removed when set to a falsey value.
+	   * hasNumericValue:
+	   *   Whether the property must be numeric or parse as a numeric and should be
+	   *   removed when set to a falsey value.
+	   * hasPositiveNumericValue:
+	   *   Whether the property must be positive numeric or parse as a positive
+	   *   numeric and should be removed when set to a falsey value.
+	   * hasOverloadedBooleanValue:
+	   *   Whether the property can be used as a flag as well as with a value.
+	   *   Removed when strictly equal to false; present without a value when
+	   *   strictly equal to true; present with a value otherwise.
+	   */
+	  properties: {},
+
+	  /**
+	   * Mapping from lowercase property names to the properly cased version, used
+	   * to warn in the case of missing properties. Available only in __DEV__.
+	   *
+	   * autofocus is predefined, because adding it to the property whitelist
+	   * causes unintended side effects.
+	   *
+	   * @type {Object}
+	   */
+	  getPossibleStandardName: process.env.NODE_ENV !== 'production' ? { autofocus: 'autoFocus' } : null,
+
+	  /**
+	   * All of the isCustomAttribute() functions that have been injected.
+	   */
+	  _isCustomAttributeFunctions: [],
+
+	  /**
+	   * Checks whether a property name is a custom attribute.
+	   * @method
+	   */
+	  isCustomAttribute: function (attributeName) {
+	    for (var i = 0; i < DOMProperty._isCustomAttributeFunctions.length; i++) {
+	      var isCustomAttributeFn = DOMProperty._isCustomAttributeFunctions[i];
+	      if (isCustomAttributeFn(attributeName)) {
+	        return true;
+	      }
+	    }
+	    return false;
+	  },
+
+	  injection: DOMPropertyInjection
+	};
+
+	module.exports = DOMProperty;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 37 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	/**
+	 * Use invariant() to assert state which your program assumes to be true.
+	 *
+	 * Provide sprintf-style format (only %s is supported) 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, format, a, b, c, d, e, f) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    if (format === undefined) {
+	      throw new Error('invariant requires an error message argument');
+	    }
+	  }
+
+	  if (!condition) {
+	    var error;
+	    if (format === undefined) {
+	      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
+	    } else {
+	      var args = [a, b, c, d, e, f];
+	      var argIndex = 0;
+	      error = new Error(format.replace(/%s/g, function () {
+	        return args[argIndex++];
+	      }));
+	      error.name = 'Invariant Violation';
+	    }
+
+	    error.framesToPop = 1; // we don't care about invariant's own frame
+	    throw error;
+	  }
+	}
+
+	module.exports = invariant;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 38 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2015-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ReactDOMComponentFlags = {
+	  hasCachedChildNodes: 1 << 0
+	};
+
+	module.exports = ReactDOMComponentFlags;
+
+/***/ },
+/* 39 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ARIADOMPropertyConfig = __webpack_require__(40);
+	var BeforeInputEventPlugin = __webpack_require__(41);
+	var ChangeEventPlugin = __webpack_require__(59);
+	var DefaultEventPluginOrder = __webpack_require__(76);
+	var EnterLeaveEventPlugin = __webpack_require__(77);
+	var HTMLDOMPropertyConfig = __webpack_require__(82);
+	var ReactComponentBrowserEnvironment = __webpack_require__(83);
+	var ReactDOMComponent = __webpack_require__(96);
+	var ReactDOMComponentTree = __webpack_require__(34);
+	var ReactDOMEmptyComponent = __webpack_require__(142);
+	var ReactDOMTreeTraversal = __webpack_require__(143);
+	var ReactDOMTextComponent = __webpack_require__(144);
+	var ReactDefaultBatchingStrategy = __webpack_require__(145);
+	var ReactEventListener = __webpack_require__(146);
+	var ReactInjection = __webpack_require__(149);
+	var ReactReconcileTransaction = __webpack_require__(150);
+	var SVGDOMPropertyConfig = __webpack_require__(158);
+	var SelectEventPlugin = __webpack_require__(159);
+	var SimpleEventPlugin = __webpack_require__(160);
+
+	var alreadyInjected = false;
+
+	function inject() {
+	  if (alreadyInjected) {
+	    // TODO: This is currently true because these injections are shared between
+	    // the client and the server package. They should be built independently
+	    // and not share any injection state. Then this problem will be solved.
+	    return;
+	  }
+	  alreadyInjected = true;
+
+	  ReactInjection.EventEmitter.injectReactEventListener(ReactEventListener);
+
+	  /**
+	   * Inject modules for resolving DOM hierarchy and plugin ordering.
+	   */
+	  ReactInjection.EventPluginHub.injectEventPluginOrder(DefaultEventPluginOrder);
+	  ReactInjection.EventPluginUtils.injectComponentTree(ReactDOMComponentTree);
+	  ReactInjection.EventPluginUtils.injectTreeTraversal(ReactDOMTreeTraversal);
+
+	  /**
+	   * Some important event plugins included by default (without having to require
+	   * them).
+	   */
+	  ReactInjection.EventPluginHub.injectEventPluginsByName({
+	    SimpleEventPlugin: SimpleEventPlugin,
+	    EnterLeaveEventPlugin: EnterLeaveEventPlugin,
+	    ChangeEventPlugin: ChangeEventPlugin,
+	    SelectEventPlugin: SelectEventPlugin,
+	    BeforeInputEventPlugin: BeforeInputEventPlugin
+	  });
+
+	  ReactInjection.HostComponent.injectGenericComponentClass(ReactDOMComponent);
+
+	  ReactInjection.HostComponent.injectTextComponentClass(ReactDOMTextComponent);
+
+	  ReactInjection.DOMProperty.injectDOMPropertyConfig(ARIADOMPropertyConfig);
+	  ReactInjection.DOMProperty.injectDOMPropertyConfig(HTMLDOMPropertyConfig);
+	  ReactInjection.DOMProperty.injectDOMPropertyConfig(SVGDOMPropertyConfig);
+
+	  ReactInjection.EmptyComponent.injectEmptyComponentFactory(function (instantiate) {
+	    return new ReactDOMEmptyComponent(instantiate);
+	  });
+
+	  ReactInjection.Updates.injectReconcileTransaction(ReactReconcileTransaction);
+	  ReactInjection.Updates.injectBatchingStrategy(ReactDefaultBatchingStrategy);
+
+	  ReactInjection.Component.injectEnvironment(ReactComponentBrowserEnvironment);
+	}
+
+	module.exports = {
+	  inject: inject
+	};
+
+/***/ },
+/* 40 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ARIADOMPropertyConfig = {
+	  Properties: {
+	    // Global States and Properties
+	    'aria-current': 0, // state
+	    'aria-details': 0,
+	    'aria-disabled': 0, // state
+	    'aria-hidden': 0, // state
+	    'aria-invalid': 0, // state
+	    'aria-keyshortcuts': 0,
+	    'aria-label': 0,
+	    'aria-roledescription': 0,
+	    // Widget Attributes
+	    'aria-autocomplete': 0,
+	    'aria-checked': 0,
+	    'aria-expanded': 0,
+	    'aria-haspopup': 0,
+	    'aria-level': 0,
+	    'aria-modal': 0,
+	    'aria-multiline': 0,
+	    'aria-multiselectable': 0,
+	    'aria-orientation': 0,
+	    'aria-placeholder': 0,
+	    'aria-pressed': 0,
+	    'aria-readonly': 0,
+	    'aria-required': 0,
+	    'aria-selected': 0,
+	    'aria-sort': 0,
+	    'aria-valuemax': 0,
+	    'aria-valuemin': 0,
+	    'aria-valuenow': 0,
+	    'aria-valuetext': 0,
+	    // Live Region Attributes
+	    'aria-atomic': 0,
+	    'aria-busy': 0,
+	    'aria-live': 0,
+	    'aria-relevant': 0,
+	    // Drag-and-Drop Attributes
+	    'aria-dropeffect': 0,
+	    'aria-grabbed': 0,
+	    // Relationship Attributes
+	    'aria-activedescendant': 0,
+	    'aria-colcount': 0,
+	    'aria-colindex': 0,
+	    'aria-colspan': 0,
+	    'aria-controls': 0,
+	    'aria-describedby': 0,
+	    'aria-errormessage': 0,
+	    'aria-flowto': 0,
+	    'aria-labelledby': 0,
+	    'aria-owns': 0,
+	    'aria-posinset': 0,
+	    'aria-rowcount': 0,
+	    'aria-rowindex': 0,
+	    'aria-rowspan': 0,
+	    'aria-setsize': 0
+	  },
+	  DOMAttributeNames: {},
+	  DOMPropertyNames: {}
+	};
+
+	module.exports = ARIADOMPropertyConfig;
+
+/***/ },
+/* 41 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var EventPropagators = __webpack_require__(42);
+	var ExecutionEnvironment = __webpack_require__(51);
+	var FallbackCompositionState = __webpack_require__(52);
+	var SyntheticCompositionEvent = __webpack_require__(56);
+	var SyntheticInputEvent = __webpack_require__(58);
+
+	var END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space
+	var START_KEYCODE = 229;
+
+	var canUseCompositionEvent = ExecutionEnvironment.canUseDOM && 'CompositionEvent' in window;
+
+	var documentMode = null;
+	if (ExecutionEnvironment.canUseDOM && 'documentMode' in document) {
+	  documentMode = document.documentMode;
+	}
+
+	// Webkit offers a very useful `textInput` event that can be used to
+	// directly represent `beforeInput`. The IE `textinput` event is not as
+	// useful, so we don't use it.
+	var canUseTextInputEvent = ExecutionEnvironment.canUseDOM && 'TextEvent' in window && !documentMode && !isPresto();
+
+	// In IE9+, we have access to composition events, but the data supplied
+	// by the native compositionend event may be incorrect. Japanese ideographic
+	// spaces, for instance (\u3000) are not recorded correctly.
+	var useFallbackCompositionData = ExecutionEnvironment.canUseDOM && (!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11);
+
+	/**
+	 * Opera <= 12 includes TextEvent in window, but does not fire
+	 * text input events. Rely on keypress instead.
+	 */
+	function isPresto() {
+	  var opera = window.opera;
+	  return typeof opera === 'object' && typeof opera.version === 'function' && parseInt(opera.version(), 10) <= 12;
+	}
+
+	var SPACEBAR_CODE = 32;
+	var SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);
+
+	// Events and their corresponding property names.
+	var eventTypes = {
+	  beforeInput: {
+	    phasedRegistrationNames: {
+	      bubbled: 'onBeforeInput',
+	      captured: 'onBeforeInputCapture'
+	    },
+	    dependencies: ['topCompositionEnd', 'topKeyPress', 'topTextInput', 'topPaste']
+	  },
+	  compositionEnd: {
+	    phasedRegistrationNames: {
+	      bubbled: 'onCompositionEnd',
+	      captured: 'onCompositionEndCapture'
+	    },
+	    dependencies: ['topBlur', 'topCompositionEnd', 'topKeyDown', 'topKeyPress', 'topKeyUp', 'topMouseDown']
+	  },
+	  compositionStart: {
+	    phasedRegistrationNames: {
+	      bubbled: 'onCompositionStart',
+	      captured: 'onCompositionStartCapture'
+	    },
+	    dependencies: ['topBlur', 'topCompositionStart', 'topKeyDown', 'topKeyPress', 'topKeyUp', 'topMouseDown']
+	  },
+	  compositionUpdate: {
+	    phasedRegistrationNames: {
+	      bubbled: 'onCompositionUpdate',
+	      captured: 'onCompositionUpdateCapture'
+	    },
+	    dependencies: ['topBlur', 'topCompositionUpdate', 'topKeyDown', 'topKeyPress', 'topKeyUp', 'topMouseDown']
+	  }
+	};
+
+	// Track whether we've ever handled a keypress on the space key.
+	var hasSpaceKeypress = false;
+
+	/**
+	 * Return whether a native keypress event is assumed to be a command.
+	 * This is required because Firefox fires `keypress` events for key commands
+	 * (cut, copy, select-all, etc.) even though no character is inserted.
+	 */
+	function isKeypressCommand(nativeEvent) {
+	  return (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) &&
+	  // ctrlKey && altKey is equivalent to AltGr, and is not a command.
+	  !(nativeEvent.ctrlKey && nativeEvent.altKey);
+	}
+
+	/**
+	 * Translate native top level events into event types.
+	 *
+	 * @param {string} topLevelType
+	 * @return {object}
+	 */
+	function getCompositionEventType(topLevelType) {
+	  switch (topLevelType) {
+	    case 'topCompositionStart':
+	      return eventTypes.compositionStart;
+	    case 'topCompositionEnd':
+	      return eventTypes.compositionEnd;
+	    case 'topCompositionUpdate':
+	      return eventTypes.compositionUpdate;
+	  }
+	}
+
+	/**
+	 * Does our fallback best-guess model think this event signifies that
+	 * composition has begun?
+	 *
+	 * @param {string} topLevelType
+	 * @param {object} nativeEvent
+	 * @return {boolean}
+	 */
+	function isFallbackCompositionStart(topLevelType, nativeEvent) {
+	  return topLevelType === 'topKeyDown' && nativeEvent.keyCode === START_KEYCODE;
+	}
+
+	/**
+	 * Does our fallback mode think that this event is the end of composition?
+	 *
+	 * @param {string} topLevelType
+	 * @param {object} nativeEvent
+	 * @return {boolean}
+	 */
+	function isFallbackCompositionEnd(topLevelType, nativeEvent) {
+	  switch (topLevelType) {
+	    case 'topKeyUp':
+	      // Command keys insert or clear IME input.
+	      return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;
+	    case 'topKeyDown':
+	      // Expect IME keyCode on each keydown. If we get any other
+	      // code we must have exited earlier.
+	      return nativeEvent.keyCode !== START_KEYCODE;
+	    case 'topKeyPress':
+	    case 'topMouseDown':
+	    case 'topBlur':
+	      // Events are not possible without cancelling IME.
+	      return true;
+	    default:
+	      return false;
+	  }
+	}
+
+	/**
+	 * Google Input Tools provides composition data via a CustomEvent,
+	 * with the `data` property populated in the `detail` object. If this
+	 * is available on the event object, use it. If not, this is a plain
+	 * composition event and we have nothing special to extract.
+	 *
+	 * @param {object} nativeEvent
+	 * @return {?string}
+	 */
+	function getDataFromCustomEvent(nativeEvent) {
+	  var detail = nativeEvent.detail;
+	  if (typeof detail === 'object' && 'data' in detail) {
+	    return detail.data;
+	  }
+	  return null;
+	}
+
+	// Track the current IME composition fallback object, if any.
+	var currentComposition = null;
+
+	/**
+	 * @return {?object} A SyntheticCompositionEvent.
+	 */
+	function extractCompositionEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+	  var eventType;
+	  var fallbackData;
+
+	  if (canUseCompositionEvent) {
+	    eventType = getCompositionEventType(topLevelType);
+	  } else if (!currentComposition) {
+	    if (isFallbackCompositionStart(topLevelType, nativeEvent)) {
+	      eventType = eventTypes.compositionStart;
+	    }
+	  } else if (isFallbackCompositionEnd(topLevelType, nativeEvent)) {
+	    eventType = eventTypes.compositionEnd;
+	  }
+
+	  if (!eventType) {
+	    return null;
+	  }
+
+	  if (useFallbackCompositionData) {
+	    // The current composition is stored statically and must not be
+	    // overwritten while composition continues.
+	    if (!currentComposition && eventType === eventTypes.compositionStart) {
+	      currentComposition = FallbackCompositionState.getPooled(nativeEventTarget);
+	    } else if (eventType === eventTypes.compositionEnd) {
+	      if (currentComposition) {
+	        fallbackData = currentComposition.getData();
+	      }
+	    }
+	  }
+
+	  var event = SyntheticCompositionEvent.getPooled(eventType, targetInst, nativeEvent, nativeEventTarget);
+
+	  if (fallbackData) {
+	    // Inject data generated from fallback path into the synthetic event.
+	    // This matches the property of native CompositionEventInterface.
+	    event.data = fallbackData;
+	  } else {
+	    var customData = getDataFromCustomEvent(nativeEvent);
+	    if (customData !== null) {
+	      event.data = customData;
+	    }
+	  }
+
+	  EventPropagators.accumulateTwoPhaseDispatches(event);
+	  return event;
+	}
+
+	/**
+	 * @param {string} topLevelType Record from `EventConstants`.
+	 * @param {object} nativeEvent Native browser event.
+	 * @return {?string} The string corresponding to this `beforeInput` event.
+	 */
+	function getNativeBeforeInputChars(topLevelType, nativeEvent) {
+	  switch (topLevelType) {
+	    case 'topCompositionEnd':
+	      return getDataFromCustomEvent(nativeEvent);
+	    case 'topKeyPress':
+	      /**
+	       * If native `textInput` events are available, our goal is to make
+	       * use of them. However, there is a special case: the spacebar key.
+	       * In Webkit, preventing default on a spacebar `textInput` event
+	       * cancels character insertion, but it *also* causes the browser
+	       * to fall back to its default spacebar behavior of scrolling the
+	       * page.
+	       *
+	       * Tracking at:
+	       * https://code.google.com/p/chromium/issues/detail?id=355103
+	       *
+	       * To avoid this issue, use the keypress event as if no `textInput`
+	       * event is available.
+	       */
+	      var which = nativeEvent.which;
+	      if (which !== SPACEBAR_CODE) {
+	        return null;
+	      }
+
+	      hasSpaceKeypress = true;
+	      return SPACEBAR_CHAR;
+
+	    case 'topTextInput':
+	      // Record the characters to be added to the DOM.
+	      var chars = nativeEvent.data;
+
+	      // If it's a spacebar character, assume that we have already handled
+	      // it at the keypress level and bail immediately. Android Chrome
+	      // doesn't give us keycodes, so we need to blacklist it.
+	      if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {
+	        return null;
+	      }
+
+	      return chars;
+
+	    default:
+	      // For other native event types, do nothing.
+	      return null;
+	  }
+	}
+
+	/**
+	 * For browsers that do not provide the `textInput` event, extract the
+	 * appropriate string to use for SyntheticInputEvent.
+	 *
+	 * @param {string} topLevelType Record from `EventConstants`.
+	 * @param {object} nativeEvent Native browser event.
+	 * @return {?string} The fallback string for this `beforeInput` event.
+	 */
+	function getFallbackBeforeInputChars(topLevelType, nativeEvent) {
+	  // If we are currently composing (IME) and using a fallback to do so,
+	  // try to extract the composed characters from the fallback object.
+	  // If composition event is available, we extract a string only at
+	  // compositionevent, otherwise extract it at fallback events.
+	  if (currentComposition) {
+	    if (topLevelType === 'topCompositionEnd' || !canUseCompositionEvent && isFallbackCompositionEnd(topLevelType, nativeEvent)) {
+	      var chars = currentComposition.getData();
+	      FallbackCompositionState.release(currentComposition);
+	      currentComposition = null;
+	      return chars;
+	    }
+	    return null;
+	  }
+
+	  switch (topLevelType) {
+	    case 'topPaste':
+	      // If a paste event occurs after a keypress, throw out the input
+	      // chars. Paste events should not lead to BeforeInput events.
+	      return null;
+	    case 'topKeyPress':
+	      /**
+	       * As of v27, Firefox may fire keypress events even when no character
+	       * will be inserted. A few possibilities:
+	       *
+	       * - `which` is `0`. Arrow keys, Esc key, etc.
+	       *
+	       * - `which` is the pressed key code, but no char is available.
+	       *   Ex: 'AltGr + d` in Polish. There is no modified character for
+	       *   this key combination and no character is inserted into the
+	       *   document, but FF fires the keypress for char code `100` anyway.
+	       *   No `input` event will occur.
+	       *
+	       * - `which` is the pressed key code, but a command combination is
+	       *   being used. Ex: `Cmd+C`. No character is inserted, and no
+	       *   `input` event will occur.
+	       */
+	      if (nativeEvent.which && !isKeypressCommand(nativeEvent)) {
+	        return String.fromCharCode(nativeEvent.which);
+	      }
+	      return null;
+	    case 'topCompositionEnd':
+	      return useFallbackCompositionData ? null : nativeEvent.data;
+	    default:
+	      return null;
+	  }
+	}
+
+	/**
+	 * Extract a SyntheticInputEvent for `beforeInput`, based on either native
+	 * `textInput` or fallback behavior.
+	 *
+	 * @return {?object} A SyntheticInputEvent.
+	 */
+	function extractBeforeInputEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+	  var chars;
+
+	  if (canUseTextInputEvent) {
+	    chars = getNativeBeforeInputChars(topLevelType, nativeEvent);
+	  } else {
+	    chars = getFallbackBeforeInputChars(topLevelType, nativeEvent);
+	  }
+
+	  // If no characters are being inserted, no BeforeInput event should
+	  // be fired.
+	  if (!chars) {
+	    return null;
+	  }
+
+	  var event = SyntheticInputEvent.getPooled(eventTypes.beforeInput, targetInst, nativeEvent, nativeEventTarget);
+
+	  event.data = chars;
+	  EventPropagators.accumulateTwoPhaseDispatches(event);
+	  return event;
+	}
+
+	/**
+	 * Create an `onBeforeInput` event to match
+	 * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.
+	 *
+	 * This event plugin is based on the native `textInput` event
+	 * available in Chrome, Safari, Opera, and IE. This event fires after
+	 * `onKeyPress` and `onCompositionEnd`, but before `onInput`.
+	 *
+	 * `beforeInput` is spec'd but not implemented in any browsers, and
+	 * the `input` event does not provide any useful information about what has
+	 * actually been added, contrary to the spec. Thus, `textInput` is the best
+	 * available event to identify the characters that have actually been inserted
+	 * into the target node.
+	 *
+	 * This plugin is also responsible for emitting `composition` events, thus
+	 * allowing us to share composition fallback code for both `beforeInput` and
+	 * `composition` event types.
+	 */
+	var BeforeInputEventPlugin = {
+
+	  eventTypes: eventTypes,
+
+	  extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+	    return [extractCompositionEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget), extractBeforeInputEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget)];
+	  }
+	};
+
+	module.exports = BeforeInputEventPlugin;
+
+/***/ },
+/* 42 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var EventPluginHub = __webpack_require__(43);
+	var EventPluginUtils = __webpack_require__(45);
+
+	var accumulateInto = __webpack_require__(49);
+	var forEachAccumulated = __webpack_require__(50);
+	var warning = __webpack_require__(47);
+
+	var getListener = EventPluginHub.getListener;
+
+	/**
+	 * Some event types have a notion of different registration names for different
+	 * "phases" of propagation. This finds listeners by a given phase.
+	 */
+	function listenerAtPhase(inst, event, propagationPhase) {
+	  var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
+	  return getListener(inst, registrationName);
+	}
+
+	/**
+	 * 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(inst, phase, event) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    process.env.NODE_ENV !== 'production' ? warning(inst, 'Dispatching inst must not be null') : void 0;
+	  }
+	  var listener = listenerAtPhase(inst, event, phase);
+	  if (listener) {
+	    event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
+	    event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
+	  }
+	}
+
+	/**
+	 * 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 cannot perform a
+	 * single traversal for the entire collection of events because each event may
+	 * have a different target.
+	 */
+	function accumulateTwoPhaseDispatchesSingle(event) {
+	  if (event && event.dispatchConfig.phasedRegistrationNames) {
+	    EventPluginUtils.traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
+	  }
+	}
+
+	/**
+	 * Same as `accumulateTwoPhaseDispatchesSingle`, but skips over the targetID.
+	 */
+	function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
+	  if (event && event.dispatchConfig.phasedRegistrationNames) {
+	    var targetInst = event._targetInst;
+	    var parentInst = targetInst ? EventPluginUtils.getParentInstance(targetInst) : null;
+	    EventPluginUtils.traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
+	  }
+	}
+
+	/**
+	 * Accumulates without regard to direction, does not look for phased
+	 * registration names. Same as `accumulateDirectDispatchesSingle` but without
+	 * requiring that the `dispatchMarker` be the same as the dispatched ID.
+	 */
+	function accumulateDispatches(inst, ignoredDirection, event) {
+	  if (event && event.dispatchConfig.registrationName) {
+	    var registrationName = event.dispatchConfig.registrationName;
+	    var listener = getListener(inst, registrationName);
+	    if (listener) {
+	      event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
+	      event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
+	    }
+	  }
+	}
+
+	/**
+	 * Accumulates dispatches on an `SyntheticEvent`, but only for the
+	 * `dispatchMarker`.
+	 * @param {SyntheticEvent} event
+	 */
+	function accumulateDirectDispatchesSingle(event) {
+	  if (event && event.dispatchConfig.registrationName) {
+	    accumulateDispatches(event._targetInst, null, event);
+	  }
+	}
+
+	function accumulateTwoPhaseDispatches(events) {
+	  forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);
+	}
+
+	function accumulateTwoPhaseDispatchesSkipTarget(events) {
+	  forEachAccumulated(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
+	}
+
+	function accumulateEnterLeaveDispatches(leave, enter, from, to) {
+	  EventPluginUtils.traverseEnterLeave(from, to, accumulateDispatches, leave, enter);
+	}
+
+	function accumulateDirectDispatches(events) {
+	  forEachAccumulated(events, 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,
+	  accumulateTwoPhaseDispatchesSkipTarget: accumulateTwoPhaseDispatchesSkipTarget,
+	  accumulateDirectDispatches: accumulateDirectDispatches,
+	  accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches
+	};
+
+	module.exports = EventPropagators;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 43 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var EventPluginRegistry = __webpack_require__(44);
+	var EventPluginUtils = __webpack_require__(45);
+	var ReactErrorUtils = __webpack_require__(46);
+
+	var accumulateInto = __webpack_require__(49);
+	var forEachAccumulated = __webpack_require__(50);
+	var invariant = __webpack_require__(37);
+
+	/**
+	 * Internal store for event listeners
+	 */
+	var listenerBank = {};
+
+	/**
+	 * Internal queue of events that have accumulated their dispatches and are
+	 * waiting to have their dispatches executed.
+	 */
+	var eventQueue = null;
+
+	/**
+	 * Dispatches an event and releases it back into the pool, unless persistent.
+	 *
+	 * @param {?object} event Synthetic event to be dispatched.
+	 * @param {boolean} simulated If the event is simulated (changes exn behavior)
+	 * @private
+	 */
+	var executeDispatchesAndRelease = function (event, simulated) {
+	  if (event) {
+	    EventPluginUtils.executeDispatchesInOrder(event, simulated);
+
+	    if (!event.isPersistent()) {
+	      event.constructor.release(event);
+	    }
+	  }
+	};
+	var executeDispatchesAndReleaseSimulated = function (e) {
+	  return executeDispatchesAndRelease(e, true);
+	};
+	var executeDispatchesAndReleaseTopLevel = function (e) {
+	  return executeDispatchesAndRelease(e, false);
+	};
+
+	var getDictionaryKey = function (inst) {
+	  // Prevents V8 performance issue:
+	  // https://github.com/facebook/react/pull/7232
+	  return '.' + inst._rootNodeID;
+	};
+
+	function isInteractive(tag) {
+	  return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea';
+	}
+
+	function shouldPreventMouseEvent(name, type, props) {
+	  switch (name) {
+	    case 'onClick':
+	    case 'onClickCapture':
+	    case 'onDoubleClick':
+	    case 'onDoubleClickCapture':
+	    case 'onMouseDown':
+	    case 'onMouseDownCapture':
+	    case 'onMouseMove':
+	    case 'onMouseMoveCapture':
+	    case 'onMouseUp':
+	    case 'onMouseUpCapture':
+	      return !!(props.disabled && isInteractive(type));
+	    default:
+	      return false;
+	  }
+	}
+
+	/**
+	 * This is a unified interface for event plugins to be installed and configured.
+	 *
+	 * Event plugins can implement the following properties:
+	 *
+	 *   `extractEvents` {function(string, DOMEventTarget, string, object): *}
+	 *     Required. When a top-level event is fired, this method is expected to
+	 *     extract synthetic events that will in turn be queued and dispatched.
+	 *
+	 *   `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`.
+	 *
+	 *   `executeDispatch` {function(object, function, string)}
+	 *     Optional, allows plugins to override how an event gets dispatched. By
+	 *     default, the listener is simply invoked.
+	 *
+	 * Each plugin that is injected into `EventsPluginHub` is immediately operable.
+	 *
+	 * @public
+	 */
+	var EventPluginHub = {
+
+	  /**
+	   * Methods for injecting dependencies.
+	   */
+	  injection: {
+
+	    /**
+	     * @param {array} InjectedEventPluginOrder
+	     * @public
+	     */
+	    injectEventPluginOrder: EventPluginRegistry.injectEventPluginOrder,
+
+	    /**
+	     * @param {object} injectedNamesToPlugins Map from names to plugin modules.
+	     */
+	    injectEventPluginsByName: EventPluginRegistry.injectEventPluginsByName
+
+	  },
+
+	  /**
+	   * Stores `listener` at `listenerBank[registrationName][key]`. Is idempotent.
+	   *
+	   * @param {object} inst The instance, which is the source of events.
+	   * @param {string} registrationName Name of listener (e.g. `onClick`).
+	   * @param {function} listener The callback to store.
+	   */
+	  putListener: function (inst, registrationName, listener) {
+	    !(typeof listener === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected %s listener to be a function, instead got type %s', registrationName, typeof listener) : _prodInvariant('94', registrationName, typeof listener) : void 0;
+
+	    var key = getDictionaryKey(inst);
+	    var bankForRegistrationName = listenerBank[registrationName] || (listenerBank[registrationName] = {});
+	    bankForRegistrationName[key] = listener;
+
+	    var PluginModule = EventPluginRegistry.registrationNameModules[registrationName];
+	    if (PluginModule && PluginModule.didPutListener) {
+	      PluginModule.didPutListener(inst, registrationName, listener);
+	    }
+	  },
+
+	  /**
+	   * @param {object} inst The instance, which is the source of events.
+	   * @param {string} registrationName Name of listener (e.g. `onClick`).
+	   * @return {?function} The stored callback.
+	   */
+	  getListener: function (inst, registrationName) {
+	    // TODO: shouldPreventMouseEvent is DOM-specific and definitely should not
+	    // live here; needs to be moved to a better place soon
+	    var bankForRegistrationName = listenerBank[registrationName];
+	    if (shouldPreventMouseEvent(registrationName, inst._currentElement.type, inst._currentElement.props)) {
+	      return null;
+	    }
+	    var key = getDictionaryKey(inst);
+	    return bankForRegistrationName && bankForRegistrationName[key];
+	  },
+
+	  /**
+	   * Deletes a listener from the registration bank.
+	   *
+	   * @param {object} inst The instance, which is the source of events.
+	   * @param {string} registrationName Name of listener (e.g. `onClick`).
+	   */
+	  deleteListener: function (inst, registrationName) {
+	    var PluginModule = EventPluginRegistry.registrationNameModules[registrationName];
+	    if (PluginModule && PluginModule.willDeleteListener) {
+	      PluginModule.willDeleteListener(inst, registrationName);
+	    }
+
+	    var bankForRegistrationName = listenerBank[registrationName];
+	    // TODO: This should never be null -- when is it?
+	    if (bankForRegistrationName) {
+	      var key = getDictionaryKey(inst);
+	      delete bankForRegistrationName[key];
+	    }
+	  },
+
+	  /**
+	   * Deletes all listeners for the DOM element with the supplied ID.
+	   *
+	   * @param {object} inst The instance, which is the source of events.
+	   */
+	  deleteAllListeners: function (inst) {
+	    var key = getDictionaryKey(inst);
+	    for (var registrationName in listenerBank) {
+	      if (!listenerBank.hasOwnProperty(registrationName)) {
+	        continue;
+	      }
+
+	      if (!listenerBank[registrationName][key]) {
+	        continue;
+	      }
+
+	      var PluginModule = EventPluginRegistry.registrationNameModules[registrationName];
+	      if (PluginModule && PluginModule.willDeleteListener) {
+	        PluginModule.willDeleteListener(inst, registrationName);
+	      }
+
+	      delete listenerBank[registrationName][key];
+	    }
+	  },
+
+	  /**
+	   * Allows registered plugins an opportunity to extract events from top-level
+	   * native browser events.
+	   *
+	   * @return {*} An accumulation of synthetic events.
+	   * @internal
+	   */
+	  extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+	    var events;
+	    var plugins = EventPluginRegistry.plugins;
+	    for (var i = 0; i < plugins.length; i++) {
+	      // Not every plugin in the ordering may be loaded at runtime.
+	      var possiblePlugin = plugins[i];
+	      if (possiblePlugin) {
+	        var extractedEvents = possiblePlugin.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
+	        if (extractedEvents) {
+	          events = accumulateInto(events, extractedEvents);
+	        }
+	      }
+	    }
+	    return events;
+	  },
+
+	  /**
+	   * Enqueues a synthetic event that should be dispatched when
+	   * `processEventQueue` is invoked.
+	   *
+	   * @param {*} events An accumulation of synthetic events.
+	   * @internal
+	   */
+	  enqueueEvents: function (events) {
+	    if (events) {
+	      eventQueue = accumulateInto(eventQueue, events);
+	    }
+	  },
+
+	  /**
+	   * Dispatches all synthetic events on the event queue.
+	   *
+	   * @internal
+	   */
+	  processEventQueue: function (simulated) {
+	    // Set `eventQueue` to null before processing it so that we can tell if more
+	    // events get enqueued while processing.
+	    var processingEventQueue = eventQueue;
+	    eventQueue = null;
+	    if (simulated) {
+	      forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseSimulated);
+	    } else {
+	      forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseTopLevel);
+	    }
+	    !!eventQueue ? process.env.NODE_ENV !== 'production' ? invariant(false, 'processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented.') : _prodInvariant('95') : void 0;
+	    // This would be a good time to rethrow if any of the event handlers threw.
+	    ReactErrorUtils.rethrowCaughtError();
+	  },
+
+	  /**
+	   * These are needed for tests only. Do not use!
+	   */
+	  __purge: function () {
+	    listenerBank = {};
+	  },
+
+	  __getListenerBank: function () {
+	    return listenerBank;
+	  }
+
+	};
+
+	module.exports = EventPluginHub;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 44 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var invariant = __webpack_require__(37);
+
+	/**
+	 * Injectable ordering of event plugins.
+	 */
+	var eventPluginOrder = null;
+
+	/**
+	 * Injectable mapping from names to event plugin modules.
+	 */
+	var namesToPlugins = {};
+
+	/**
+	 * Recomputes the plugin list using the injected plugins and plugin ordering.
+	 *
+	 * @private
+	 */
+	function recomputePluginOrdering() {
+	  if (!eventPluginOrder) {
+	    // Wait until an `eventPluginOrder` is injected.
+	    return;
+	  }
+	  for (var pluginName in namesToPlugins) {
+	    var pluginModule = namesToPlugins[pluginName];
+	    var pluginIndex = eventPluginOrder.indexOf(pluginName);
+	    !(pluginIndex > -1) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `%s`.', pluginName) : _prodInvariant('96', pluginName) : void 0;
+	    if (EventPluginRegistry.plugins[pluginIndex]) {
+	      continue;
+	    }
+	    !pluginModule.extractEvents ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `%s` does not.', pluginName) : _prodInvariant('97', pluginName) : void 0;
+	    EventPluginRegistry.plugins[pluginIndex] = pluginModule;
+	    var publishedEvents = pluginModule.eventTypes;
+	    for (var eventName in publishedEvents) {
+	      !publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.', eventName, pluginName) : _prodInvariant('98', eventName, pluginName) : void 0;
+	    }
+	  }
+	}
+
+	/**
+	 * Publishes an event so that it can be dispatched by the supplied plugin.
+	 *
+	 * @param {object} dispatchConfig Dispatch configuration for the event.
+	 * @param {object} PluginModule Plugin publishing the event.
+	 * @return {boolean} True if the event was successfully published.
+	 * @private
+	 */
+	function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {
+	  !!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same event name, `%s`.', eventName) : _prodInvariant('99', eventName) : void 0;
+	  EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig;
+
+	  var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
+	  if (phasedRegistrationNames) {
+	    for (var phaseName in phasedRegistrationNames) {
+	      if (phasedRegistrationNames.hasOwnProperty(phaseName)) {
+	        var phasedRegistrationName = phasedRegistrationNames[phaseName];
+	        publishRegistrationName(phasedRegistrationName, pluginModule, eventName);
+	      }
+	    }
+	    return true;
+	  } else if (dispatchConfig.registrationName) {
+	    publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName);
+	    return true;
+	  }
+	  return false;
+	}
+
+	/**
+	 * Publishes a registration name that is used to identify dispatched events and
+	 * can be used with `EventPluginHub.putListener` to register listeners.
+	 *
+	 * @param {string} registrationName Registration name to add.
+	 * @param {object} PluginModule Plugin publishing the event.
+	 * @private
+	 */
+	function publishRegistrationName(registrationName, pluginModule, eventName) {
+	  !!EventPluginRegistry.registrationNameModules[registrationName] ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same registration name, `%s`.', registrationName) : _prodInvariant('100', registrationName) : void 0;
+	  EventPluginRegistry.registrationNameModules[registrationName] = pluginModule;
+	  EventPluginRegistry.registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies;
+
+	  if (process.env.NODE_ENV !== 'production') {
+	    var lowerCasedName = registrationName.toLowerCase();
+	    EventPluginRegistry.possibleRegistrationNames[lowerCasedName] = registrationName;
+
+	    if (registrationName === 'onDoubleClick') {
+	      EventPluginRegistry.possibleRegistrationNames.ondblclick = registrationName;
+	    }
+	  }
+	}
+
+	/**
+	 * Registers plugins so that they can extract and dispatch events.
+	 *
+	 * @see {EventPluginHub}
+	 */
+	var EventPluginRegistry = {
+
+	  /**
+	   * Ordered list of injected plugins.
+	   */
+	  plugins: [],
+
+	  /**
+	   * Mapping from event name to dispatch config
+	   */
+	  eventNameDispatchConfigs: {},
+
+	  /**
+	   * Mapping from registration name to plugin module
+	   */
+	  registrationNameModules: {},
+
+	  /**
+	   * Mapping from registration name to event name
+	   */
+	  registrationNameDependencies: {},
+
+	  /**
+	   * Mapping from lowercase registration names to the properly cased version,
+	   * used to warn in the case of missing event handlers. Available
+	   * only in __DEV__.
+	   * @type {Object}
+	   */
+	  possibleRegistrationNames: process.env.NODE_ENV !== 'production' ? {} : null,
+	  // Trust the developer to only use possibleRegistrationNames in __DEV__
+
+	  /**
+	   * Injects an ordering of plugins (by plugin name). This allows the ordering
+	   * to be decoupled from injection of the actual plugins so that ordering is
+	   * always deterministic regardless of packaging, on-the-fly injection, etc.
+	   *
+	   * @param {array} InjectedEventPluginOrder
+	   * @internal
+	   * @see {EventPluginHub.injection.injectEventPluginOrder}
+	   */
+	  injectEventPluginOrder: function (injectedEventPluginOrder) {
+	    !!eventPluginOrder ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React.') : _prodInvariant('101') : void 0;
+	    // Clone the ordering so it cannot be dynamically mutated.
+	    eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder);
+	    recomputePluginOrdering();
+	  },
+
+	  /**
+	   * Injects plugins to be used by `EventPluginHub`. The plugin names must be
+	   * in the ordering injected by `injectEventPluginOrder`.
+	   *
+	   * Plugins can be injected as part of page initialization or on-the-fly.
+	   *
+	   * @param {object} injectedNamesToPlugins Map from names to plugin modules.
+	   * @internal
+	   * @see {EventPluginHub.injection.injectEventPluginsByName}
+	   */
+	  injectEventPluginsByName: function (injectedNamesToPlugins) {
+	    var isOrderingDirty = false;
+	    for (var pluginName in injectedNamesToPlugins) {
+	      if (!injectedNamesToPlugins.hasOwnProperty(pluginName)) {
+	        continue;
+	      }
+	      var pluginModule = injectedNamesToPlugins[pluginName];
+	      if (!namesToPlugins.hasOwnProperty(pluginName) || namesToPlugins[pluginName] !== pluginModule) {
+	        !!namesToPlugins[pluginName] ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject two different event plugins using the same name, `%s`.', pluginName) : _prodInvariant('102', pluginName) : void 0;
+	        namesToPlugins[pluginName] = pluginModule;
+	        isOrderingDirty = true;
+	      }
+	    }
+	    if (isOrderingDirty) {
+	      recomputePluginOrdering();
+	    }
+	  },
+
+	  /**
+	   * Looks up the plugin for the supplied event.
+	   *
+	   * @param {object} event A synthetic event.
+	   * @return {?object} The plugin that created the supplied event.
+	   * @internal
+	   */
+	  getPluginModuleForEvent: function (event) {
+	    var dispatchConfig = event.dispatchConfig;
+	    if (dispatchConfig.registrationName) {
+	      return EventPluginRegistry.registrationNameModules[dispatchConfig.registrationName] || null;
+	    }
+	    if (dispatchConfig.phasedRegistrationNames !== undefined) {
+	      // pulling phasedRegistrationNames out of dispatchConfig helps Flow see
+	      // that it is not undefined.
+	      var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
+
+	      for (var phase in phasedRegistrationNames) {
+	        if (!phasedRegistrationNames.hasOwnProperty(phase)) {
+	          continue;
+	        }
+	        var pluginModule = EventPluginRegistry.registrationNameModules[phasedRegistrationNames[phase]];
+	        if (pluginModule) {
+	          return pluginModule;
+	        }
+	      }
+	    }
+	    return null;
+	  },
+
+	  /**
+	   * Exposed for unit testing.
+	   * @private
+	   */
+	  _resetEventPlugins: function () {
+	    eventPluginOrder = null;
+	    for (var pluginName in namesToPlugins) {
+	      if (namesToPlugins.hasOwnProperty(pluginName)) {
+	        delete namesToPlugins[pluginName];
+	      }
+	    }
+	    EventPluginRegistry.plugins.length = 0;
+
+	    var eventNameDispatchConfigs = EventPluginRegistry.eventNameDispatchConfigs;
+	    for (var eventName in eventNameDispatchConfigs) {
+	      if (eventNameDispatchConfigs.hasOwnProperty(eventName)) {
+	        delete eventNameDispatchConfigs[eventName];
+	      }
+	    }
+
+	    var registrationNameModules = EventPluginRegistry.registrationNameModules;
+	    for (var registrationName in registrationNameModules) {
+	      if (registrationNameModules.hasOwnProperty(registrationName)) {
+	        delete registrationNameModules[registrationName];
+	      }
+	    }
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      var possibleRegistrationNames = EventPluginRegistry.possibleRegistrationNames;
+	      for (var lowerCasedName in possibleRegistrationNames) {
+	        if (possibleRegistrationNames.hasOwnProperty(lowerCasedName)) {
+	          delete possibleRegistrationNames[lowerCasedName];
+	        }
+	      }
+	    }
+	  }
+
+	};
+
+	module.exports = EventPluginRegistry;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 45 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var ReactErrorUtils = __webpack_require__(46);
+
+	var invariant = __webpack_require__(37);
+	var warning = __webpack_require__(47);
+
+	/**
+	 * Injected dependencies:
+	 */
+
+	/**
+	 * - `ComponentTree`: [required] Module that can convert between React instances
+	 *   and actual node references.
+	 */
+	var ComponentTree;
+	var TreeTraversal;
+	var injection = {
+	  injectComponentTree: function (Injected) {
+	    ComponentTree = Injected;
+	    if (process.env.NODE_ENV !== 'production') {
+	      process.env.NODE_ENV !== 'production' ? warning(Injected && Injected.getNodeFromInstance && Injected.getInstanceFromNode, 'EventPluginUtils.injection.injectComponentTree(...): Injected ' + 'module is missing getNodeFromInstance or getInstanceFromNode.') : void 0;
+	    }
+	  },
+	  injectTreeTraversal: function (Injected) {
+	    TreeTraversal = Injected;
+	    if (process.env.NODE_ENV !== 'production') {
+	      process.env.NODE_ENV !== 'production' ? warning(Injected && Injected.isAncestor && Injected.getLowestCommonAncestor, 'EventPluginUtils.injection.injectTreeTraversal(...): Injected ' + 'module is missing isAncestor or getLowestCommonAncestor.') : void 0;
+	    }
+	  }
+	};
+
+	function isEndish(topLevelType) {
+	  return topLevelType === 'topMouseUp' || topLevelType === 'topTouchEnd' || topLevelType === 'topTouchCancel';
+	}
+
+	function isMoveish(topLevelType) {
+	  return topLevelType === 'topMouseMove' || topLevelType === 'topTouchMove';
+	}
+	function isStartish(topLevelType) {
+	  return topLevelType === 'topMouseDown' || topLevelType === 'topTouchStart';
+	}
+
+	var validateEventDispatches;
+	if (process.env.NODE_ENV !== 'production') {
+	  validateEventDispatches = function (event) {
+	    var dispatchListeners = event._dispatchListeners;
+	    var dispatchInstances = event._dispatchInstances;
+
+	    var listenersIsArr = Array.isArray(dispatchListeners);
+	    var listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0;
+
+	    var instancesIsArr = Array.isArray(dispatchInstances);
+	    var instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;
+
+	    process.env.NODE_ENV !== 'production' ? warning(instancesIsArr === listenersIsArr && instancesLen === listenersLen, 'EventPluginUtils: Invalid `event`.') : void 0;
+	  };
+	}
+
+	/**
+	 * Dispatch the event to the listener.
+	 * @param {SyntheticEvent} event SyntheticEvent to handle
+	 * @param {boolean} simulated If the event is simulated (changes exn behavior)
+	 * @param {function} listener Application-level callback
+	 * @param {*} inst Internal component instance
+	 */
+	function executeDispatch(event, simulated, listener, inst) {
+	  var type = event.type || 'unknown-event';
+	  event.currentTarget = EventPluginUtils.getNodeFromInstance(inst);
+	  if (simulated) {
+	    ReactErrorUtils.invokeGuardedCallbackWithCatch(type, listener, event);
+	  } else {
+	    ReactErrorUtils.invokeGuardedCallback(type, listener, event);
+	  }
+	  event.currentTarget = null;
+	}
+
+	/**
+	 * Standard/simple iteration through an event's collected dispatches.
+	 */
+	function executeDispatchesInOrder(event, simulated) {
+	  var dispatchListeners = event._dispatchListeners;
+	  var dispatchInstances = event._dispatchInstances;
+	  if (process.env.NODE_ENV !== 'production') {
+	    validateEventDispatches(event);
+	  }
+	  if (Array.isArray(dispatchListeners)) {
+	    for (var i = 0; i < dispatchListeners.length; i++) {
+	      if (event.isPropagationStopped()) {
+	        break;
+	      }
+	      // Listeners and Instances are two parallel arrays that are always in sync.
+	      executeDispatch(event, simulated, dispatchListeners[i], dispatchInstances[i]);
+	    }
+	  } else if (dispatchListeners) {
+	    executeDispatch(event, simulated, dispatchListeners, dispatchInstances);
+	  }
+	  event._dispatchListeners = null;
+	  event._dispatchInstances = null;
+	}
+
+	/**
+	 * Standard/simple iteration through an event's collected dispatches, but stops
+	 * at the first dispatch execution returning true, and returns that id.
+	 *
+	 * @return {?string} id of the first dispatch execution who's listener returns
+	 * true, or null if no listener returned true.
+	 */
+	function executeDispatchesInOrderStopAtTrueImpl(event) {
+	  var dispatchListeners = event._dispatchListeners;
+	  var dispatchInstances = event._dispatchInstances;
+	  if (process.env.NODE_ENV !== 'production') {
+	    validateEventDispatches(event);
+	  }
+	  if (Array.isArray(dispatchListeners)) {
+	    for (var i = 0; i < dispatchListeners.length; i++) {
+	      if (event.isPropagationStopped()) {
+	        break;
+	      }
+	      // Listeners and Instances are two parallel arrays that are always in sync.
+	      if (dispatchListeners[i](event, dispatchInstances[i])) {
+	        return dispatchInstances[i];
+	      }
+	    }
+	  } else if (dispatchListeners) {
+	    if (dispatchListeners(event, dispatchInstances)) {
+	      return dispatchInstances;
+	    }
+	  }
+	  return null;
+	}
+
+	/**
+	 * @see executeDispatchesInOrderStopAtTrueImpl
+	 */
+	function executeDispatchesInOrderStopAtTrue(event) {
+	  var ret = executeDispatchesInOrderStopAtTrueImpl(event);
+	  event._dispatchInstances = null;
+	  event._dispatchListeners = null;
+	  return ret;
+	}
+
+	/**
+	 * 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.
+	 *
+	 * @return {*} The return value of executing the single dispatch.
+	 */
+	function executeDirectDispatch(event) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    validateEventDispatches(event);
+	  }
+	  var dispatchListener = event._dispatchListeners;
+	  var dispatchInstance = event._dispatchInstances;
+	  !!Array.isArray(dispatchListener) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'executeDirectDispatch(...): Invalid `event`.') : _prodInvariant('103') : void 0;
+	  event.currentTarget = dispatchListener ? EventPluginUtils.getNodeFromInstance(dispatchInstance) : null;
+	  var res = dispatchListener ? dispatchListener(event) : null;
+	  event.currentTarget = null;
+	  event._dispatchListeners = null;
+	  event._dispatchInstances = null;
+	  return res;
+	}
+
+	/**
+	 * @param {SyntheticEvent} event
+	 * @return {boolean} True iff number of dispatches accumulated is greater than 0.
+	 */
+	function hasDispatches(event) {
+	  return !!event._dispatchListeners;
+	}
+
+	/**
+	 * General utilities that are useful in creating custom Event Plugins.
+	 */
+	var EventPluginUtils = {
+	  isEndish: isEndish,
+	  isMoveish: isMoveish,
+	  isStartish: isStartish,
+
+	  executeDirectDispatch: executeDirectDispatch,
+	  executeDispatchesInOrder: executeDispatchesInOrder,
+	  executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,
+	  hasDispatches: hasDispatches,
+
+	  getInstanceFromNode: function (node) {
+	    return ComponentTree.getInstanceFromNode(node);
+	  },
+	  getNodeFromInstance: function (node) {
+	    return ComponentTree.getNodeFromInstance(node);
+	  },
+	  isAncestor: function (a, b) {
+	    return TreeTraversal.isAncestor(a, b);
+	  },
+	  getLowestCommonAncestor: function (a, b) {
+	    return TreeTraversal.getLowestCommonAncestor(a, b);
+	  },
+	  getParentInstance: function (inst) {
+	    return TreeTraversal.getParentInstance(inst);
+	  },
+	  traverseTwoPhase: function (target, fn, arg) {
+	    return TreeTraversal.traverseTwoPhase(target, fn, arg);
+	  },
+	  traverseEnterLeave: function (from, to, fn, argFrom, argTo) {
+	    return TreeTraversal.traverseEnterLeave(from, to, fn, argFrom, argTo);
+	  },
+
+	  injection: injection
+	};
+
+	module.exports = EventPluginUtils;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 46 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var caughtError = null;
+
+	/**
+	 * Call a function while guarding against errors that happens within it.
+	 *
+	 * @param {String} name of the guard to use for logging or debugging
+	 * @param {Function} func The function to invoke
+	 * @param {*} a First argument
+	 * @param {*} b Second argument
+	 */
+	function invokeGuardedCallback(name, func, a) {
+	  try {
+	    func(a);
+	  } catch (x) {
+	    if (caughtError === null) {
+	      caughtError = x;
+	    }
+	  }
+	}
+
+	var ReactErrorUtils = {
+	  invokeGuardedCallback: invokeGuardedCallback,
+
+	  /**
+	   * Invoked by ReactTestUtils.Simulate so that any errors thrown by the event
+	   * handler are sure to be rethrown by rethrowCaughtError.
+	   */
+	  invokeGuardedCallbackWithCatch: invokeGuardedCallback,
+
+	  /**
+	   * During execution of guarded functions we will capture the first error which
+	   * we will rethrow to be handled by the top level error handler.
+	   */
+	  rethrowCaughtError: function () {
+	    if (caughtError) {
+	      var error = caughtError;
+	      caughtError = null;
+	      throw error;
+	    }
+	  }
+	};
+
+	if (process.env.NODE_ENV !== 'production') {
+	  /**
+	   * To help development we can get better devtools integration by simulating a
+	   * real browser event.
+	   */
+	  if (typeof window !== 'undefined' && typeof window.dispatchEvent === 'function' && typeof document !== 'undefined' && typeof document.createEvent === 'function') {
+	    var fakeNode = document.createElement('react');
+	    ReactErrorUtils.invokeGuardedCallback = function (name, func, a) {
+	      var boundFunc = func.bind(null, a);
+	      var evtType = 'react-' + name;
+	      fakeNode.addEventListener(evtType, boundFunc, false);
+	      var evt = document.createEvent('Event');
+	      // $FlowFixMe https://github.com/facebook/flow/issues/2336
+	      evt.initEvent(evtType, false, false);
+	      fakeNode.dispatchEvent(evt);
+	      fakeNode.removeEventListener(evtType, boundFunc, false);
+	    };
+	  }
+	}
+
+	module.exports = ReactErrorUtils;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 47 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2014-2015, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var emptyFunction = __webpack_require__(48);
+
+	/**
+	 * Similar to invariant but only logs a warning if the condition is not met.
+	 * This can be used to log issues in development environments in critical
+	 * paths. Removing the logging code for production environments will keep the
+	 * same logic and follow the same code paths.
+	 */
+
+	var warning = emptyFunction;
+
+	if (process.env.NODE_ENV !== 'production') {
+	  (function () {
+	    var printWarning = function printWarning(format) {
+	      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+	        args[_key - 1] = arguments[_key];
+	      }
+
+	      var argIndex = 0;
+	      var message = 'Warning: ' + format.replace(/%s/g, function () {
+	        return args[argIndex++];
+	      });
+	      if (typeof console !== 'undefined') {
+	        console.error(message);
+	      }
+	      try {
+	        // --- Welcome to debugging React ---
+	        // This error was thrown as a convenience so that you can use this stack
+	        // to find the callsite that caused this warning to fire.
+	        throw new Error(message);
+	      } catch (x) {}
+	    };
+
+	    warning = function warning(condition, format) {
+	      if (format === undefined) {
+	        throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
+	      }
+
+	      if (format.indexOf('Failed Composite propType: ') === 0) {
+	        return; // Ignore CompositeComponent proptype check.
+	      }
+
+	      if (!condition) {
+	        for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+	          args[_key2 - 2] = arguments[_key2];
+	        }
+
+	        printWarning.apply(undefined, [format].concat(args));
+	      }
+	    };
+	  })();
+	}
+
+	module.exports = warning;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 48 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	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.
+	 */
+	var emptyFunction = function emptyFunction() {};
+
+	emptyFunction.thatReturns = makeEmptyFunction;
+	emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
+	emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
+	emptyFunction.thatReturnsNull = makeEmptyFunction(null);
+	emptyFunction.thatReturnsThis = function () {
+	  return this;
+	};
+	emptyFunction.thatReturnsArgument = function (arg) {
+	  return arg;
+	};
+
+	module.exports = emptyFunction;
+
+/***/ },
+/* 49 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2014-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var invariant = __webpack_require__(37);
+
+	/**
+	 * Accumulates items that must not be null or undefined into the first one. This
+	 * is used to conserve memory by avoiding array allocations, and thus sacrifices
+	 * API cleanness. Since `current` can be null before being passed in and not
+	 * null after this function, make sure to assign it back to `current`:
+	 *
+	 * `a = accumulateInto(a, b);`
+	 *
+	 * This API should be sparingly used. Try `accumulate` for something cleaner.
+	 *
+	 * @return {*|array<*>} An accumulation of items.
+	 */
+
+	function accumulateInto(current, next) {
+	  !(next != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'accumulateInto(...): Accumulated items must not be null or undefined.') : _prodInvariant('30') : void 0;
+
+	  if (current == null) {
+	    return next;
+	  }
+
+	  // 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).
+	  if (Array.isArray(current)) {
+	    if (Array.isArray(next)) {
+	      current.push.apply(current, next);
+	      return current;
+	    }
+	    current.push(next);
+	    return current;
+	  }
+
+	  if (Array.isArray(next)) {
+	    // A bit too dangerous to mutate `next`.
+	    return [current].concat(next);
+	  }
+
+	  return [current, next];
+	}
+
+	module.exports = accumulateInto;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 50 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	/**
+	 * @param {array} arr 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).
+	 */
+
+	function forEachAccumulated(arr, cb, scope) {
+	  if (Array.isArray(arr)) {
+	    arr.forEach(cb, scope);
+	  } else if (arr) {
+	    cb.call(scope, arr);
+	  }
+	}
+
+	module.exports = forEachAccumulated;
+
+/***/ },
+/* 51 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
+
+	/**
+	 * 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',
+
+	  canUseEventListeners: canUseDOM && !!(window.addEventListener || window.attachEvent),
+
+	  canUseViewport: canUseDOM && !!window.screen,
+
+	  isInWorker: !canUseDOM // For now, this is true - might change in the future.
+
+	};
+
+	module.exports = ExecutionEnvironment;
+
+/***/ },
+/* 52 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _assign = __webpack_require__(53);
+
+	var PooledClass = __webpack_require__(54);
+
+	var getTextContentAccessor = __webpack_require__(55);
+
+	/**
+	 * This helper class stores information about text content of a target node,
+	 * allowing comparison of content before and after a given event.
+	 *
+	 * Identify the node where selection currently begins, then observe
+	 * both its text content and its current position in the DOM. Since the
+	 * browser may natively replace the target node during composition, we can
+	 * use its position to find its replacement.
+	 *
+	 * @param {DOMEventTarget} root
+	 */
+	function FallbackCompositionState(root) {
+	  this._root = root;
+	  this._startText = this.getText();
+	  this._fallbackText = null;
+	}
+
+	_assign(FallbackCompositionState.prototype, {
+	  destructor: function () {
+	    this._root = null;
+	    this._startText = null;
+	    this._fallbackText = null;
+	  },
+
+	  /**
+	   * Get current text of input.
+	   *
+	   * @return {string}
+	   */
+	  getText: function () {
+	    if ('value' in this._root) {
+	      return this._root.value;
+	    }
+	    return this._root[getTextContentAccessor()];
+	  },
+
+	  /**
+	   * Determine the differing substring between the initially stored
+	   * text content and the current content.
+	   *
+	   * @return {string}
+	   */
+	  getData: function () {
+	    if (this._fallbackText) {
+	      return this._fallbackText;
+	    }
+
+	    var start;
+	    var startValue = this._startText;
+	    var startLength = startValue.length;
+	    var end;
+	    var endValue = this.getText();
+	    var endLength = endValue.length;
+
+	    for (start = 0; start < startLength; start++) {
+	      if (startValue[start] !== endValue[start]) {
+	        break;
+	      }
+	    }
+
+	    var minEnd = startLength - start;
+	    for (end = 1; end <= minEnd; end++) {
+	      if (startValue[startLength - end] !== endValue[endLength - end]) {
+	        break;
+	      }
+	    }
+
+	    var sliceTail = end > 1 ? 1 - end : undefined;
+	    this._fallbackText = endValue.slice(start, sliceTail);
+	    return this._fallbackText;
+	  }
+	});
+
+	PooledClass.addPoolingTo(FallbackCompositionState);
+
+	module.exports = FallbackCompositionState;
+
+/***/ },
+/* 53 */
+/***/ function(module, exports) {
+
+	'use strict';
+	/* eslint-disable no-unused-vars */
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+	function toObject(val) {
+		if (val === null || val === undefined) {
+			throw new TypeError('Object.assign cannot be called with null or undefined');
+		}
+
+		return Object(val);
+	}
+
+	function shouldUseNative() {
+		try {
+			if (!Object.assign) {
+				return false;
+			}
+
+			// Detect buggy property enumeration order in older V8 versions.
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=4118
+			var test1 = new String('abc');  // eslint-disable-line
+			test1[5] = 'de';
+			if (Object.getOwnPropertyNames(test1)[0] === '5') {
+				return false;
+			}
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+			var test2 = {};
+			for (var i = 0; i < 10; i++) {
+				test2['_' + String.fromCharCode(i)] = i;
+			}
+			var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+				return test2[n];
+			});
+			if (order2.join('') !== '0123456789') {
+				return false;
+			}
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+			var test3 = {};
+			'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+				test3[letter] = letter;
+			});
+			if (Object.keys(Object.assign({}, test3)).join('') !==
+					'abcdefghijklmnopqrst') {
+				return false;
+			}
+
+			return true;
+		} catch (e) {
+			// We don't expect any of the above to throw, but better to be safe.
+			return false;
+		}
+	}
+
+	module.exports = shouldUseNative() ? Object.assign : function (target, source) {
+		var from;
+		var to = toObject(target);
+		var symbols;
+
+		for (var s = 1; s < arguments.length; s++) {
+			from = Object(arguments[s]);
+
+			for (var key in from) {
+				if (hasOwnProperty.call(from, key)) {
+					to[key] = from[key];
+				}
+			}
+
+			if (Object.getOwnPropertySymbols) {
+				symbols = Object.getOwnPropertySymbols(from);
+				for (var i = 0; i < symbols.length; i++) {
+					if (propIsEnumerable.call(from, symbols[i])) {
+						to[symbols[i]] = from[symbols[i]];
+					}
+				}
+			}
+		}
+
+		return to;
+	};
+
+
+/***/ },
+/* 54 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var invariant = __webpack_require__(37);
+
+	/**
+	 * 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 threeArgumentPooler = function (a1, a2, a3) {
+	  var Klass = this;
+	  if (Klass.instancePool.length) {
+	    var instance = Klass.instancePool.pop();
+	    Klass.call(instance, a1, a2, a3);
+	    return instance;
+	  } else {
+	    return new Klass(a1, a2, a3);
+	  }
+	};
+
+	var fourArgumentPooler = function (a1, a2, a3, a4) {
+	  var Klass = this;
+	  if (Klass.instancePool.length) {
+	    var instance = Klass.instancePool.pop();
+	    Klass.call(instance, a1, a2, a3, a4);
+	    return instance;
+	  } else {
+	    return new Klass(a1, a2, a3, a4);
+	  }
+	};
+
+	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;
+	  !(instance instanceof Klass) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Trying to release an instance into a pool of a different type.') : _prodInvariant('25') : void 0;
+	  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.
+	 *
+	 * @param {Function} CopyConstructor Constructor that can be used to reset.
+	 * @param {Function} pooler Customizable pooler.
+	 */
+	var addPoolingTo = function (CopyConstructor, pooler) {
+	  // Casting as any so that flow ignores the actual implementation and trusts
+	  // it to match the type we declared
+	  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,
+	  threeArgumentPooler: threeArgumentPooler,
+	  fourArgumentPooler: fourArgumentPooler,
+	  fiveArgumentPooler: fiveArgumentPooler
+	};
+
+	module.exports = PooledClass;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 55 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ExecutionEnvironment = __webpack_require__(51);
+
+	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) {
+	    // Prefer textContent to innerText because many browsers support both but
+	    // SVG <text> elements don't support innerText even when <div> does.
+	    contentKey = 'textContent' in document.documentElement ? 'textContent' : 'innerText';
+	  }
+	  return contentKey;
+	}
+
+	module.exports = getTextContentAccessor;
+
+/***/ },
+/* 56 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var SyntheticEvent = __webpack_require__(57);
+
+	/**
+	 * @interface Event
+	 * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
+	 */
+	var CompositionEventInterface = {
+	  data: null
+	};
+
+	/**
+	 * @param {object} dispatchConfig Configuration used to dispatch this event.
+	 * @param {string} dispatchMarker Marker identifying the event target.
+	 * @param {object} nativeEvent Native browser event.
+	 * @extends {SyntheticUIEvent}
+	 */
+	function SyntheticCompositionEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
+	  return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
+	}
+
+	SyntheticEvent.augmentClass(SyntheticCompositionEvent, CompositionEventInterface);
+
+	module.exports = SyntheticCompositionEvent;
+
+/***/ },
+/* 57 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _assign = __webpack_require__(53);
+
+	var PooledClass = __webpack_require__(54);
+
+	var emptyFunction = __webpack_require__(48);
+	var warning = __webpack_require__(47);
+
+	var didWarnForAddedNewProperty = false;
+	var isProxySupported = typeof Proxy === 'function';
+
+	var shouldBeReleasedProperties = ['dispatchConfig', '_targetInst', 'nativeEvent', 'isDefaultPrevented', 'isPropagationStopped', '_dispatchListeners', '_dispatchInstances'];
+
+	/**
+	 * @interface Event
+	 * @see http://www.w3.org/TR/DOM-Level-3-Events/
+	 */
+	var EventInterface = {
+	  type: null,
+	  target: null,
+	  // currentTarget is set when dispatching; no use in copying it here
+	  currentTarget: emptyFunction.thatReturnsNull,
+	  eventPhase: null,
+	  bubbles: null,
+	  cancelable: null,
+	  timeStamp: function (event) {
+	    return event.timeStamp || Date.now();
+	  },
+	  defaultPrevented: null,
+	  isTrusted: null
+	};
+
+	/**
+	 * Synthetic events are dispatched by event plugins, typically in response to a
+	 * top-level event delegation handler.
+	 *
+	 * These systems should generally use pooling to reduce the frequency of garbage
+	 * collection. The system should check `isPersistent` to determine whether the
+	 * event should be released into the pool after being dispatched. Users that
+	 * need a persisted event should invoke `persist`.
+	 *
+	 * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
+	 * normalizing browser quirks. Subclasses do not necessarily have to implement a
+	 * DOM interface; custom application-specific events can also subclass this.
+	 *
+	 * @param {object} dispatchConfig Configuration used to dispatch this event.
+	 * @param {*} targetInst Marker identifying the event target.
+	 * @param {object} nativeEvent Native browser event.
+	 * @param {DOMEventTarget} nativeEventTarget Target node.
+	 */
+	function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    // these have a getter/setter for warnings
+	    delete this.nativeEvent;
+	    delete this.preventDefault;
+	    delete this.stopPropagation;
+	  }
+
+	  this.dispatchConfig = dispatchConfig;
+	  this._targetInst = targetInst;
+	  this.nativeEvent = nativeEvent;
+
+	  var Interface = this.constructor.Interface;
+	  for (var propName in Interface) {
+	    if (!Interface.hasOwnProperty(propName)) {
+	      continue;
+	    }
+	    if (process.env.NODE_ENV !== 'production') {
+	      delete this[propName]; // this has a getter/setter for warnings
+	    }
+	    var normalize = Interface[propName];
+	    if (normalize) {
+	      this[propName] = normalize(nativeEvent);
+	    } else {
+	      if (propName === 'target') {
+	        this.target = nativeEventTarget;
+	      } else {
+	        this[propName] = nativeEvent[propName];
+	      }
+	    }
+	  }
+
+	  var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
+	  if (defaultPrevented) {
+	    this.isDefaultPrevented = emptyFunction.thatReturnsTrue;
+	  } else {
+	    this.isDefaultPrevented = emptyFunction.thatReturnsFalse;
+	  }
+	  this.isPropagationStopped = emptyFunction.thatReturnsFalse;
+	  return this;
+	}
+
+	_assign(SyntheticEvent.prototype, {
+
+	  preventDefault: function () {
+	    this.defaultPrevented = true;
+	    var event = this.nativeEvent;
+	    if (!event) {
+	      return;
+	    }
+
+	    if (event.preventDefault) {
+	      event.preventDefault();
+	    } else if (typeof event.returnValue !== 'unknown') {
+	      // eslint-disable-line valid-typeof
+	      event.returnValue = false;
+	    }
+	    this.isDefaultPrevented = emptyFunction.thatReturnsTrue;
+	  },
+
+	  stopPropagation: function () {
+	    var event = this.nativeEvent;
+	    if (!event) {
+	      return;
+	    }
+
+	    if (event.stopPropagation) {
+	      event.stopPropagation();
+	    } else if (typeof event.cancelBubble !== 'unknown') {
+	      // eslint-disable-line valid-typeof
+	      // The ChangeEventPlugin registers a "propertychange" event for
+	      // IE. This event does not support bubbling or cancelling, and
+	      // any references to cancelBubble throw "Member not found".  A
+	      // typeof check of "unknown" circumvents this issue (and is also
+	      // IE specific).
+	      event.cancelBubble = true;
+	    }
+
+	    this.isPropagationStopped = emptyFunction.thatReturnsTrue;
+	  },
+
+	  /**
+	   * We release all dispatched `SyntheticEvent`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.
+	   */
+	  persist: function () {
+	    this.isPersistent = emptyFunction.thatReturnsTrue;
+	  },
+
+	  /**
+	   * Checks if this event should be released back into the pool.
+	   *
+	   * @return {boolean} True if this should not be released, false otherwise.
+	   */
+	  isPersistent: emptyFunction.thatReturnsFalse,
+
+	  /**
+	   * `PooledClass` looks for `destructor` on each instance it releases.
+	   */
+	  destructor: function () {
+	    var Interface = this.constructor.Interface;
+	    for (var propName in Interface) {
+	      if (process.env.NODE_ENV !== 'production') {
+	        Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
+	      } else {
+	        this[propName] = null;
+	      }
+	    }
+	    for (var i = 0; i < shouldBeReleasedProperties.length; i++) {
+	      this[shouldBeReleasedProperties[i]] = null;
+	    }
+	    if (process.env.NODE_ENV !== 'production') {
+	      Object.defineProperty(this, 'nativeEvent', getPooledWarningPropertyDefinition('nativeEvent', null));
+	      Object.defineProperty(this, 'preventDefault', getPooledWarningPropertyDefinition('preventDefault', emptyFunction));
+	      Object.defineProperty(this, 'stopPropagation', getPooledWarningPropertyDefinition('stopPropagation', emptyFunction));
+	    }
+	  }
+
+	});
+
+	SyntheticEvent.Interface = EventInterface;
+
+	if (process.env.NODE_ENV !== 'production') {
+	  if (isProxySupported) {
+	    /*eslint-disable no-func-assign */
+	    SyntheticEvent = new Proxy(SyntheticEvent, {
+	      construct: function (target, args) {
+	        return this.apply(target, Object.create(target.prototype), args);
+	      },
+	      apply: function (constructor, that, args) {
+	        return new Proxy(constructor.apply(that, args), {
+	          set: function (target, prop, value) {
+	            if (prop !== 'isPersistent' && !target.constructor.Interface.hasOwnProperty(prop) && shouldBeReleasedProperties.indexOf(prop) === -1) {
+	              process.env.NODE_ENV !== 'production' ? warning(didWarnForAddedNewProperty || target.isPersistent(), 'This synthetic event is reused for performance reasons. If you\'re ' + 'seeing this, you\'re adding a new property in the synthetic event object. ' + 'The property is never released. See ' + 'https://fb.me/react-event-pooling for more information.') : void 0;
+	              didWarnForAddedNewProperty = true;
+	            }
+	            target[prop] = value;
+	            return true;
+	          }
+	        });
+	      }
+	    });
+	    /*eslint-enable no-func-assign */
+	  }
+	}
+	/**
+	 * Helper to reduce boilerplate when creating subclasses.
+	 *
+	 * @param {function} Class
+	 * @param {?object} Interface
+	 */
+	SyntheticEvent.augmentClass = function (Class, Interface) {
+	  var Super = this;
+
+	  var E = function () {};
+	  E.prototype = Super.prototype;
+	  var prototype = new E();
+
+	  _assign(prototype, Class.prototype);
+	  Class.prototype = prototype;
+	  Class.prototype.constructor = Class;
+
+	  Class.Interface = _assign({}, Super.Interface, Interface);
+	  Class.augmentClass = Super.augmentClass;
+
+	  PooledClass.addPoolingTo(Class, PooledClass.fourArgumentPooler);
+	};
+
+	PooledClass.addPoolingTo(SyntheticEvent, PooledClass.fourArgumentPooler);
+
+	module.exports = SyntheticEvent;
+
+	/**
+	  * Helper to nullify syntheticEvent instance properties when destructing
+	  *
+	  * @param {object} SyntheticEvent
+	  * @param {String} propName
+	  * @return {object} defineProperty object
+	  */
+	function getPooledWarningPropertyDefinition(propName, getVal) {
+	  var isFunction = typeof getVal === 'function';
+	  return {
+	    configurable: true,
+	    set: set,
+	    get: get
+	  };
+
+	  function set(val) {
+	    var action = isFunction ? 'setting the method' : 'setting the property';
+	    warn(action, 'This is effectively a no-op');
+	    return val;
+	  }
+
+	  function get() {
+	    var action = isFunction ? 'accessing the method' : 'accessing the property';
+	    var result = isFunction ? 'This is a no-op function' : 'This is set to null';
+	    warn(action, result);
+	    return getVal;
+	  }
+
+	  function warn(action, result) {
+	    var warningCondition = false;
+	    process.env.NODE_ENV !== 'production' ? warning(warningCondition, 'This synthetic event is reused for performance reasons. If you\'re seeing this, ' + 'you\'re %s `%s` on a released/nullified synthetic event. %s. ' + 'If you must keep the original synthetic event around, use event.persist(). ' + 'See https://fb.me/react-event-pooling for more information.', action, propName, result) : void 0;
+	  }
+	}
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 58 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var SyntheticEvent = __webpack_require__(57);
+
+	/**
+	 * @interface Event
+	 * @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105
+	 *      /#events-inputevents
+	 */
+	var InputEventInterface = {
+	  data: null
+	};
+
+	/**
+	 * @param {object} dispatchConfig Configuration used to dispatch this event.
+	 * @param {string} dispatchMarker Marker identifying the event target.
+	 * @param {object} nativeEvent Native browser event.
+	 * @extends {SyntheticUIEvent}
+	 */
+	function SyntheticInputEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
+	  return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
+	}
+
+	SyntheticEvent.augmentClass(SyntheticInputEvent, InputEventInterface);
+
+	module.exports = SyntheticInputEvent;
+
+/***/ },
+/* 59 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var EventPluginHub = __webpack_require__(43);
+	var EventPropagators = __webpack_require__(42);
+	var ExecutionEnvironment = __webpack_require__(51);
+	var ReactDOMComponentTree = __webpack_require__(34);
+	var ReactUpdates = __webpack_require__(60);
+	var SyntheticEvent = __webpack_require__(57);
+
+	var getEventTarget = __webpack_require__(73);
+	var isEventSupported = __webpack_require__(74);
+	var isTextInputElement = __webpack_require__(75);
+
+	var eventTypes = {
+	  change: {
+	    phasedRegistrationNames: {
+	      bubbled: 'onChange',
+	      captured: 'onChangeCapture'
+	    },
+	    dependencies: ['topBlur', 'topChange', 'topClick', 'topFocus', 'topInput', 'topKeyDown', 'topKeyUp', 'topSelectionChange']
+	  }
+	};
+
+	/**
+	 * For IE shims
+	 */
+	var activeElement = null;
+	var activeElementInst = null;
+	var activeElementValue = null;
+	var activeElementValueProp = null;
+
+	/**
+	 * SECTION: handle `change` event
+	 */
+	function shouldUseChangeEvent(elem) {
+	  var nodeName = elem.nodeName && elem.nodeName.toLowerCase();
+	  return nodeName === 'select' || nodeName === 'input' && elem.type === 'file';
+	}
+
+	var doesChangeEventBubble = false;
+	if (ExecutionEnvironment.canUseDOM) {
+	  // See `handleChange` comment below
+	  doesChangeEventBubble = isEventSupported('change') && (!document.documentMode || document.documentMode > 8);
+	}
+
+	function manualDispatchChangeEvent(nativeEvent) {
+	  var event = SyntheticEvent.getPooled(eventTypes.change, activeElementInst, nativeEvent, getEventTarget(nativeEvent));
+	  EventPropagators.accumulateTwoPhaseDispatches(event);
+
+	  // If change and propertychange bubbled, we'd just bind to it like all the
+	  // other events and have it go through ReactBrowserEventEmitter. Since it
+	  // doesn't, we manually listen for the events and so we have to enqueue and
+	  // process the abstract event manually.
+	  //
+	  // Batching is necessary here in order to ensure that all event handlers run
+	  // before the next rerender (including event handlers attached to ancestor
+	  // elements instead of directly on the input). Without this, controlled
+	  // components don't work properly in conjunction with event bubbling because
+	  // the component is rerendered and the value reverted before all the event
+	  // handlers can run. See https://github.com/facebook/react/issues/708.
+	  ReactUpdates.batchedUpdates(runEventInBatch, event);
+	}
+
+	function runEventInBatch(event) {
+	  EventPluginHub.enqueueEvents(event);
+	  EventPluginHub.processEventQueue(false);
+	}
+
+	function startWatchingForChangeEventIE8(target, targetInst) {
+	  activeElement = target;
+	  activeElementInst = targetInst;
+	  activeElement.attachEvent('onchange', manualDispatchChangeEvent);
+	}
+
+	function stopWatchingForChangeEventIE8() {
+	  if (!activeElement) {
+	    return;
+	  }
+	  activeElement.detachEvent('onchange', manualDispatchChangeEvent);
+	  activeElement = null;
+	  activeElementInst = null;
+	}
+
+	function getTargetInstForChangeEvent(topLevelType, targetInst) {
+	  if (topLevelType === 'topChange') {
+	    return targetInst;
+	  }
+	}
+	function handleEventsForChangeEventIE8(topLevelType, target, targetInst) {
+	  if (topLevelType === 'topFocus') {
+	    // stopWatching() should be a noop here but we call it just in case we
+	    // missed a blur event somehow.
+	    stopWatchingForChangeEventIE8();
+	    startWatchingForChangeEventIE8(target, targetInst);
+	  } else if (topLevelType === 'topBlur') {
+	    stopWatchingForChangeEventIE8();
+	  }
+	}
+
+	/**
+	 * 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.
+	  // IE10+ fire input events to often, such when a placeholder
+	  // changes or when an input with a placeholder is focused.
+	  isInputEventSupported = isEventSupported('input') && (!document.documentMode || document.documentMode > 11);
+	}
+
+	/**
+	 * (For IE <=11) Replacement getter/setter for the `value` property that gets
+	 * set on the active element.
+	 */
+	var newValueProp = {
+	  get: function () {
+	    return activeElementValueProp.get.call(this);
+	  },
+	  set: function (val) {
+	    // Cast to a string so we can do equality checks.
+	    activeElementValue = '' + val;
+	    activeElementValueProp.set.call(this, val);
+	  }
+	};
+
+	/**
+	 * (For IE <=11) Starts tracking propertychange events on the passed-in element
+	 * and override the value property so that we can distinguish user events from
+	 * value changes in JS.
+	 */
+	function startWatchingForValueChange(target, targetInst) {
+	  activeElement = target;
+	  activeElementInst = targetInst;
+	  activeElementValue = target.value;
+	  activeElementValueProp = Object.getOwnPropertyDescriptor(target.constructor.prototype, 'value');
+
+	  // Not guarded in a canDefineProperty check: IE8 supports defineProperty only
+	  // on DOM elements
+	  Object.defineProperty(activeElement, 'value', newValueProp);
+	  if (activeElement.attachEvent) {
+	    activeElement.attachEvent('onpropertychange', handlePropertyChange);
+	  } else {
+	    activeElement.addEventListener('propertychange', handlePropertyChange, false);
+	  }
+	}
+
+	/**
+	 * (For IE <=11) Removes the event listeners from the currently-tracked element,
+	 * if any exists.
+	 */
+	function stopWatchingForValueChange() {
+	  if (!activeElement) {
+	    return;
+	  }
+
+	  // delete restores the original property definition
+	  delete activeElement.value;
+
+	  if (activeElement.detachEvent) {
+	    activeElement.detachEvent('onpropertychange', handlePropertyChange);
+	  } else {
+	    activeElement.removeEventListener('propertychange', handlePropertyChange, false);
+	  }
+
+	  activeElement = null;
+	  activeElementInst = null;
+	  activeElementValue = null;
+	  activeElementValueProp = null;
+	}
+
+	/**
+	 * (For IE <=11) Handles a propertychange event, sending a `change` event if
+	 * the value of the active element has changed.
+	 */
+	function handlePropertyChange(nativeEvent) {
+	  if (nativeEvent.propertyName !== 'value') {
+	    return;
+	  }
+	  var value = nativeEvent.srcElement.value;
+	  if (value === activeElementValue) {
+	    return;
+	  }
+	  activeElementValue = value;
+
+	  manualDispatchChangeEvent(nativeEvent);
+	}
+
+	/**
+	 * If a `change` event should be fired, returns the target's ID.
+	 */
+	function getTargetInstForInputEvent(topLevelType, targetInst) {
+	  if (topLevelType === '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 targetInst;
+	  }
+	}
+
+	function handleEventsForInputEventIE(topLevelType, target, targetInst) {
+	  if (topLevelType === '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-11, 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(target, targetInst);
+	  } else if (topLevelType === 'topBlur') {
+	    stopWatchingForValueChange();
+	  }
+	}
+
+	// For IE8 and IE9.
+	function getTargetInstForInputEventIE(topLevelType, targetInst) {
+	  if (topLevelType === 'topSelectionChange' || topLevelType === 'topKeyUp' || topLevelType === '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 activeElementInst;
+	    }
+	  }
+	}
+
+	/**
+	 * SECTION: handle `click` event
+	 */
+	function shouldUseClickEvent(elem) {
+	  // Use the `click` event to detect changes to checkbox and radio inputs.
+	  // This approach works across all browsers, whereas `change` does not fire
+	  // until `blur` in IE8.
+	  return elem.nodeName && elem.nodeName.toLowerCase() === 'input' && (elem.type === 'checkbox' || elem.type === 'radio');
+	}
+
+	function getTargetInstForClickEvent(topLevelType, targetInst) {
+	  if (topLevelType === 'topClick') {
+	    return targetInst;
+	  }
+	}
+
+	/**
+	 * This plugin creates an `onChange` event that normalizes change events
+	 * across form elements. This event fires at a time when it's possible to
+	 * change the element's value without seeing a flicker.
+	 *
+	 * Supported elements are:
+	 * - input (see `isTextInputElement`)
+	 * - textarea
+	 * - select
+	 */
+	var ChangeEventPlugin = {
+
+	  eventTypes: eventTypes,
+
+	  extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+	    var targetNode = targetInst ? ReactDOMComponentTree.getNodeFromInstance(targetInst) : window;
+
+	    var getTargetInstFunc, handleEventFunc;
+	    if (shouldUseChangeEvent(targetNode)) {
+	      if (doesChangeEventBubble) {
+	        getTargetInstFunc = getTargetInstForChangeEvent;
+	      } else {
+	        handleEventFunc = handleEventsForChangeEventIE8;
+	      }
+	    } else if (isTextInputElement(targetNode)) {
+	      if (isInputEventSupported) {
+	        getTargetInstFunc = getTargetInstForInputEvent;
+	      } else {
+	        getTargetInstFunc = getTargetInstForInputEventIE;
+	        handleEventFunc = handleEventsForInputEventIE;
+	      }
+	    } else if (shouldUseClickEvent(targetNode)) {
+	      getTargetInstFunc = getTargetInstForClickEvent;
+	    }
+
+	    if (getTargetInstFunc) {
+	      var inst = getTargetInstFunc(topLevelType, targetInst);
+	      if (inst) {
+	        var event = SyntheticEvent.getPooled(eventTypes.change, inst, nativeEvent, nativeEventTarget);
+	        event.type = 'change';
+	        EventPropagators.accumulateTwoPhaseDispatches(event);
+	        return event;
+	      }
+	    }
+
+	    if (handleEventFunc) {
+	      handleEventFunc(topLevelType, targetNode, targetInst);
+	    }
+	  }
+
+	};
+
+	module.exports = ChangeEventPlugin;
+
+/***/ },
+/* 60 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35),
+	    _assign = __webpack_require__(53);
+
+	var CallbackQueue = __webpack_require__(61);
+	var PooledClass = __webpack_require__(54);
+	var ReactFeatureFlags = __webpack_require__(62);
+	var ReactReconciler = __webpack_require__(63);
+	var Transaction = __webpack_require__(72);
+
+	var invariant = __webpack_require__(37);
+
+	var dirtyComponents = [];
+	var updateBatchNumber = 0;
+	var asapCallbackQueue = CallbackQueue.getPooled();
+	var asapEnqueued = false;
+
+	var batchingStrategy = null;
+
+	function ensureInjected() {
+	  !(ReactUpdates.ReactReconcileTransaction && batchingStrategy) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must inject a reconcile transaction class and batching strategy') : _prodInvariant('123') : void 0;
+	}
+
+	var NESTED_UPDATES = {
+	  initialize: function () {
+	    this.dirtyComponentsLength = dirtyComponents.length;
+	  },
+	  close: function () {
+	    if (this.dirtyComponentsLength !== dirtyComponents.length) {
+	      // Additional updates were enqueued by componentDidUpdate handlers or
+	      // similar; before our own UPDATE_QUEUEING wrapper closes, we want to run
+	      // these new updates so that if A's componentDidUpdate calls setState on
+	      // B, B will update before the callback A's updater provided when calling
+	      // setState.
+	      dirtyComponents.splice(0, this.dirtyComponentsLength);
+	      flushBatchedUpdates();
+	    } else {
+	      dirtyComponents.length = 0;
+	    }
+	  }
+	};
+
+	var UPDATE_QUEUEING = {
+	  initialize: function () {
+	    this.callbackQueue.reset();
+	  },
+	  close: function () {
+	    this.callbackQueue.notifyAll();
+	  }
+	};
+
+	var TRANSACTION_WRAPPERS = [NESTED_UPDATES, UPDATE_QUEUEING];
+
+	function ReactUpdatesFlushTransaction() {
+	  this.reinitializeTransaction();
+	  this.dirtyComponentsLength = null;
+	  this.callbackQueue = CallbackQueue.getPooled();
+	  this.reconcileTransaction = ReactUpdates.ReactReconcileTransaction.getPooled(
+	  /* useCreateElement */true);
+	}
+
+	_assign(ReactUpdatesFlushTransaction.prototype, Transaction, {
+	  getTransactionWrappers: function () {
+	    return TRANSACTION_WRAPPERS;
+	  },
+
+	  destructor: function () {
+	    this.dirtyComponentsLength = null;
+	    CallbackQueue.release(this.callbackQueue);
+	    this.callbackQueue = null;
+	    ReactUpdates.ReactReconcileTransaction.release(this.reconcileTransaction);
+	    this.reconcileTransaction = null;
+	  },
+
+	  perform: function (method, scope, a) {
+	    // Essentially calls `this.reconcileTransaction.perform(method, scope, a)`
+	    // with this transaction's wrappers around it.
+	    return Transaction.perform.call(this, this.reconcileTransaction.perform, this.reconcileTransaction, method, scope, a);
+	  }
+	});
+
+	PooledClass.addPoolingTo(ReactUpdatesFlushTransaction);
+
+	function batchedUpdates(callback, a, b, c, d, e) {
+	  ensureInjected();
+	  return batchingStrategy.batchedUpdates(callback, a, b, c, d, e);
+	}
+
+	/**
+	 * Array comparator for ReactComponents by mount ordering.
+	 *
+	 * @param {ReactComponent} c1 first component you're comparing
+	 * @param {ReactComponent} c2 second component you're comparing
+	 * @return {number} Return value usable by Array.prototype.sort().
+	 */
+	function mountOrderComparator(c1, c2) {
+	  return c1._mountOrder - c2._mountOrder;
+	}
+
+	function runBatchedUpdates(transaction) {
+	  var len = transaction.dirtyComponentsLength;
+	  !(len === dirtyComponents.length) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected flush transaction\'s stored dirty-components length (%s) to match dirty-components array length (%s).', len, dirtyComponents.length) : _prodInvariant('124', len, dirtyComponents.length) : void 0;
+
+	  // Since reconciling a component higher in the owner hierarchy usually (not
+	  // always -- see shouldComponentUpdate()) will reconcile children, reconcile
+	  // them before their children by sorting the array.
+	  dirtyComponents.sort(mountOrderComparator);
+
+	  // Any updates enqueued while reconciling must be performed after this entire
+	  // batch. Otherwise, if dirtyComponents is [A, B] where A has children B and
+	  // C, B could update twice in a single batch if C's render enqueues an update
+	  // to B (since B would have already updated, we should skip it, and the only
+	  // way we can know to do so is by checking the batch counter).
+	  updateBatchNumber++;
+
+	  for (var i = 0; i < len; i++) {
+	    // If a component is unmounted before pending changes apply, it will still
+	    // be here, but we assume that it has cleared its _pendingCallbacks and
+	    // that performUpdateIfNecessary is a noop.
+	    var component = dirtyComponents[i];
+
+	    // If performUpdateIfNecessary happens to enqueue any new updates, we
+	    // shouldn't execute the callbacks until the next render happens, so
+	    // stash the callbacks first
+	    var callbacks = component._pendingCallbacks;
+	    component._pendingCallbacks = null;
+
+	    var markerName;
+	    if (ReactFeatureFlags.logTopLevelRenders) {
+	      var namedComponent = component;
+	      // Duck type TopLevelWrapper. This is probably always true.
+	      if (component._currentElement.type.isReactTopLevelWrapper) {
+	        namedComponent = component._renderedComponent;
+	      }
+	      markerName = 'React update: ' + namedComponent.getName();
+	      console.time(markerName);
+	    }
+
+	    ReactReconciler.performUpdateIfNecessary(component, transaction.reconcileTransaction, updateBatchNumber);
+
+	    if (markerName) {
+	      console.timeEnd(markerName);
+	    }
+
+	    if (callbacks) {
+	      for (var j = 0; j < callbacks.length; j++) {
+	        transaction.callbackQueue.enqueue(callbacks[j], component.getPublicInstance());
+	      }
+	    }
+	  }
+	}
+
+	var flushBatchedUpdates = function () {
+	  // ReactUpdatesFlushTransaction's wrappers will clear the dirtyComponents
+	  // array and perform any updates enqueued by mount-ready handlers (i.e.,
+	  // componentDidUpdate) but we need to check here too in order to catch
+	  // updates enqueued by setState callbacks and asap calls.
+	  while (dirtyComponents.length || asapEnqueued) {
+	    if (dirtyComponents.length) {
+	      var transaction = ReactUpdatesFlushTransaction.getPooled();
+	      transaction.perform(runBatchedUpdates, null, transaction);
+	      ReactUpdatesFlushTransaction.release(transaction);
+	    }
+
+	    if (asapEnqueued) {
+	      asapEnqueued = false;
+	      var queue = asapCallbackQueue;
+	      asapCallbackQueue = CallbackQueue.getPooled();
+	      queue.notifyAll();
+	      CallbackQueue.release(queue);
+	    }
+	  }
+	};
+
+	/**
+	 * Mark a component as needing a rerender, adding an optional callback to a
+	 * list of functions which will be executed once the rerender occurs.
+	 */
+	function enqueueUpdate(component) {
+	  ensureInjected();
+
+	  // Various parts of our code (such as ReactCompositeComponent's
+	  // _renderValidatedComponent) assume that calls to render aren't nested;
+	  // verify that that's the case. (This is called by each top-level update
+	  // function, like setState, forceUpdate, etc.; creation and
+	  // destruction of top-level components is guarded in ReactMount.)
+
+	  if (!batchingStrategy.isBatchingUpdates) {
+	    batchingStrategy.batchedUpdates(enqueueUpdate, component);
+	    return;
+	  }
+
+	  dirtyComponents.push(component);
+	  if (component._updateBatchNumber == null) {
+	    component._updateBatchNumber = updateBatchNumber + 1;
+	  }
+	}
+
+	/**
+	 * Enqueue a callback to be run at the end of the current batching cycle. Throws
+	 * if no updates are currently being performed.
+	 */
+	function asap(callback, context) {
+	  !batchingStrategy.isBatchingUpdates ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates.asap: Can\'t enqueue an asap callback in a context whereupdates are not being batched.') : _prodInvariant('125') : void 0;
+	  asapCallbackQueue.enqueue(callback, context);
+	  asapEnqueued = true;
+	}
+
+	var ReactUpdatesInjection = {
+	  injectReconcileTransaction: function (ReconcileTransaction) {
+	    !ReconcileTransaction ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide a reconcile transaction class') : _prodInvariant('126') : void 0;
+	    ReactUpdates.ReactReconcileTransaction = ReconcileTransaction;
+	  },
+
+	  injectBatchingStrategy: function (_batchingStrategy) {
+	    !_batchingStrategy ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide a batching strategy') : _prodInvariant('127') : void 0;
+	    !(typeof _batchingStrategy.batchedUpdates === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide a batchedUpdates() function') : _prodInvariant('128') : void 0;
+	    !(typeof _batchingStrategy.isBatchingUpdates === 'boolean') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide an isBatchingUpdates boolean attribute') : _prodInvariant('129') : void 0;
+	    batchingStrategy = _batchingStrategy;
+	  }
+	};
+
+	var ReactUpdates = {
+	  /**
+	   * React references `ReactReconcileTransaction` using this property in order
+	   * to allow dependency injection.
+	   *
+	   * @internal
+	   */
+	  ReactReconcileTransaction: null,
+
+	  batchedUpdates: batchedUpdates,
+	  enqueueUpdate: enqueueUpdate,
+	  flushBatchedUpdates: flushBatchedUpdates,
+	  injection: ReactUpdatesInjection,
+	  asap: asap
+	};
+
+	module.exports = ReactUpdates;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 61 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var PooledClass = __webpack_require__(54);
+
+	var invariant = __webpack_require__(37);
+
+	/**
+	 * A specialized pseudo-event module to help keep track of components waiting to
+	 * be notified when their DOM representations are available for use.
+	 *
+	 * This implements `PooledClass`, so you should never need to instantiate this.
+	 * Instead, use `CallbackQueue.getPooled()`.
+	 *
+	 * @class ReactMountReady
+	 * @implements PooledClass
+	 * @internal
+	 */
+
+	var CallbackQueue = function () {
+	  function CallbackQueue(arg) {
+	    _classCallCheck(this, CallbackQueue);
+
+	    this._callbacks = null;
+	    this._contexts = null;
+	    this._arg = arg;
+	  }
+
+	  /**
+	   * Enqueues a callback to be invoked when `notifyAll` is invoked.
+	   *
+	   * @param {function} callback Invoked when `notifyAll` is invoked.
+	   * @param {?object} context Context to call `callback` with.
+	   * @internal
+	   */
+
+
+	  CallbackQueue.prototype.enqueue = function enqueue(callback, context) {
+	    this._callbacks = this._callbacks || [];
+	    this._callbacks.push(callback);
+	    this._contexts = this._contexts || [];
+	    this._contexts.push(context);
+	  };
+
+	  /**
+	   * Invokes all enqueued callbacks and clears the queue. This is invoked after
+	   * the DOM representation of a component has been created or updated.
+	   *
+	   * @internal
+	   */
+
+
+	  CallbackQueue.prototype.notifyAll = function notifyAll() {
+	    var callbacks = this._callbacks;
+	    var contexts = this._contexts;
+	    var arg = this._arg;
+	    if (callbacks && contexts) {
+	      !(callbacks.length === contexts.length) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Mismatched list of contexts in callback queue') : _prodInvariant('24') : void 0;
+	      this._callbacks = null;
+	      this._contexts = null;
+	      for (var i = 0; i < callbacks.length; i++) {
+	        callbacks[i].call(contexts[i], arg);
+	      }
+	      callbacks.length = 0;
+	      contexts.length = 0;
+	    }
+	  };
+
+	  CallbackQueue.prototype.checkpoint = function checkpoint() {
+	    return this._callbacks ? this._callbacks.length : 0;
+	  };
+
+	  CallbackQueue.prototype.rollback = function rollback(len) {
+	    if (this._callbacks && this._contexts) {
+	      this._callbacks.length = len;
+	      this._contexts.length = len;
+	    }
+	  };
+
+	  /**
+	   * Resets the internal queue.
+	   *
+	   * @internal
+	   */
+
+
+	  CallbackQueue.prototype.reset = function reset() {
+	    this._callbacks = null;
+	    this._contexts = null;
+	  };
+
+	  /**
+	   * `PooledClass` looks for this.
+	   */
+
+
+	  CallbackQueue.prototype.destructor = function destructor() {
+	    this.reset();
+	  };
+
+	  return CallbackQueue;
+	}();
+
+	module.exports = PooledClass.addPoolingTo(CallbackQueue);
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 62 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var ReactFeatureFlags = {
+	  // When true, call console.time() before and .timeEnd() after each top-level
+	  // render (both initial renders and updates). Useful when looking at prod-mode
+	  // timeline profiles in Chrome, for example.
+	  logTopLevelRenders: false
+	};
+
+	module.exports = ReactFeatureFlags;
+
+/***/ },
+/* 63 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ReactRef = __webpack_require__(64);
+	var ReactInstrumentation = __webpack_require__(66);
+
+	var warning = __webpack_require__(47);
+
+	/**
+	 * Helper to call ReactRef.attachRefs with this composite component, split out
+	 * to avoid allocations in the transaction mount-ready queue.
+	 */
+	function attachRefs() {
+	  ReactRef.attachRefs(this, this._currentElement);
+	}
+
+	var ReactReconciler = {
+
+	  /**
+	   * Initializes the component, renders markup, and registers event listeners.
+	   *
+	   * @param {ReactComponent} internalInstance
+	   * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
+	   * @param {?object} the containing host component instance
+	   * @param {?object} info about the host container
+	   * @return {?string} Rendered markup to be inserted into the DOM.
+	   * @final
+	   * @internal
+	   */
+	  mountComponent: function (internalInstance, transaction, hostParent, hostContainerInfo, context, parentDebugID // 0 in production and for roots
+	  ) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      if (internalInstance._debugID !== 0) {
+	        ReactInstrumentation.debugTool.onBeforeMountComponent(internalInstance._debugID, internalInstance._currentElement, parentDebugID);
+	      }
+	    }
+	    var markup = internalInstance.mountComponent(transaction, hostParent, hostContainerInfo, context, parentDebugID);
+	    if (internalInstance._currentElement && internalInstance._currentElement.ref != null) {
+	      transaction.getReactMountReady().enqueue(attachRefs, internalInstance);
+	    }
+	    if (process.env.NODE_ENV !== 'production') {
+	      if (internalInstance._debugID !== 0) {
+	        ReactInstrumentation.debugTool.onMountComponent(internalInstance._debugID);
+	      }
+	    }
+	    return markup;
+	  },
+
+	  /**
+	   * Returns a value that can be passed to
+	   * ReactComponentEnvironment.replaceNodeWithMarkup.
+	   */
+	  getHostNode: function (internalInstance) {
+	    return internalInstance.getHostNode();
+	  },
+
+	  /**
+	   * Releases any resources allocated by `mountComponent`.
+	   *
+	   * @final
+	   * @internal
+	   */
+	  unmountComponent: function (internalInstance, safely) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      if (internalInstance._debugID !== 0) {
+	        ReactInstrumentation.debugTool.onBeforeUnmountComponent(internalInstance._debugID);
+	      }
+	    }
+	    ReactRef.detachRefs(internalInstance, internalInstance._currentElement);
+	    internalInstance.unmountComponent(safely);
+	    if (process.env.NODE_ENV !== 'production') {
+	      if (internalInstance._debugID !== 0) {
+	        ReactInstrumentation.debugTool.onUnmountComponent(internalInstance._debugID);
+	      }
+	    }
+	  },
+
+	  /**
+	   * Update a component using a new element.
+	   *
+	   * @param {ReactComponent} internalInstance
+	   * @param {ReactElement} nextElement
+	   * @param {ReactReconcileTransaction} transaction
+	   * @param {object} context
+	   * @internal
+	   */
+	  receiveComponent: function (internalInstance, nextElement, transaction, context) {
+	    var prevElement = internalInstance._currentElement;
+
+	    if (nextElement === prevElement && context === internalInstance._context) {
+	      // Since elements are immutable after the owner is rendered,
+	      // we can do a cheap identity compare here to determine if this is a
+	      // superfluous reconcile. It's possible for state to be mutable but such
+	      // change should trigger an update of the owner which would recreate
+	      // the element. We explicitly check for the existence of an owner since
+	      // it's possible for an element created outside a composite to be
+	      // deeply mutated and reused.
+
+	      // TODO: Bailing out early is just a perf optimization right?
+	      // TODO: Removing the return statement should affect correctness?
+	      return;
+	    }
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      if (internalInstance._debugID !== 0) {
+	        ReactInstrumentation.debugTool.onBeforeUpdateComponent(internalInstance._debugID, nextElement);
+	      }
+	    }
+
+	    var refsChanged = ReactRef.shouldUpdateRefs(prevElement, nextElement);
+
+	    if (refsChanged) {
+	      ReactRef.detachRefs(internalInstance, prevElement);
+	    }
+
+	    internalInstance.receiveComponent(nextElement, transaction, context);
+
+	    if (refsChanged && internalInstance._currentElement && internalInstance._currentElement.ref != null) {
+	      transaction.getReactMountReady().enqueue(attachRefs, internalInstance);
+	    }
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      if (internalInstance._debugID !== 0) {
+	        ReactInstrumentation.debugTool.onUpdateComponent(internalInstance._debugID);
+	      }
+	    }
+	  },
+
+	  /**
+	   * Flush any dirty changes in a component.
+	   *
+	   * @param {ReactComponent} internalInstance
+	   * @param {ReactReconcileTransaction} transaction
+	   * @internal
+	   */
+	  performUpdateIfNecessary: function (internalInstance, transaction, updateBatchNumber) {
+	    if (internalInstance._updateBatchNumber !== updateBatchNumber) {
+	      // The component's enqueued batch number should always be the current
+	      // batch or the following one.
+	      process.env.NODE_ENV !== 'production' ? warning(internalInstance._updateBatchNumber == null || internalInstance._updateBatchNumber === updateBatchNumber + 1, 'performUpdateIfNecessary: Unexpected batch number (current %s, ' + 'pending %s)', updateBatchNumber, internalInstance._updateBatchNumber) : void 0;
+	      return;
+	    }
+	    if (process.env.NODE_ENV !== 'production') {
+	      if (internalInstance._debugID !== 0) {
+	        ReactInstrumentation.debugTool.onBeforeUpdateComponent(internalInstance._debugID, internalInstance._currentElement);
+	      }
+	    }
+	    internalInstance.performUpdateIfNecessary(transaction);
+	    if (process.env.NODE_ENV !== 'production') {
+	      if (internalInstance._debugID !== 0) {
+	        ReactInstrumentation.debugTool.onUpdateComponent(internalInstance._debugID);
+	      }
+	    }
+	  }
+
+	};
+
+	module.exports = ReactReconciler;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 64 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var ReactOwner = __webpack_require__(65);
+
+	var ReactRef = {};
+
+	function attachRef(ref, component, owner) {
+	  if (typeof ref === 'function') {
+	    ref(component.getPublicInstance());
+	  } else {
+	    // Legacy ref
+	    ReactOwner.addComponentAsRefTo(component, ref, owner);
+	  }
+	}
+
+	function detachRef(ref, component, owner) {
+	  if (typeof ref === 'function') {
+	    ref(null);
+	  } else {
+	    // Legacy ref
+	    ReactOwner.removeComponentAsRefFrom(component, ref, owner);
+	  }
+	}
+
+	ReactRef.attachRefs = function (instance, element) {
+	  if (element === null || typeof element !== 'object') {
+	    return;
+	  }
+	  var ref = element.ref;
+	  if (ref != null) {
+	    attachRef(ref, instance, element._owner);
+	  }
+	};
+
+	ReactRef.shouldUpdateRefs = function (prevElement, nextElement) {
+	  // 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`. We use the element instead
+	  // of the public this.props because the post processing cannot determine
+	  // a ref. The ref conceptually lives on the element.
+
+	  // TODO: Should this even be possible? The owner cannot change because
+	  // it's forbidden by shouldUpdateReactComponent. The ref can change
+	  // if you swap the keys of but not the refs. Reconsider where this check
+	  // is made. It probably belongs where the key checking and
+	  // instantiateReactComponent is done.
+
+	  var prevRef = null;
+	  var prevOwner = null;
+	  if (prevElement !== null && typeof prevElement === 'object') {
+	    prevRef = prevElement.ref;
+	    prevOwner = prevElement._owner;
+	  }
+
+	  var nextRef = null;
+	  var nextOwner = null;
+	  if (nextElement !== null && typeof nextElement === 'object') {
+	    nextRef = nextElement.ref;
+	    nextOwner = nextElement._owner;
+	  }
+
+	  return prevRef !== nextRef ||
+	  // If owner changes but we have an unchanged function ref, don't update refs
+	  typeof nextRef === 'string' && nextOwner !== prevOwner;
+	};
+
+	ReactRef.detachRefs = function (instance, element) {
+	  if (element === null || typeof element !== 'object') {
+	    return;
+	  }
+	  var ref = element.ref;
+	  if (ref != null) {
+	    detachRef(ref, instance, element._owner);
+	  }
+	};
+
+	module.exports = ReactRef;
+
+/***/ },
+/* 65 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var invariant = __webpack_require__(37);
+
+	/**
+	 * @param {?object} object
+	 * @return {boolean} True if `object` is a valid owner.
+	 * @final
+	 */
+	function isValidOwner(object) {
+	  return !!(object && typeof object.attachRef === 'function' && typeof object.detachRef === 'function');
+	}
+
+	/**
+	 * 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: 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 = {
+	  /**
+	   * 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) {
+	    !isValidOwner(owner) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'addComponentAsRefTo(...): Only a ReactOwner can have refs. You might be adding a ref to a component that was not created inside a component\'s `render` method, or you have multiple copies of React loaded (details: https://fb.me/react-refs-must-have-owner).') : _prodInvariant('119') : void 0;
+	    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) {
+	    !isValidOwner(owner) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'removeComponentAsRefFrom(...): Only a ReactOwner can have refs. You might be removing a ref to a component that was not created inside a component\'s `render` method, or you have multiple copies of React loaded (details: https://fb.me/react-refs-must-have-owner).') : _prodInvariant('120') : void 0;
+	    var ownerPublicInstance = owner.getPublicInstance();
+	    // Check that `component`'s owner is still alive and that `component` is still the current ref
+	    // because we do not want to detach the ref if another component stole it.
+	    if (ownerPublicInstance && ownerPublicInstance.refs[ref] === component.getPublicInstance()) {
+	      owner.detachRef(ref);
+	    }
+	  }
+
+	};
+
+	module.exports = ReactOwner;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 66 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2016-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	// Trust the developer to only use ReactInstrumentation with a __DEV__ check
+
+	var debugTool = null;
+
+	if (process.env.NODE_ENV !== 'production') {
+	  var ReactDebugTool = __webpack_require__(67);
+	  debugTool = ReactDebugTool;
+	}
+
+	module.exports = { debugTool: debugTool };
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 67 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2016-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var ReactInvalidSetStateWarningHook = __webpack_require__(68);
+	var ReactHostOperationHistoryHook = __webpack_require__(69);
+	var ReactComponentTreeHook = __webpack_require__(26);
+	var ExecutionEnvironment = __webpack_require__(51);
+
+	var performanceNow = __webpack_require__(70);
+	var warning = __webpack_require__(47);
+
+	var hooks = [];
+	var didHookThrowForEvent = {};
+
+	function callHook(event, fn, context, arg1, arg2, arg3, arg4, arg5) {
+	  try {
+	    fn.call(context, arg1, arg2, arg3, arg4, arg5);
+	  } catch (e) {
+	    process.env.NODE_ENV !== 'production' ? warning(didHookThrowForEvent[event], 'Exception thrown by hook while handling %s: %s', event, e + '\n' + e.stack) : void 0;
+	    didHookThrowForEvent[event] = true;
+	  }
+	}
+
+	function emitEvent(event, arg1, arg2, arg3, arg4, arg5) {
+	  for (var i = 0; i < hooks.length; i++) {
+	    var hook = hooks[i];
+	    var fn = hook[event];
+	    if (fn) {
+	      callHook(event, fn, hook, arg1, arg2, arg3, arg4, arg5);
+	    }
+	  }
+	}
+
+	var isProfiling = false;
+	var flushHistory = [];
+	var lifeCycleTimerStack = [];
+	var currentFlushNesting = 0;
+	var currentFlushMeasurements = [];
+	var currentFlushStartTime = 0;
+	var currentTimerDebugID = null;
+	var currentTimerStartTime = 0;
+	var currentTimerNestedFlushDuration = 0;
+	var currentTimerType = null;
+
+	var lifeCycleTimerHasWarned = false;
+
+	function clearHistory() {
+	  ReactComponentTreeHook.purgeUnmountedComponents();
+	  ReactHostOperationHistoryHook.clearHistory();
+	}
+
+	function getTreeSnapshot(registeredIDs) {
+	  return registeredIDs.reduce(function (tree, id) {
+	    var ownerID = ReactComponentTreeHook.getOwnerID(id);
+	    var parentID = ReactComponentTreeHook.getParentID(id);
+	    tree[id] = {
+	      displayName: ReactComponentTreeHook.getDisplayName(id),
+	      text: ReactComponentTreeHook.getText(id),
+	      updateCount: ReactComponentTreeHook.getUpdateCount(id),
+	      childIDs: ReactComponentTreeHook.getChildIDs(id),
+	      // Text nodes don't have owners but this is close enough.
+	      ownerID: ownerID || parentID && ReactComponentTreeHook.getOwnerID(parentID) || 0,
+	      parentID: parentID
+	    };
+	    return tree;
+	  }, {});
+	}
+
+	function resetMeasurements() {
+	  var previousStartTime = currentFlushStartTime;
+	  var previousMeasurements = currentFlushMeasurements;
+	  var previousOperations = ReactHostOperationHistoryHook.getHistory();
+
+	  if (currentFlushNesting === 0) {
+	    currentFlushStartTime = 0;
+	    currentFlushMeasurements = [];
+	    clearHistory();
+	    return;
+	  }
+
+	  if (previousMeasurements.length || previousOperations.length) {
+	    var registeredIDs = ReactComponentTreeHook.getRegisteredIDs();
+	    flushHistory.push({
+	      duration: performanceNow() - previousStartTime,
+	      measurements: previousMeasurements || [],
+	      operations: previousOperations || [],
+	      treeSnapshot: getTreeSnapshot(registeredIDs)
+	    });
+	  }
+
+	  clearHistory();
+	  currentFlushStartTime = performanceNow();
+	  currentFlushMeasurements = [];
+	}
+
+	function checkDebugID(debugID) {
+	  var allowRoot = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+	  if (allowRoot && debugID === 0) {
+	    return;
+	  }
+	  if (!debugID) {
+	    process.env.NODE_ENV !== 'production' ? warning(false, 'ReactDebugTool: debugID may not be empty.') : void 0;
+	  }
+	}
+
+	function beginLifeCycleTimer(debugID, timerType) {
+	  if (currentFlushNesting === 0) {
+	    return;
+	  }
+	  if (currentTimerType && !lifeCycleTimerHasWarned) {
+	    process.env.NODE_ENV !== 'production' ? warning(false, 'There is an internal error in the React performance measurement code. ' + 'Did not expect %s timer to start while %s timer is still in ' + 'progress for %s instance.', timerType, currentTimerType || 'no', debugID === currentTimerDebugID ? 'the same' : 'another') : void 0;
+	    lifeCycleTimerHasWarned = true;
+	  }
+	  currentTimerStartTime = performanceNow();
+	  currentTimerNestedFlushDuration = 0;
+	  currentTimerDebugID = debugID;
+	  currentTimerType = timerType;
+	}
+
+	function endLifeCycleTimer(debugID, timerType) {
+	  if (currentFlushNesting === 0) {
+	    return;
+	  }
+	  if (currentTimerType !== timerType && !lifeCycleTimerHasWarned) {
+	    process.env.NODE_ENV !== 'production' ? warning(false, 'There is an internal error in the React performance measurement code. ' + 'We did not expect %s timer to stop while %s timer is still in ' + 'progress for %s instance. Please report this as a bug in React.', timerType, currentTimerType || 'no', debugID === currentTimerDebugID ? 'the same' : 'another') : void 0;
+	    lifeCycleTimerHasWarned = true;
+	  }
+	  if (isProfiling) {
+	    currentFlushMeasurements.push({
+	      timerType: timerType,
+	      instanceID: debugID,
+	      duration: performanceNow() - currentTimerStartTime - currentTimerNestedFlushDuration
+	    });
+	  }
+	  currentTimerStartTime = 0;
+	  currentTimerNestedFlushDuration = 0;
+	  currentTimerDebugID = null;
+	  currentTimerType = null;
+	}
+
+	function pauseCurrentLifeCycleTimer() {
+	  var currentTimer = {
+	    startTime: currentTimerStartTime,
+	    nestedFlushStartTime: performanceNow(),
+	    debugID: currentTimerDebugID,
+	    timerType: currentTimerType
+	  };
+	  lifeCycleTimerStack.push(currentTimer);
+	  currentTimerStartTime = 0;
+	  currentTimerNestedFlushDuration = 0;
+	  currentTimerDebugID = null;
+	  currentTimerType = null;
+	}
+
+	function resumeCurrentLifeCycleTimer() {
+	  var _lifeCycleTimerStack$ = lifeCycleTimerStack.pop(),
+	      startTime = _lifeCycleTimerStack$.startTime,
+	      nestedFlushStartTime = _lifeCycleTimerStack$.nestedFlushStartTime,
+	      debugID = _lifeCycleTimerStack$.debugID,
+	      timerType = _lifeCycleTimerStack$.timerType;
+
+	  var nestedFlushDuration = performanceNow() - nestedFlushStartTime;
+	  currentTimerStartTime = startTime;
+	  currentTimerNestedFlushDuration += nestedFlushDuration;
+	  currentTimerDebugID = debugID;
+	  currentTimerType = timerType;
+	}
+
+	var lastMarkTimeStamp = 0;
+	var canUsePerformanceMeasure =
+	// $FlowFixMe https://github.com/facebook/flow/issues/2345
+	typeof performance !== 'undefined' && typeof performance.mark === 'function' && typeof performance.clearMarks === 'function' && typeof performance.measure === 'function' && typeof performance.clearMeasures === 'function';
+
+	function shouldMark(debugID) {
+	  if (!isProfiling || !canUsePerformanceMeasure) {
+	    return false;
+	  }
+	  var element = ReactComponentTreeHook.getElement(debugID);
+	  if (element == null || typeof element !== 'object') {
+	    return false;
+	  }
+	  var isHostElement = typeof element.type === 'string';
+	  if (isHostElement) {
+	    return false;
+	  }
+	  return true;
+	}
+
+	function markBegin(debugID, markType) {
+	  if (!shouldMark(debugID)) {
+	    return;
+	  }
+
+	  var markName = debugID + '::' + markType;
+	  lastMarkTimeStamp = performanceNow();
+	  performance.mark(markName);
+	}
+
+	function markEnd(debugID, markType) {
+	  if (!shouldMark(debugID)) {
+	    return;
+	  }
+
+	  var markName = debugID + '::' + markType;
+	  var displayName = ReactComponentTreeHook.getDisplayName(debugID) || 'Unknown';
+
+	  // Chrome has an issue of dropping markers recorded too fast:
+	  // https://bugs.chromium.org/p/chromium/issues/detail?id=640652
+	  // To work around this, we will not report very small measurements.
+	  // I determined the magic number by tweaking it back and forth.
+	  // 0.05ms was enough to prevent the issue, but I set it to 0.1ms to be safe.
+	  // When the bug is fixed, we can `measure()` unconditionally if we want to.
+	  var timeStamp = performanceNow();
+	  if (timeStamp - lastMarkTimeStamp > 0.1) {
+	    var measurementName = displayName + ' [' + markType + ']';
+	    performance.measure(measurementName, markName);
+	  }
+
+	  performance.clearMarks(markName);
+	  performance.clearMeasures(measurementName);
+	}
+
+	var ReactDebugTool = {
+	  addHook: function (hook) {
+	    hooks.push(hook);
+	  },
+	  removeHook: function (hook) {
+	    for (var i = 0; i < hooks.length; i++) {
+	      if (hooks[i] === hook) {
+	        hooks.splice(i, 1);
+	        i--;
+	      }
+	    }
+	  },
+	  isProfiling: function () {
+	    return isProfiling;
+	  },
+	  beginProfiling: function () {
+	    if (isProfiling) {
+	      return;
+	    }
+
+	    isProfiling = true;
+	    flushHistory.length = 0;
+	    resetMeasurements();
+	    ReactDebugTool.addHook(ReactHostOperationHistoryHook);
+	  },
+	  endProfiling: function () {
+	    if (!isProfiling) {
+	      return;
+	    }
+
+	    isProfiling = false;
+	    resetMeasurements();
+	    ReactDebugTool.removeHook(ReactHostOperationHistoryHook);
+	  },
+	  getFlushHistory: function () {
+	    return flushHistory;
+	  },
+	  onBeginFlush: function () {
+	    currentFlushNesting++;
+	    resetMeasurements();
+	    pauseCurrentLifeCycleTimer();
+	    emitEvent('onBeginFlush');
+	  },
+	  onEndFlush: function () {
+	    resetMeasurements();
+	    currentFlushNesting--;
+	    resumeCurrentLifeCycleTimer();
+	    emitEvent('onEndFlush');
+	  },
+	  onBeginLifeCycleTimer: function (debugID, timerType) {
+	    checkDebugID(debugID);
+	    emitEvent('onBeginLifeCycleTimer', debugID, timerType);
+	    markBegin(debugID, timerType);
+	    beginLifeCycleTimer(debugID, timerType);
+	  },
+	  onEndLifeCycleTimer: function (debugID, timerType) {
+	    checkDebugID(debugID);
+	    endLifeCycleTimer(debugID, timerType);
+	    markEnd(debugID, timerType);
+	    emitEvent('onEndLifeCycleTimer', debugID, timerType);
+	  },
+	  onBeginProcessingChildContext: function () {
+	    emitEvent('onBeginProcessingChildContext');
+	  },
+	  onEndProcessingChildContext: function () {
+	    emitEvent('onEndProcessingChildContext');
+	  },
+	  onHostOperation: function (operation) {
+	    checkDebugID(operation.instanceID);
+	    emitEvent('onHostOperation', operation);
+	  },
+	  onSetState: function () {
+	    emitEvent('onSetState');
+	  },
+	  onSetChildren: function (debugID, childDebugIDs) {
+	    checkDebugID(debugID);
+	    childDebugIDs.forEach(checkDebugID);
+	    emitEvent('onSetChildren', debugID, childDebugIDs);
+	  },
+	  onBeforeMountComponent: function (debugID, element, parentDebugID) {
+	    checkDebugID(debugID);
+	    checkDebugID(parentDebugID, true);
+	    emitEvent('onBeforeMountComponent', debugID, element, parentDebugID);
+	    markBegin(debugID, 'mount');
+	  },
+	  onMountComponent: function (debugID) {
+	    checkDebugID(debugID);
+	    markEnd(debugID, 'mount');
+	    emitEvent('onMountComponent', debugID);
+	  },
+	  onBeforeUpdateComponent: function (debugID, element) {
+	    checkDebugID(debugID);
+	    emitEvent('onBeforeUpdateComponent', debugID, element);
+	    markBegin(debugID, 'update');
+	  },
+	  onUpdateComponent: function (debugID) {
+	    checkDebugID(debugID);
+	    markEnd(debugID, 'update');
+	    emitEvent('onUpdateComponent', debugID);
+	  },
+	  onBeforeUnmountComponent: function (debugID) {
+	    checkDebugID(debugID);
+	    emitEvent('onBeforeUnmountComponent', debugID);
+	    markBegin(debugID, 'unmount');
+	  },
+	  onUnmountComponent: function (debugID) {
+	    checkDebugID(debugID);
+	    markEnd(debugID, 'unmount');
+	    emitEvent('onUnmountComponent', debugID);
+	  },
+	  onTestEvent: function () {
+	    emitEvent('onTestEvent');
+	  }
+	};
+
+	// TODO remove these when RN/www gets updated
+	ReactDebugTool.addDevtool = ReactDebugTool.addHook;
+	ReactDebugTool.removeDevtool = ReactDebugTool.removeHook;
+
+	ReactDebugTool.addHook(ReactInvalidSetStateWarningHook);
+	ReactDebugTool.addHook(ReactComponentTreeHook);
+	var url = ExecutionEnvironment.canUseDOM && window.location.href || '';
+	if (/[?&]react_perf\b/.test(url)) {
+	  ReactDebugTool.beginProfiling();
+	}
+
+	module.exports = ReactDebugTool;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 68 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2016-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var warning = __webpack_require__(47);
+
+	if (process.env.NODE_ENV !== 'production') {
+	  var processingChildContext = false;
+
+	  var warnInvalidSetState = function () {
+	    process.env.NODE_ENV !== 'production' ? warning(!processingChildContext, 'setState(...): Cannot call setState() inside getChildContext()') : void 0;
+	  };
+	}
+
+	var ReactInvalidSetStateWarningHook = {
+	  onBeginProcessingChildContext: function () {
+	    processingChildContext = true;
+	  },
+	  onEndProcessingChildContext: function () {
+	    processingChildContext = false;
+	  },
+	  onSetState: function () {
+	    warnInvalidSetState();
+	  }
+	};
+
+	module.exports = ReactInvalidSetStateWarningHook;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 69 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2016-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var history = [];
+
+	var ReactHostOperationHistoryHook = {
+	  onHostOperation: function (operation) {
+	    history.push(operation);
+	  },
+	  clearHistory: function () {
+	    if (ReactHostOperationHistoryHook._preventClearing) {
+	      // Should only be used for tests.
+	      return;
+	    }
+
+	    history = [];
+	  },
+	  getHistory: function () {
+	    return history;
+	  }
+	};
+
+	module.exports = ReactHostOperationHistoryHook;
+
+/***/ },
+/* 70 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * @typechecks
+	 */
+
+	var performance = __webpack_require__(71);
+
+	var performanceNow;
+
+	/**
+	 * Detect if we can use `window.performance.now()` and gracefully fallback to
+	 * `Date.now()` if it doesn't exist. We need to support Firefox < 15 for now
+	 * because of Facebook's testing infrastructure.
+	 */
+	if (performance.now) {
+	  performanceNow = function performanceNow() {
+	    return performance.now();
+	  };
+	} else {
+	  performanceNow = function performanceNow() {
+	    return Date.now();
+	  };
+	}
+
+	module.exports = performanceNow;
+
+/***/ },
+/* 71 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * @typechecks
+	 */
+
+	'use strict';
+
+	var ExecutionEnvironment = __webpack_require__(51);
+
+	var performance;
+
+	if (ExecutionEnvironment.canUseDOM) {
+	  performance = window.performance || window.msPerformance || window.webkitPerformance;
+	}
+
+	module.exports = performance || {};
+
+/***/ },
+/* 72 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var invariant = __webpack_require__(37);
+
+	var OBSERVED_ERROR = {};
+
+	/**
+	 * `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 run while it is already being run. 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>
+	 *
+	 * 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 `componentDidUpdate` 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 updates.
+	 *
+	 * 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 TransactionImpl = {
+	  /**
+	   * 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.length = 0;
+	    } else {
+	      this.wrapperInitData = [];
+	    }
+	    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. The optional arguments helps prevent the need
+	   * to bind in many cases.
+	   *
+	   * @param {function} method Member of scope to call.
+	   * @param {Object} scope Scope to invoke from.
+	   * @param {Object?=} a Argument to pass to the method.
+	   * @param {Object?=} b Argument to pass to the method.
+	   * @param {Object?=} c Argument to pass to the method.
+	   * @param {Object?=} d Argument to pass to the method.
+	   * @param {Object?=} e Argument to pass to the method.
+	   * @param {Object?=} f Argument to pass to the method.
+	   *
+	   * @return {*} Return value from `method`.
+	   */
+	  perform: function (method, scope, a, b, c, d, e, f) {
+	    !!this.isInTransaction() ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Transaction.perform(...): Cannot initialize a transaction when there is already an outstanding transaction.') : _prodInvariant('27') : void 0;
+	    var errorThrown;
+	    var ret;
+	    try {
+	      this._isInTransaction = true;
+	      // Catching errors makes debugging more difficult, so we start with
+	      // errorThrown set to true before setting it to false after calling
+	      // close -- if it's still set to true in the finally block, it means
+	      // one of these calls threw.
+	      errorThrown = true;
+	      this.initializeAll(0);
+	      ret = method.call(scope, a, b, c, d, e, f);
+	      errorThrown = false;
+	    } finally {
+	      try {
+	        if (errorThrown) {
+	          // If `method` throws, prefer to show that stack trace over any thrown
+	          // by invoking `closeAll`.
+	          try {
+	            this.closeAll(0);
+	          } catch (err) {}
+	        } else {
+	          // Since `method` didn't throw, we don't want to silence the exception
+	          // here.
+	          this.closeAll(0);
+	        }
+	      } finally {
+	        this._isInTransaction = false;
+	      }
+	    }
+	    return ret;
+	  },
+
+	  initializeAll: function (startIndex) {
+	    var transactionWrappers = this.transactionWrappers;
+	    for (var i = startIndex; i < transactionWrappers.length; i++) {
+	      var wrapper = transactionWrappers[i];
+	      try {
+	        // Catching errors makes debugging more difficult, so we start with the
+	        // OBSERVED_ERROR state before overwriting it with the real return value
+	        // of initialize -- if it's still set to OBSERVED_ERROR in the finally
+	        // block, it means wrapper.initialize threw.
+	        this.wrapperInitData[i] = OBSERVED_ERROR;
+	        this.wrapperInitData[i] = wrapper.initialize ? wrapper.initialize.call(this) : null;
+	      } finally {
+	        if (this.wrapperInitData[i] === OBSERVED_ERROR) {
+	          // The initializer for wrapper i threw an error; initialize the
+	          // remaining wrappers but silence any exceptions from them to ensure
+	          // that the first error is the one to bubble up.
+	          try {
+	            this.initializeAll(i + 1);
+	          } catch (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 (startIndex) {
+	    !this.isInTransaction() ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Transaction.closeAll(): Cannot close transaction when none are open.') : _prodInvariant('28') : void 0;
+	    var transactionWrappers = this.transactionWrappers;
+	    for (var i = startIndex; i < transactionWrappers.length; i++) {
+	      var wrapper = transactionWrappers[i];
+	      var initData = this.wrapperInitData[i];
+	      var errorThrown;
+	      try {
+	        // Catching errors makes debugging more difficult, so we start with
+	        // errorThrown set to true before setting it to false after calling
+	        // close -- if it's still set to true in the finally block, it means
+	        // wrapper.close threw.
+	        errorThrown = true;
+	        if (initData !== OBSERVED_ERROR && wrapper.close) {
+	          wrapper.close.call(this, initData);
+	        }
+	        errorThrown = false;
+	      } finally {
+	        if (errorThrown) {
+	          // The closer for wrapper i threw an error; close the remaining
+	          // wrappers but silence any exceptions from them to ensure that the
+	          // first error is the one to bubble up.
+	          try {
+	            this.closeAll(i + 1);
+	          } catch (e) {}
+	        }
+	      }
+	    }
+	    this.wrapperInitData.length = 0;
+	  }
+	};
+
+	module.exports = TransactionImpl;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 73 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	/**
+	 * Gets the target node from a native browser event by accounting for
+	 * inconsistencies in browser DOM APIs.
+	 *
+	 * @param {object} nativeEvent Native browser event.
+	 * @return {DOMEventTarget} Target node.
+	 */
+
+	function getEventTarget(nativeEvent) {
+	  var target = nativeEvent.target || nativeEvent.srcElement || window;
+
+	  // Normalize SVG <use> element events #4963
+	  if (target.correspondingUseElement) {
+	    target = target.correspondingUseElement;
+	  }
+
+	  // Safari may fire events on text nodes (Node.TEXT_NODE is 3).
+	  // @see http://www.quirksmode.org/js/events_properties.html
+	  return target.nodeType === 3 ? target.parentNode : target;
+	}
+
+	module.exports = getEventTarget;
+
+/***/ },
+/* 74 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ExecutionEnvironment = __webpack_require__(51);
+
+	var useHasFeature;
+	if (ExecutionEnvironment.canUseDOM) {
+	  useHasFeature = document.implementation && document.implementation.hasFeature &&
+	  // always returns true in newer browsers as per the standard.
+	  // @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature
+	  document.implementation.hasFeature('', '') !== true;
+	}
+
+	/**
+	 * 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 (!ExecutionEnvironment.canUseDOM || capture && !('addEventListener' in document)) {
+	    return false;
+	  }
+
+	  var eventName = 'on' + eventNameSuffix;
+	  var isSupported = eventName in document;
+
+	  if (!isSupported) {
+	    var element = document.createElement('div');
+	    element.setAttribute(eventName, 'return;');
+	    isSupported = typeof element[eventName] === 'function';
+	  }
+
+	  if (!isSupported && useHasFeature && eventNameSuffix === 'wheel') {
+	    // This is the only way to test support for the `wheel` event in IE9+.
+	    isSupported = document.implementation.hasFeature('Events.wheel', '3.0');
+	  }
+
+	  return isSupported;
+	}
+
+	module.exports = isEventSupported;
+
+/***/ },
+/* 75 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	/**
+	 * @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
+	};
+
+	function isTextInputElement(elem) {
+	  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+
+	  if (nodeName === 'input') {
+	    return !!supportedInputTypes[elem.type];
+	  }
+
+	  if (nodeName === 'textarea') {
+	    return true;
+	  }
+
+	  return false;
+	}
+
+	module.exports = isTextInputElement;
+
+/***/ },
+/* 76 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	/**
+	 * 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 = ['ResponderEventPlugin', 'SimpleEventPlugin', 'TapEventPlugin', 'EnterLeaveEventPlugin', 'ChangeEventPlugin', 'SelectEventPlugin', 'BeforeInputEventPlugin'];
+
+	module.exports = DefaultEventPluginOrder;
+
+/***/ },
+/* 77 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var EventPropagators = __webpack_require__(42);
+	var ReactDOMComponentTree = __webpack_require__(34);
+	var SyntheticMouseEvent = __webpack_require__(78);
+
+	var eventTypes = {
+	  mouseEnter: {
+	    registrationName: 'onMouseEnter',
+	    dependencies: ['topMouseOut', 'topMouseOver']
+	  },
+	  mouseLeave: {
+	    registrationName: 'onMouseLeave',
+	    dependencies: ['topMouseOut', 'topMouseOver']
+	  }
+	};
+
+	var EnterLeaveEventPlugin = {
+
+	  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.
+	   */
+	  extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+	    if (topLevelType === 'topMouseOver' && (nativeEvent.relatedTarget || nativeEvent.fromElement)) {
+	      return null;
+	    }
+	    if (topLevelType !== 'topMouseOut' && topLevelType !== 'topMouseOver') {
+	      // Must not be a mouse in or mouse out - ignoring.
+	      return null;
+	    }
+
+	    var win;
+	    if (nativeEventTarget.window === nativeEventTarget) {
+	      // `nativeEventTarget` is probably a window object.
+	      win = nativeEventTarget;
+	    } else {
+	      // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
+	      var doc = nativeEventTarget.ownerDocument;
+	      if (doc) {
+	        win = doc.defaultView || doc.parentWindow;
+	      } else {
+	        win = window;
+	      }
+	    }
+
+	    var from;
+	    var to;
+	    if (topLevelType === 'topMouseOut') {
+	      from = targetInst;
+	      var related = nativeEvent.relatedTarget || nativeEvent.toElement;
+	      to = related ? ReactDOMComponentTree.getClosestInstanceFromNode(related) : null;
+	    } else {
+	      // Moving to a node from outside the window.
+	      from = null;
+	      to = targetInst;
+	    }
+
+	    if (from === to) {
+	      // Nothing pertains to our managed components.
+	      return null;
+	    }
+
+	    var fromNode = from == null ? win : ReactDOMComponentTree.getNodeFromInstance(from);
+	    var toNode = to == null ? win : ReactDOMComponentTree.getNodeFromInstance(to);
+
+	    var leave = SyntheticMouseEvent.getPooled(eventTypes.mouseLeave, from, nativeEvent, nativeEventTarget);
+	    leave.type = 'mouseleave';
+	    leave.target = fromNode;
+	    leave.relatedTarget = toNode;
+
+	    var enter = SyntheticMouseEvent.getPooled(eventTypes.mouseEnter, to, nativeEvent, nativeEventTarget);
+	    enter.type = 'mouseenter';
+	    enter.target = toNode;
+	    enter.relatedTarget = fromNode;
+
+	    EventPropagators.accumulateEnterLeaveDispatches(leave, enter, from, to);
+
+	    return [leave, enter];
+	  }
+
+	};
+
+	module.exports = EnterLeaveEventPlugin;
+
+/***/ },
+/* 78 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var SyntheticUIEvent = __webpack_require__(79);
+	var ViewportMetrics = __webpack_require__(80);
+
+	var getEventModifierState = __webpack_require__(81);
+
+	/**
+	 * @interface MouseEvent
+	 * @see http://www.w3.org/TR/DOM-Level-3-Events/
+	 */
+	var MouseEventInterface = {
+	  screenX: null,
+	  screenY: null,
+	  clientX: null,
+	  clientY: null,
+	  ctrlKey: null,
+	  shiftKey: null,
+	  altKey: null,
+	  metaKey: null,
+	  getModifierState: getEventModifierState,
+	  button: function (event) {
+	    // Webkit, Firefox, IE9+
+	    // which:  1 2 3
+	    // button: 0 1 2 (standard)
+	    var button = event.button;
+	    if ('which' in event) {
+	      return button;
+	    }
+	    // IE<9
+	    // which:  undefined
+	    // button: 0 0 0
+	    // button: 1 4 2 (onmouseup)
+	    return button === 2 ? 2 : button === 4 ? 1 : 0;
+	  },
+	  buttons: null,
+	  relatedTarget: function (event) {
+	    return event.relatedTarget || (event.fromElement === event.srcElement ? event.toElement : event.fromElement);
+	  },
+	  // "Proprietary" Interface.
+	  pageX: function (event) {
+	    return 'pageX' in event ? event.pageX : event.clientX + ViewportMetrics.currentScrollLeft;
+	  },
+	  pageY: function (event) {
+	    return 'pageY' in event ? event.pageY : event.clientY + ViewportMetrics.currentScrollTop;
+	  }
+	};
+
+	/**
+	 * @param {object} dispatchConfig Configuration used to dispatch this event.
+	 * @param {string} dispatchMarker Marker identifying the event target.
+	 * @param {object} nativeEvent Native browser event.
+	 * @extends {SyntheticUIEvent}
+	 */
+	function SyntheticMouseEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
+	  return SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
+	}
+
+	SyntheticUIEvent.augmentClass(SyntheticMouseEvent, MouseEventInterface);
+
+	module.exports = SyntheticMouseEvent;
+
+/***/ },
+/* 79 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var SyntheticEvent = __webpack_require__(57);
+
+	var getEventTarget = __webpack_require__(73);
+
+	/**
+	 * @interface UIEvent
+	 * @see http://www.w3.org/TR/DOM-Level-3-Events/
+	 */
+	var UIEventInterface = {
+	  view: function (event) {
+	    if (event.view) {
+	      return event.view;
+	    }
+
+	    var target = getEventTarget(event);
+	    if (target.window === target) {
+	      // target is a window object
+	      return target;
+	    }
+
+	    var doc = target.ownerDocument;
+	    // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
+	    if (doc) {
+	      return doc.defaultView || doc.parentWindow;
+	    } else {
+	      return window;
+	    }
+	  },
+	  detail: function (event) {
+	    return event.detail || 0;
+	  }
+	};
+
+	/**
+	 * @param {object} dispatchConfig Configuration used to dispatch this event.
+	 * @param {string} dispatchMarker Marker identifying the event target.
+	 * @param {object} nativeEvent Native browser event.
+	 * @extends {SyntheticEvent}
+	 */
+	function SyntheticUIEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
+	  return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
+	}
+
+	SyntheticEvent.augmentClass(SyntheticUIEvent, UIEventInterface);
+
+	module.exports = SyntheticUIEvent;
+
+/***/ },
+/* 80 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ViewportMetrics = {
+
+	  currentScrollLeft: 0,
+
+	  currentScrollTop: 0,
+
+	  refreshScrollValues: function (scrollPosition) {
+	    ViewportMetrics.currentScrollLeft = scrollPosition.x;
+	    ViewportMetrics.currentScrollTop = scrollPosition.y;
+	  }
+
+	};
+
+	module.exports = ViewportMetrics;
+
+/***/ },
+/* 81 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	/**
+	 * Translation from modifier key to the associated property in the event.
+	 * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
+	 */
+
+	var modifierKeyToProp = {
+	  'Alt': 'altKey',
+	  'Control': 'ctrlKey',
+	  'Meta': 'metaKey',
+	  'Shift': 'shiftKey'
+	};
+
+	// IE8 does not implement getModifierState so we simply map it to the only
+	// modifier keys exposed by the event itself, does not support Lock-keys.
+	// Currently, all major browsers except Chrome seems to support Lock-keys.
+	function modifierStateGetter(keyArg) {
+	  var syntheticEvent = this;
+	  var nativeEvent = syntheticEvent.nativeEvent;
+	  if (nativeEvent.getModifierState) {
+	    return nativeEvent.getModifierState(keyArg);
+	  }
+	  var keyProp = modifierKeyToProp[keyArg];
+	  return keyProp ? !!nativeEvent[keyProp] : false;
+	}
+
+	function getEventModifierState(nativeEvent) {
+	  return modifierStateGetter;
+	}
+
+	module.exports = getEventModifierState;
+
+/***/ },
+/* 82 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var DOMProperty = __webpack_require__(36);
+
+	var MUST_USE_PROPERTY = DOMProperty.injection.MUST_USE_PROPERTY;
+	var HAS_BOOLEAN_VALUE = DOMProperty.injection.HAS_BOOLEAN_VALUE;
+	var HAS_NUMERIC_VALUE = DOMProperty.injection.HAS_NUMERIC_VALUE;
+	var HAS_POSITIVE_NUMERIC_VALUE = DOMProperty.injection.HAS_POSITIVE_NUMERIC_VALUE;
+	var HAS_OVERLOADED_BOOLEAN_VALUE = DOMProperty.injection.HAS_OVERLOADED_BOOLEAN_VALUE;
+
+	var HTMLDOMPropertyConfig = {
+	  isCustomAttribute: RegExp.prototype.test.bind(new RegExp('^(data|aria)-[' + DOMProperty.ATTRIBUTE_NAME_CHAR + ']*$')),
+	  Properties: {
+	    /**
+	     * Standard Properties
+	     */
+	    accept: 0,
+	    acceptCharset: 0,
+	    accessKey: 0,
+	    action: 0,
+	    allowFullScreen: HAS_BOOLEAN_VALUE,
+	    allowTransparency: 0,
+	    alt: 0,
+	    // specifies target context for links with `preload` type
+	    as: 0,
+	    async: HAS_BOOLEAN_VALUE,
+	    autoComplete: 0,
+	    // autoFocus is polyfilled/normalized by AutoFocusUtils
+	    // autoFocus: HAS_BOOLEAN_VALUE,
+	    autoPlay: HAS_BOOLEAN_VALUE,
+	    capture: HAS_BOOLEAN_VALUE,
+	    cellPadding: 0,
+	    cellSpacing: 0,
+	    charSet: 0,
+	    challenge: 0,
+	    checked: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
+	    cite: 0,
+	    classID: 0,
+	    className: 0,
+	    cols: HAS_POSITIVE_NUMERIC_VALUE,
+	    colSpan: 0,
+	    content: 0,
+	    contentEditable: 0,
+	    contextMenu: 0,
+	    controls: HAS_BOOLEAN_VALUE,
+	    coords: 0,
+	    crossOrigin: 0,
+	    data: 0, // For `<object />` acts as `src`.
+	    dateTime: 0,
+	    'default': HAS_BOOLEAN_VALUE,
+	    defer: HAS_BOOLEAN_VALUE,
+	    dir: 0,
+	    disabled: HAS_BOOLEAN_VALUE,
+	    download: HAS_OVERLOADED_BOOLEAN_VALUE,
+	    draggable: 0,
+	    encType: 0,
+	    form: 0,
+	    formAction: 0,
+	    formEncType: 0,
+	    formMethod: 0,
+	    formNoValidate: HAS_BOOLEAN_VALUE,
+	    formTarget: 0,
+	    frameBorder: 0,
+	    headers: 0,
+	    height: 0,
+	    hidden: HAS_BOOLEAN_VALUE,
+	    high: 0,
+	    href: 0,
+	    hrefLang: 0,
+	    htmlFor: 0,
+	    httpEquiv: 0,
+	    icon: 0,
+	    id: 0,
+	    inputMode: 0,
+	    integrity: 0,
+	    is: 0,
+	    keyParams: 0,
+	    keyType: 0,
+	    kind: 0,
+	    label: 0,
+	    lang: 0,
+	    list: 0,
+	    loop: HAS_BOOLEAN_VALUE,
+	    low: 0,
+	    manifest: 0,
+	    marginHeight: 0,
+	    marginWidth: 0,
+	    max: 0,
+	    maxLength: 0,
+	    media: 0,
+	    mediaGroup: 0,
+	    method: 0,
+	    min: 0,
+	    minLength: 0,
+	    // Caution; `option.selected` is not updated if `select.multiple` is
+	    // disabled with `removeAttribute`.
+	    multiple: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
+	    muted: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
+	    name: 0,
+	    nonce: 0,
+	    noValidate: HAS_BOOLEAN_VALUE,
+	    open: HAS_BOOLEAN_VALUE,
+	    optimum: 0,
+	    pattern: 0,
+	    placeholder: 0,
+	    playsInline: HAS_BOOLEAN_VALUE,
+	    poster: 0,
+	    preload: 0,
+	    profile: 0,
+	    radioGroup: 0,
+	    readOnly: HAS_BOOLEAN_VALUE,
+	    referrerPolicy: 0,
+	    rel: 0,
+	    required: HAS_BOOLEAN_VALUE,
+	    reversed: HAS_BOOLEAN_VALUE,
+	    role: 0,
+	    rows: HAS_POSITIVE_NUMERIC_VALUE,
+	    rowSpan: HAS_NUMERIC_VALUE,
+	    sandbox: 0,
+	    scope: 0,
+	    scoped: HAS_BOOLEAN_VALUE,
+	    scrolling: 0,
+	    seamless: HAS_BOOLEAN_VALUE,
+	    selected: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
+	    shape: 0,
+	    size: HAS_POSITIVE_NUMERIC_VALUE,
+	    sizes: 0,
+	    span: HAS_POSITIVE_NUMERIC_VALUE,
+	    spellCheck: 0,
+	    src: 0,
+	    srcDoc: 0,
+	    srcLang: 0,
+	    srcSet: 0,
+	    start: HAS_NUMERIC_VALUE,
+	    step: 0,
+	    style: 0,
+	    summary: 0,
+	    tabIndex: 0,
+	    target: 0,
+	    title: 0,
+	    // Setting .type throws on non-<input> tags
+	    type: 0,
+	    useMap: 0,
+	    value: 0,
+	    width: 0,
+	    wmode: 0,
+	    wrap: 0,
+
+	    /**
+	     * RDFa Properties
+	     */
+	    about: 0,
+	    datatype: 0,
+	    inlist: 0,
+	    prefix: 0,
+	    // property is also supported for OpenGraph in meta tags.
+	    property: 0,
+	    resource: 0,
+	    'typeof': 0,
+	    vocab: 0,
+
+	    /**
+	     * Non-standard Properties
+	     */
+	    // autoCapitalize and autoCorrect are supported in Mobile Safari for
+	    // keyboard hints.
+	    autoCapitalize: 0,
+	    autoCorrect: 0,
+	    // autoSave allows WebKit/Blink to persist values of input fields on page reloads
+	    autoSave: 0,
+	    // color is for Safari mask-icon link
+	    color: 0,
+	    // itemProp, itemScope, itemType are for
+	    // Microdata support. See http://schema.org/docs/gs.html
+	    itemProp: 0,
+	    itemScope: HAS_BOOLEAN_VALUE,
+	    itemType: 0,
+	    // itemID and itemRef are for Microdata support as well but
+	    // only specified in the WHATWG spec document. See
+	    // https://html.spec.whatwg.org/multipage/microdata.html#microdata-dom-api
+	    itemID: 0,
+	    itemRef: 0,
+	    // results show looking glass icon and recent searches on input
+	    // search fields in WebKit/Blink
+	    results: 0,
+	    // IE-only attribute that specifies security restrictions on an iframe
+	    // as an alternative to the sandbox attribute on IE<10
+	    security: 0,
+	    // IE-only attribute that controls focus behavior
+	    unselectable: 0
+	  },
+	  DOMAttributeNames: {
+	    acceptCharset: 'accept-charset',
+	    className: 'class',
+	    htmlFor: 'for',
+	    httpEquiv: 'http-equiv'
+	  },
+	  DOMPropertyNames: {}
+	};
+
+	module.exports = HTMLDOMPropertyConfig;
+
+/***/ },
+/* 83 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var DOMChildrenOperations = __webpack_require__(84);
+	var ReactDOMIDOperations = __webpack_require__(95);
+
+	/**
+	 * Abstracts away all functionality of the reconciler that requires knowledge of
+	 * the browser context. TODO: These callers should be refactored to avoid the
+	 * need for this injection.
+	 */
+	var ReactComponentBrowserEnvironment = {
+
+	  processChildrenUpdates: ReactDOMIDOperations.dangerouslyProcessChildrenUpdates,
+
+	  replaceNodeWithMarkup: DOMChildrenOperations.dangerouslyReplaceNodeWithMarkup
+
+	};
+
+	module.exports = ReactComponentBrowserEnvironment;
+
+/***/ },
+/* 84 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var DOMLazyTree = __webpack_require__(85);
+	var Danger = __webpack_require__(91);
+	var ReactDOMComponentTree = __webpack_require__(34);
+	var ReactInstrumentation = __webpack_require__(66);
+
+	var createMicrosoftUnsafeLocalFunction = __webpack_require__(88);
+	var setInnerHTML = __webpack_require__(87);
+	var setTextContent = __webpack_require__(89);
+
+	function getNodeAfter(parentNode, node) {
+	  // Special case for text components, which return [open, close] comments
+	  // from getHostNode.
+	  if (Array.isArray(node)) {
+	    node = node[1];
+	  }
+	  return node ? node.nextSibling : parentNode.firstChild;
+	}
+
+	/**
+	 * Inserts `childNode` as a child of `parentNode` at the `index`.
+	 *
+	 * @param {DOMElement} parentNode Parent node in which to insert.
+	 * @param {DOMElement} childNode Child node to insert.
+	 * @param {number} index Index at which to insert the child.
+	 * @internal
+	 */
+	var insertChildAt = createMicrosoftUnsafeLocalFunction(function (parentNode, childNode, referenceNode) {
+	  // We rely exclusively on `insertBefore(node, null)` instead of also using
+	  // `appendChild(node)`. (Using `undefined` is not allowed by all browsers so
+	  // we are careful to use `null`.)
+	  parentNode.insertBefore(childNode, referenceNode);
+	});
+
+	function insertLazyTreeChildAt(parentNode, childTree, referenceNode) {
+	  DOMLazyTree.insertTreeBefore(parentNode, childTree, referenceNode);
+	}
+
+	function moveChild(parentNode, childNode, referenceNode) {
+	  if (Array.isArray(childNode)) {
+	    moveDelimitedText(parentNode, childNode[0], childNode[1], referenceNode);
+	  } else {
+	    insertChildAt(parentNode, childNode, referenceNode);
+	  }
+	}
+
+	function removeChild(parentNode, childNode) {
+	  if (Array.isArray(childNode)) {
+	    var closingComment = childNode[1];
+	    childNode = childNode[0];
+	    removeDelimitedText(parentNode, childNode, closingComment);
+	    parentNode.removeChild(closingComment);
+	  }
+	  parentNode.removeChild(childNode);
+	}
+
+	function moveDelimitedText(parentNode, openingComment, closingComment, referenceNode) {
+	  var node = openingComment;
+	  while (true) {
+	    var nextNode = node.nextSibling;
+	    insertChildAt(parentNode, node, referenceNode);
+	    if (node === closingComment) {
+	      break;
+	    }
+	    node = nextNode;
+	  }
+	}
+
+	function removeDelimitedText(parentNode, startNode, closingComment) {
+	  while (true) {
+	    var node = startNode.nextSibling;
+	    if (node === closingComment) {
+	      // The closing comment is removed by ReactMultiChild.
+	      break;
+	    } else {
+	      parentNode.removeChild(node);
+	    }
+	  }
+	}
+
+	function replaceDelimitedText(openingComment, closingComment, stringText) {
+	  var parentNode = openingComment.parentNode;
+	  var nodeAfterComment = openingComment.nextSibling;
+	  if (nodeAfterComment === closingComment) {
+	    // There are no text nodes between the opening and closing comments; insert
+	    // a new one if stringText isn't empty.
+	    if (stringText) {
+	      insertChildAt(parentNode, document.createTextNode(stringText), nodeAfterComment);
+	    }
+	  } else {
+	    if (stringText) {
+	      // Set the text content of the first node after the opening comment, and
+	      // remove all following nodes up until the closing comment.
+	      setTextContent(nodeAfterComment, stringText);
+	      removeDelimitedText(parentNode, nodeAfterComment, closingComment);
+	    } else {
+	      removeDelimitedText(parentNode, openingComment, closingComment);
+	    }
+	  }
+
+	  if (process.env.NODE_ENV !== 'production') {
+	    ReactInstrumentation.debugTool.onHostOperation({
+	      instanceID: ReactDOMComponentTree.getInstanceFromNode(openingComment)._debugID,
+	      type: 'replace text',
+	      payload: stringText
+	    });
+	  }
+	}
+
+	var dangerouslyReplaceNodeWithMarkup = Danger.dangerouslyReplaceNodeWithMarkup;
+	if (process.env.NODE_ENV !== 'production') {
+	  dangerouslyReplaceNodeWithMarkup = function (oldChild, markup, prevInstance) {
+	    Danger.dangerouslyReplaceNodeWithMarkup(oldChild, markup);
+	    if (prevInstance._debugID !== 0) {
+	      ReactInstrumentation.debugTool.onHostOperation({
+	        instanceID: prevInstance._debugID,
+	        type: 'replace with',
+	        payload: markup.toString()
+	      });
+	    } else {
+	      var nextInstance = ReactDOMComponentTree.getInstanceFromNode(markup.node);
+	      if (nextInstance._debugID !== 0) {
+	        ReactInstrumentation.debugTool.onHostOperation({
+	          instanceID: nextInstance._debugID,
+	          type: 'mount',
+	          payload: markup.toString()
+	        });
+	      }
+	    }
+	  };
+	}
+
+	/**
+	 * Operations for updating with DOM children.
+	 */
+	var DOMChildrenOperations = {
+
+	  dangerouslyReplaceNodeWithMarkup: dangerouslyReplaceNodeWithMarkup,
+
+	  replaceDelimitedText: replaceDelimitedText,
+
+	  /**
+	   * Updates a component's children by processing a series of updates. The
+	   * update configurations are each expected to have a `parentNode` property.
+	   *
+	   * @param {array<object>} updates List of update configurations.
+	   * @internal
+	   */
+	  processUpdates: function (parentNode, updates) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      var parentNodeDebugID = ReactDOMComponentTree.getInstanceFromNode(parentNode)._debugID;
+	    }
+
+	    for (var k = 0; k < updates.length; k++) {
+	      var update = updates[k];
+	      switch (update.type) {
+	        case 'INSERT_MARKUP':
+	          insertLazyTreeChildAt(parentNode, update.content, getNodeAfter(parentNode, update.afterNode));
+	          if (process.env.NODE_ENV !== 'production') {
+	            ReactInstrumentation.debugTool.onHostOperation({
+	              instanceID: parentNodeDebugID,
+	              type: 'insert child',
+	              payload: { toIndex: update.toIndex, content: update.content.toString() }
+	            });
+	          }
+	          break;
+	        case 'MOVE_EXISTING':
+	          moveChild(parentNode, update.fromNode, getNodeAfter(parentNode, update.afterNode));
+	          if (process.env.NODE_ENV !== 'production') {
+	            ReactInstrumentation.debugTool.onHostOperation({
+	              instanceID: parentNodeDebugID,
+	              type: 'move child',
+	              payload: { fromIndex: update.fromIndex, toIndex: update.toIndex }
+	            });
+	          }
+	          break;
+	        case 'SET_MARKUP':
+	          setInnerHTML(parentNode, update.content);
+	          if (process.env.NODE_ENV !== 'production') {
+	            ReactInstrumentation.debugTool.onHostOperation({
+	              instanceID: parentNodeDebugID,
+	              type: 'replace children',
+	              payload: update.content.toString()
+	            });
+	          }
+	          break;
+	        case 'TEXT_CONTENT':
+	          setTextContent(parentNode, update.content);
+	          if (process.env.NODE_ENV !== 'production') {
+	            ReactInstrumentation.debugTool.onHostOperation({
+	              instanceID: parentNodeDebugID,
+	              type: 'replace text',
+	              payload: update.content.toString()
+	            });
+	          }
+	          break;
+	        case 'REMOVE_NODE':
+	          removeChild(parentNode, update.fromNode);
+	          if (process.env.NODE_ENV !== 'production') {
+	            ReactInstrumentation.debugTool.onHostOperation({
+	              instanceID: parentNodeDebugID,
+	              type: 'remove child',
+	              payload: { fromIndex: update.fromIndex }
+	            });
+	          }
+	          break;
+	      }
+	    }
+	  }
+
+	};
+
+	module.exports = DOMChildrenOperations;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 85 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2015-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var DOMNamespaces = __webpack_require__(86);
+	var setInnerHTML = __webpack_require__(87);
+
+	var createMicrosoftUnsafeLocalFunction = __webpack_require__(88);
+	var setTextContent = __webpack_require__(89);
+
+	var ELEMENT_NODE_TYPE = 1;
+	var DOCUMENT_FRAGMENT_NODE_TYPE = 11;
+
+	/**
+	 * In IE (8-11) and Edge, appending nodes with no children is dramatically
+	 * faster than appending a full subtree, so we essentially queue up the
+	 * .appendChild calls here and apply them so each node is added to its parent
+	 * before any children are added.
+	 *
+	 * In other browsers, doing so is slower or neutral compared to the other order
+	 * (in Firefox, twice as slow) so we only do this inversion in IE.
+	 *
+	 * See https://github.com/spicyj/innerhtml-vs-createelement-vs-clonenode.
+	 */
+	var enableLazy = typeof document !== 'undefined' && typeof document.documentMode === 'number' || typeof navigator !== 'undefined' && typeof navigator.userAgent === 'string' && /\bEdge\/\d/.test(navigator.userAgent);
+
+	function insertTreeChildren(tree) {
+	  if (!enableLazy) {
+	    return;
+	  }
+	  var node = tree.node;
+	  var children = tree.children;
+	  if (children.length) {
+	    for (var i = 0; i < children.length; i++) {
+	      insertTreeBefore(node, children[i], null);
+	    }
+	  } else if (tree.html != null) {
+	    setInnerHTML(node, tree.html);
+	  } else if (tree.text != null) {
+	    setTextContent(node, tree.text);
+	  }
+	}
+
+	var insertTreeBefore = createMicrosoftUnsafeLocalFunction(function (parentNode, tree, referenceNode) {
+	  // DocumentFragments aren't actually part of the DOM after insertion so
+	  // appending children won't update the DOM. We need to ensure the fragment
+	  // is properly populated first, breaking out of our lazy approach for just
+	  // this level. Also, some <object> plugins (like Flash Player) will read
+	  // <param> nodes immediately upon insertion into the DOM, so <object>
+	  // must also be populated prior to insertion into the DOM.
+	  if (tree.node.nodeType === DOCUMENT_FRAGMENT_NODE_TYPE || tree.node.nodeType === ELEMENT_NODE_TYPE && tree.node.nodeName.toLowerCase() === 'object' && (tree.node.namespaceURI == null || tree.node.namespaceURI === DOMNamespaces.html)) {
+	    insertTreeChildren(tree);
+	    parentNode.insertBefore(tree.node, referenceNode);
+	  } else {
+	    parentNode.insertBefore(tree.node, referenceNode);
+	    insertTreeChildren(tree);
+	  }
+	});
+
+	function replaceChildWithTree(oldNode, newTree) {
+	  oldNode.parentNode.replaceChild(newTree.node, oldNode);
+	  insertTreeChildren(newTree);
+	}
+
+	function queueChild(parentTree, childTree) {
+	  if (enableLazy) {
+	    parentTree.children.push(childTree);
+	  } else {
+	    parentTree.node.appendChild(childTree.node);
+	  }
+	}
+
+	function queueHTML(tree, html) {
+	  if (enableLazy) {
+	    tree.html = html;
+	  } else {
+	    setInnerHTML(tree.node, html);
+	  }
+	}
+
+	function queueText(tree, text) {
+	  if (enableLazy) {
+	    tree.text = text;
+	  } else {
+	    setTextContent(tree.node, text);
+	  }
+	}
+
+	function toString() {
+	  return this.node.nodeName;
+	}
+
+	function DOMLazyTree(node) {
+	  return {
+	    node: node,
+	    children: [],
+	    html: null,
+	    text: null,
+	    toString: toString
+	  };
+	}
+
+	DOMLazyTree.insertTreeBefore = insertTreeBefore;
+	DOMLazyTree.replaceChildWithTree = replaceChildWithTree;
+	DOMLazyTree.queueChild = queueChild;
+	DOMLazyTree.queueHTML = queueHTML;
+	DOMLazyTree.queueText = queueText;
+
+	module.exports = DOMLazyTree;
+
+/***/ },
+/* 86 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var DOMNamespaces = {
+	  html: 'http://www.w3.org/1999/xhtml',
+	  mathml: 'http://www.w3.org/1998/Math/MathML',
+	  svg: 'http://www.w3.org/2000/svg'
+	};
+
+	module.exports = DOMNamespaces;
+
+/***/ },
+/* 87 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ExecutionEnvironment = __webpack_require__(51);
+	var DOMNamespaces = __webpack_require__(86);
+
+	var WHITESPACE_TEST = /^[ \r\n\t\f]/;
+	var NONVISIBLE_TEST = /<(!--|link|noscript|meta|script|style)[ \r\n\t\f\/>]/;
+
+	var createMicrosoftUnsafeLocalFunction = __webpack_require__(88);
+
+	// SVG temp container for IE lacking innerHTML
+	var reusableSVGContainer;
+
+	/**
+	 * Set the innerHTML property of a node, ensuring that whitespace is preserved
+	 * even in IE8.
+	 *
+	 * @param {DOMElement} node
+	 * @param {string} html
+	 * @internal
+	 */
+	var setInnerHTML = createMicrosoftUnsafeLocalFunction(function (node, html) {
+	  // IE does not have innerHTML for SVG nodes, so instead we inject the
+	  // new markup in a temp node and then move the child nodes across into
+	  // the target node
+	  if (node.namespaceURI === DOMNamespaces.svg && !('innerHTML' in node)) {
+	    reusableSVGContainer = reusableSVGContainer || document.createElement('div');
+	    reusableSVGContainer.innerHTML = '<svg>' + html + '</svg>';
+	    var svgNode = reusableSVGContainer.firstChild;
+	    while (svgNode.firstChild) {
+	      node.appendChild(svgNode.firstChild);
+	    }
+	  } else {
+	    node.innerHTML = html;
+	  }
+	});
+
+	if (ExecutionEnvironment.canUseDOM) {
+	  // IE8: When updating a just created node with innerHTML only leading
+	  // whitespace is removed. When updating an existing node with innerHTML
+	  // whitespace in root TextNodes is also collapsed.
+	  // @see quirksmode.org/bugreports/archives/2004/11/innerhtml_and_t.html
+
+	  // Feature detection; only IE8 is known to behave improperly like this.
+	  var testElement = document.createElement('div');
+	  testElement.innerHTML = ' ';
+	  if (testElement.innerHTML === '') {
+	    setInnerHTML = function (node, html) {
+	      // Magic theory: IE8 supposedly differentiates between added and updated
+	      // nodes when processing innerHTML, innerHTML on updated nodes suffers
+	      // from worse whitespace behavior. Re-adding a node like this triggers
+	      // the initial and more favorable whitespace behavior.
+	      // TODO: What to do on a detached node?
+	      if (node.parentNode) {
+	        node.parentNode.replaceChild(node, node);
+	      }
+
+	      // We also implement a workaround for non-visible tags disappearing into
+	      // thin air on IE8, this only happens if there is no visible text
+	      // in-front of the non-visible tags. Piggyback on the whitespace fix
+	      // and simply check if any non-visible tags appear in the source.
+	      if (WHITESPACE_TEST.test(html) || html[0] === '<' && NONVISIBLE_TEST.test(html)) {
+	        // Recover leading whitespace by temporarily prepending any character.
+	        // \uFEFF has the potential advantage of being zero-width/invisible.
+	        // UglifyJS drops U+FEFF chars when parsing, so use String.fromCharCode
+	        // in hopes that this is preserved even if "\uFEFF" is transformed to
+	        // the actual Unicode character (by Babel, for example).
+	        // https://github.com/mishoo/UglifyJS2/blob/v2.4.20/lib/parse.js#L216
+	        node.innerHTML = String.fromCharCode(0xFEFF) + html;
+
+	        // deleteData leaves an empty `TextNode` which offsets the index of all
+	        // children. Definitely want to avoid this.
+	        var textNode = node.firstChild;
+	        if (textNode.data.length === 1) {
+	          node.removeChild(textNode);
+	        } else {
+	          textNode.deleteData(0, 1);
+	        }
+	      } else {
+	        node.innerHTML = html;
+	      }
+	    };
+	  }
+	  testElement = null;
+	}
+
+	module.exports = setInnerHTML;
+
+/***/ },
+/* 88 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	/* globals MSApp */
+
+	'use strict';
+
+	/**
+	 * Create a function which has 'unsafe' privileges (required by windows8 apps)
+	 */
+
+	var createMicrosoftUnsafeLocalFunction = function (func) {
+	  if (typeof MSApp !== 'undefined' && MSApp.execUnsafeLocalFunction) {
+	    return function (arg0, arg1, arg2, arg3) {
+	      MSApp.execUnsafeLocalFunction(function () {
+	        return func(arg0, arg1, arg2, arg3);
+	      });
+	    };
+	  } else {
+	    return func;
+	  }
+	};
+
+	module.exports = createMicrosoftUnsafeLocalFunction;
+
+/***/ },
+/* 89 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ExecutionEnvironment = __webpack_require__(51);
+	var escapeTextContentForBrowser = __webpack_require__(90);
+	var setInnerHTML = __webpack_require__(87);
+
+	/**
+	 * Set the textContent property of a node, ensuring that whitespace is preserved
+	 * even in IE8. innerText is a poor substitute for textContent and, among many
+	 * issues, inserts <br> instead of the literal newline chars. innerHTML behaves
+	 * as it should.
+	 *
+	 * @param {DOMElement} node
+	 * @param {string} text
+	 * @internal
+	 */
+	var setTextContent = function (node, text) {
+	  if (text) {
+	    var firstChild = node.firstChild;
+
+	    if (firstChild && firstChild === node.lastChild && firstChild.nodeType === 3) {
+	      firstChild.nodeValue = text;
+	      return;
+	    }
+	  }
+	  node.textContent = text;
+	};
+
+	if (ExecutionEnvironment.canUseDOM) {
+	  if (!('textContent' in document.documentElement)) {
+	    setTextContent = function (node, text) {
+	      if (node.nodeType === 3) {
+	        node.nodeValue = text;
+	        return;
+	      }
+	      setInnerHTML(node, escapeTextContentForBrowser(text));
+	    };
+	  }
+	}
+
+	module.exports = setTextContent;
+
+/***/ },
+/* 90 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2016-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * Based on the escape-html library, which is used under the MIT License below:
+	 *
+	 * Copyright (c) 2012-2013 TJ Holowaychuk
+	 * Copyright (c) 2015 Andreas Lubbe
+	 * Copyright (c) 2015 Tiancheng "Timothy" Gu
+	 *
+	 * Permission is hereby granted, free of charge, to any person obtaining
+	 * a copy of this software and associated documentation files (the
+	 * 'Software'), to deal in the Software without restriction, including
+	 * without limitation the rights to use, copy, modify, merge, publish,
+	 * distribute, sublicense, and/or sell copies of the Software, and to
+	 * permit persons to whom the Software is furnished to do so, subject to
+	 * the following conditions:
+	 *
+	 * The above copyright notice and this permission notice shall be
+	 * included in all copies or substantial portions of the Software.
+	 *
+	 * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+	 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+	 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+	 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+	 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+	 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+	 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+	 *
+	 */
+
+	'use strict';
+
+	// code copied and modified from escape-html
+	/**
+	 * Module variables.
+	 * @private
+	 */
+
+	var matchHtmlRegExp = /["'&<>]/;
+
+	/**
+	 * Escape special characters in the given string of html.
+	 *
+	 * @param  {string} string The string to escape for inserting into HTML
+	 * @return {string}
+	 * @public
+	 */
+
+	function escapeHtml(string) {
+	  var str = '' + string;
+	  var match = matchHtmlRegExp.exec(str);
+
+	  if (!match) {
+	    return str;
+	  }
+
+	  var escape;
+	  var html = '';
+	  var index = 0;
+	  var lastIndex = 0;
+
+	  for (index = match.index; index < str.length; index++) {
+	    switch (str.charCodeAt(index)) {
+	      case 34:
+	        // "
+	        escape = '&quot;';
+	        break;
+	      case 38:
+	        // &
+	        escape = '&amp;';
+	        break;
+	      case 39:
+	        // '
+	        escape = '&#x27;'; // modified from escape-html; used to be '&#39'
+	        break;
+	      case 60:
+	        // <
+	        escape = '&lt;';
+	        break;
+	      case 62:
+	        // >
+	        escape = '&gt;';
+	        break;
+	      default:
+	        continue;
+	    }
+
+	    if (lastIndex !== index) {
+	      html += str.substring(lastIndex, index);
+	    }
+
+	    lastIndex = index + 1;
+	    html += escape;
+	  }
+
+	  return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
+	}
+	// end code copied and modified from escape-html
+
+
+	/**
+	 * Escapes text to prevent scripting attacks.
+	 *
+	 * @param {*} text Text value to escape.
+	 * @return {string} An escaped string.
+	 */
+	function escapeTextContentForBrowser(text) {
+	  if (typeof text === 'boolean' || typeof text === 'number') {
+	    // this shortcircuit helps perf for types that we know will never have
+	    // special characters, especially given that this function is used often
+	    // for numeric dom ids.
+	    return '' + text;
+	  }
+	  return escapeHtml(text);
+	}
+
+	module.exports = escapeTextContentForBrowser;
+
+/***/ },
+/* 91 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var DOMLazyTree = __webpack_require__(85);
+	var ExecutionEnvironment = __webpack_require__(51);
+
+	var createNodesFromMarkup = __webpack_require__(92);
+	var emptyFunction = __webpack_require__(48);
+	var invariant = __webpack_require__(37);
+
+	var Danger = {
+
+	  /**
+	   * Replaces a node with a string of markup at its current position within its
+	   * parent. The markup must render into a single root node.
+	   *
+	   * @param {DOMElement} oldChild Child node to replace.
+	   * @param {string} markup Markup to render in place of the child node.
+	   * @internal
+	   */
+	  dangerouslyReplaceNodeWithMarkup: function (oldChild, markup) {
+	    !ExecutionEnvironment.canUseDOM ? process.env.NODE_ENV !== 'production' ? invariant(false, 'dangerouslyReplaceNodeWithMarkup(...): Cannot render markup in a worker thread. Make sure `window` and `document` are available globally before requiring React when unit testing or use ReactDOMServer.renderToString() for server rendering.') : _prodInvariant('56') : void 0;
+	    !markup ? process.env.NODE_ENV !== 'production' ? invariant(false, 'dangerouslyReplaceNodeWithMarkup(...): Missing markup.') : _prodInvariant('57') : void 0;
+	    !(oldChild.nodeName !== 'HTML') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'dangerouslyReplaceNodeWithMarkup(...): Cannot replace markup of the <html> node. This is because browser quirks make this unreliable and/or slow. If you want to render to the root you must use server rendering. See ReactDOMServer.renderToString().') : _prodInvariant('58') : void 0;
+
+	    if (typeof markup === 'string') {
+	      var newChild = createNodesFromMarkup(markup, emptyFunction)[0];
+	      oldChild.parentNode.replaceChild(newChild, oldChild);
+	    } else {
+	      DOMLazyTree.replaceChildWithTree(oldChild, markup);
+	    }
+	  }
+
+	};
+
+	module.exports = Danger;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 92 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * @typechecks
+	 */
+
+	/*eslint-disable fb-www/unsafe-html*/
+
+	var ExecutionEnvironment = __webpack_require__(51);
+
+	var createArrayFromMixed = __webpack_require__(93);
+	var getMarkupWrap = __webpack_require__(94);
+	var invariant = __webpack_require__(37);
+
+	/**
+	 * Dummy container used to render all markup.
+	 */
+	var dummyNode = ExecutionEnvironment.canUseDOM ? document.createElement('div') : null;
+
+	/**
+	 * Pattern used by `getNodeName`.
+	 */
+	var nodeNamePattern = /^\s*<(\w+)/;
+
+	/**
+	 * Extracts the `nodeName` of the first element in a string of markup.
+	 *
+	 * @param {string} markup String of markup.
+	 * @return {?string} Node name of the supplied markup.
+	 */
+	function getNodeName(markup) {
+	  var nodeNameMatch = markup.match(nodeNamePattern);
+	  return nodeNameMatch && nodeNameMatch[1].toLowerCase();
+	}
+
+	/**
+	 * Creates an array containing the nodes rendered from the supplied markup. The
+	 * optionally supplied `handleScript` function will be invoked once for each
+	 * <script> element that is rendered. If no `handleScript` function is supplied,
+	 * an exception is thrown if any <script> elements are rendered.
+	 *
+	 * @param {string} markup A string of valid HTML markup.
+	 * @param {?function} handleScript Invoked once for each rendered <script>.
+	 * @return {array<DOMElement|DOMTextNode>} An array of rendered nodes.
+	 */
+	function createNodesFromMarkup(markup, handleScript) {
+	  var node = dummyNode;
+	  !!!dummyNode ? process.env.NODE_ENV !== 'production' ? invariant(false, 'createNodesFromMarkup dummy not initialized') : invariant(false) : void 0;
+	  var nodeName = getNodeName(markup);
+
+	  var wrap = nodeName && getMarkupWrap(nodeName);
+	  if (wrap) {
+	    node.innerHTML = wrap[1] + markup + wrap[2];
+
+	    var wrapDepth = wrap[0];
+	    while (wrapDepth--) {
+	      node = node.lastChild;
+	    }
+	  } else {
+	    node.innerHTML = markup;
+	  }
+
+	  var scripts = node.getElementsByTagName('script');
+	  if (scripts.length) {
+	    !handleScript ? process.env.NODE_ENV !== 'production' ? invariant(false, 'createNodesFromMarkup(...): Unexpected <script> element rendered.') : invariant(false) : void 0;
+	    createArrayFromMixed(scripts).forEach(handleScript);
+	  }
+
+	  var nodes = Array.from(node.childNodes);
+	  while (node.lastChild) {
+	    node.removeChild(node.lastChild);
+	  }
+	  return nodes;
+	}
+
+	module.exports = createNodesFromMarkup;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 93 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * @typechecks
+	 */
+
+	var invariant = __webpack_require__(37);
+
+	/**
+	 * Convert array-like objects to arrays.
+	 *
+	 * This API assumes the caller knows the contents of the data type. For less
+	 * well defined inputs use createArrayFromMixed.
+	 *
+	 * @param {object|function|filelist} obj
+	 * @return {array}
+	 */
+	function toArray(obj) {
+	  var length = obj.length;
+
+	  // Some browsers builtin objects can report typeof 'function' (e.g. NodeList
+	  // in old versions of Safari).
+	  !(!Array.isArray(obj) && (typeof obj === 'object' || typeof obj === 'function')) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Array-like object expected') : invariant(false) : void 0;
+
+	  !(typeof length === 'number') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object needs a length property') : invariant(false) : void 0;
+
+	  !(length === 0 || length - 1 in obj) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object should have keys for indices') : invariant(false) : void 0;
+
+	  !(typeof obj.callee !== 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object can\'t be `arguments`. Use rest params ' + '(function(...args) {}) or Array.from() instead.') : invariant(false) : void 0;
+
+	  // Old IE doesn't give collections access to hasOwnProperty. Assume inputs
+	  // without method will throw during the slice call and skip straight to the
+	  // fallback.
+	  if (obj.hasOwnProperty) {
+	    try {
+	      return Array.prototype.slice.call(obj);
+	    } catch (e) {
+	      // IE < 9 does not support Array#slice on collections objects
+	    }
+	  }
+
+	  // Fall back to copying key by key. This assumes all keys have a value,
+	  // so will not preserve sparsely populated inputs.
+	  var ret = Array(length);
+	  for (var ii = 0; ii < length; ii++) {
+	    ret[ii] = obj[ii];
+	  }
+	  return ret;
+	}
+
+	/**
+	 * 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()).
+	 *
+	 * It will return false for other array-like objects like Filelist.
+	 *
+	 * @param {*} obj
+	 * @return {boolean}
+	 */
+	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) &&
+	    // no DOM node should be considered an array-like
+	    // a 'select' element has 'length' and 'item' properties on IE8
+	    typeof obj.nodeType != 'number' && (
+	    // a real array
+	    Array.isArray(obj) ||
+	    // arguments
+	    'callee' in obj ||
+	    // HTMLCollection/NodeList
+	    'item' in obj)
+	  );
+	}
+
+	/**
+	 * Ensure that the argument is an array by wrapping it in an array if it is not.
+	 * Creates a copy of the argument if it is already an array.
+	 *
+	 * This is mostly useful idiomatically:
+	 *
+	 *   var createArrayFromMixed = require('createArrayFromMixed');
+	 *
+	 *   function takesOneOrMoreThings(things) {
+	 *     things = createArrayFromMixed(things);
+	 *     ...
+	 *   }
+	 *
+	 * This allows you to treat `things' as an array, but accept scalars in the API.
+	 *
+	 * If you need to convert an array-like object, like `arguments`, into an array
+	 * use toArray instead.
+	 *
+	 * @param {*} obj
+	 * @return {array}
+	 */
+	function createArrayFromMixed(obj) {
+	  if (!hasArrayNature(obj)) {
+	    return [obj];
+	  } else if (Array.isArray(obj)) {
+	    return obj.slice();
+	  } else {
+	    return toArray(obj);
+	  }
+	}
+
+	module.exports = createArrayFromMixed;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 94 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	/*eslint-disable fb-www/unsafe-html */
+
+	var ExecutionEnvironment = __webpack_require__(51);
+
+	var invariant = __webpack_require__(37);
+
+	/**
+	 * Dummy container used to detect which wraps are necessary.
+	 */
+	var dummyNode = ExecutionEnvironment.canUseDOM ? document.createElement('div') : null;
+
+	/**
+	 * Some browsers cannot use `innerHTML` to render certain elements standalone,
+	 * so we wrap them, render the wrapped nodes, then extract the desired node.
+	 *
+	 * In IE8, certain elements cannot render alone, so wrap all elements ('*').
+	 */
+
+	var shouldWrap = {};
+
+	var selectWrap = [1, '<select multiple="true">', '</select>'];
+	var tableWrap = [1, '<table>', '</table>'];
+	var trWrap = [3, '<table><tbody><tr>', '</tr></tbody></table>'];
+
+	var svgWrap = [1, '<svg xmlns="http://www.w3.org/2000/svg">', '</svg>'];
+
+	var markupWrap = {
+	  '*': [1, '?<div>', '</div>'],
+
+	  'area': [1, '<map>', '</map>'],
+	  'col': [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],
+	  'legend': [1, '<fieldset>', '</fieldset>'],
+	  'param': [1, '<object>', '</object>'],
+	  'tr': [2, '<table><tbody>', '</tbody></table>'],
+
+	  'optgroup': selectWrap,
+	  'option': selectWrap,
+
+	  'caption': tableWrap,
+	  'colgroup': tableWrap,
+	  'tbody': tableWrap,
+	  'tfoot': tableWrap,
+	  'thead': tableWrap,
+
+	  'td': trWrap,
+	  'th': trWrap
+	};
+
+	// Initialize the SVG elements since we know they'll always need to be wrapped
+	// consistently. If they are created inside a <div> they will be initialized in
+	// the wrong namespace (and will not display).
+	var svgElements = ['circle', 'clipPath', 'defs', 'ellipse', 'g', 'image', 'line', 'linearGradient', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'text', 'tspan'];
+	svgElements.forEach(function (nodeName) {
+	  markupWrap[nodeName] = svgWrap;
+	  shouldWrap[nodeName] = true;
+	});
+
+	/**
+	 * Gets the markup wrap configuration for the supplied `nodeName`.
+	 *
+	 * NOTE: This lazily detects which wraps are necessary for the current browser.
+	 *
+	 * @param {string} nodeName Lowercase `nodeName`.
+	 * @return {?array} Markup wrap configuration, if applicable.
+	 */
+	function getMarkupWrap(nodeName) {
+	  !!!dummyNode ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Markup wrapping node not initialized') : invariant(false) : void 0;
+	  if (!markupWrap.hasOwnProperty(nodeName)) {
+	    nodeName = '*';
+	  }
+	  if (!shouldWrap.hasOwnProperty(nodeName)) {
+	    if (nodeName === '*') {
+	      dummyNode.innerHTML = '<link />';
+	    } else {
+	      dummyNode.innerHTML = '<' + nodeName + '></' + nodeName + '>';
+	    }
+	    shouldWrap[nodeName] = !dummyNode.firstChild;
+	  }
+	  return shouldWrap[nodeName] ? markupWrap[nodeName] : null;
+	}
+
+	module.exports = getMarkupWrap;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 95 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var DOMChildrenOperations = __webpack_require__(84);
+	var ReactDOMComponentTree = __webpack_require__(34);
+
+	/**
+	 * Operations used to process updates to DOM nodes.
+	 */
+	var ReactDOMIDOperations = {
+
+	  /**
+	   * Updates a component's children by processing a series of updates.
+	   *
+	   * @param {array<object>} updates List of update configurations.
+	   * @internal
+	   */
+	  dangerouslyProcessChildrenUpdates: function (parentInst, updates) {
+	    var node = ReactDOMComponentTree.getNodeFromInstance(parentInst);
+	    DOMChildrenOperations.processUpdates(node, updates);
+	  }
+	};
+
+	module.exports = ReactDOMIDOperations;
+
+/***/ },
+/* 96 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	/* global hasOwnProperty:true */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35),
+	    _assign = __webpack_require__(53);
+
+	var AutoFocusUtils = __webpack_require__(97);
+	var CSSPropertyOperations = __webpack_require__(99);
+	var DOMLazyTree = __webpack_require__(85);
+	var DOMNamespaces = __webpack_require__(86);
+	var DOMProperty = __webpack_require__(36);
+	var DOMPropertyOperations = __webpack_require__(107);
+	var EventPluginHub = __webpack_require__(43);
+	var EventPluginRegistry = __webpack_require__(44);
+	var ReactBrowserEventEmitter = __webpack_require__(109);
+	var ReactDOMComponentFlags = __webpack_require__(38);
+	var ReactDOMComponentTree = __webpack_require__(34);
+	var ReactDOMInput = __webpack_require__(112);
+	var ReactDOMOption = __webpack_require__(115);
+	var ReactDOMSelect = __webpack_require__(116);
+	var ReactDOMTextarea = __webpack_require__(117);
+	var ReactInstrumentation = __webpack_require__(66);
+	var ReactMultiChild = __webpack_require__(118);
+	var ReactServerRenderingTransaction = __webpack_require__(138);
+
+	var emptyFunction = __webpack_require__(48);
+	var escapeTextContentForBrowser = __webpack_require__(90);
+	var invariant = __webpack_require__(37);
+	var isEventSupported = __webpack_require__(74);
+	var shallowEqual = __webpack_require__(128);
+	var validateDOMNesting = __webpack_require__(141);
+	var warning = __webpack_require__(47);
+
+	var Flags = ReactDOMComponentFlags;
+	var deleteListener = EventPluginHub.deleteListener;
+	var getNode = ReactDOMComponentTree.getNodeFromInstance;
+	var listenTo = ReactBrowserEventEmitter.listenTo;
+	var registrationNameModules = EventPluginRegistry.registrationNameModules;
+
+	// For quickly matching children type, to test if can be treated as content.
+	var CONTENT_TYPES = { 'string': true, 'number': true };
+
+	var STYLE = 'style';
+	var HTML = '__html';
+	var RESERVED_PROPS = {
+	  children: null,
+	  dangerouslySetInnerHTML: null,
+	  suppressContentEditableWarning: null
+	};
+
+	// Node type for document fragments (Node.DOCUMENT_FRAGMENT_NODE).
+	var DOC_FRAGMENT_TYPE = 11;
+
+	function getDeclarationErrorAddendum(internalInstance) {
+	  if (internalInstance) {
+	    var owner = internalInstance._currentElement._owner || null;
+	    if (owner) {
+	      var name = owner.getName();
+	      if (name) {
+	        return ' This DOM node was rendered by `' + name + '`.';
+	      }
+	    }
+	  }
+	  return '';
+	}
+
+	function friendlyStringify(obj) {
+	  if (typeof obj === 'object') {
+	    if (Array.isArray(obj)) {
+	      return '[' + obj.map(friendlyStringify).join(', ') + ']';
+	    } else {
+	      var pairs = [];
+	      for (var key in obj) {
+	        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+	          var keyEscaped = /^[a-z$_][\w$_]*$/i.test(key) ? key : JSON.stringify(key);
+	          pairs.push(keyEscaped + ': ' + friendlyStringify(obj[key]));
+	        }
+	      }
+	      return '{' + pairs.join(', ') + '}';
+	    }
+	  } else if (typeof obj === 'string') {
+	    return JSON.stringify(obj);
+	  } else if (typeof obj === 'function') {
+	    return '[function object]';
+	  }
+	  // Differs from JSON.stringify in that undefined because undefined and that
+	  // inf and nan don't become null
+	  return String(obj);
+	}
+
+	var styleMutationWarning = {};
+
+	function checkAndWarnForMutatedStyle(style1, style2, component) {
+	  if (style1 == null || style2 == null) {
+	    return;
+	  }
+	  if (shallowEqual(style1, style2)) {
+	    return;
+	  }
+
+	  var componentName = component._tag;
+	  var owner = component._currentElement._owner;
+	  var ownerName;
+	  if (owner) {
+	    ownerName = owner.getName();
+	  }
+
+	  var hash = ownerName + '|' + componentName;
+
+	  if (styleMutationWarning.hasOwnProperty(hash)) {
+	    return;
+	  }
+
+	  styleMutationWarning[hash] = true;
+
+	  process.env.NODE_ENV !== 'production' ? warning(false, '`%s` was passed a style object that has previously been mutated. ' + 'Mutating `style` is deprecated. Consider cloning it beforehand. Check ' + 'the `render` %s. Previous style: %s. Mutated style: %s.', componentName, owner ? 'of `' + ownerName + '`' : 'using <' + componentName + '>', friendlyStringify(style1), friendlyStringify(style2)) : void 0;
+	}
+
+	/**
+	 * @param {object} component
+	 * @param {?object} props
+	 */
+	function assertValidProps(component, props) {
+	  if (!props) {
+	    return;
+	  }
+	  // Note the use of `==` which checks for null or undefined.
+	  if (voidElementTags[component._tag]) {
+	    !(props.children == null && props.dangerouslySetInnerHTML == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`.%s', component._tag, component._currentElement._owner ? ' Check the render method of ' + component._currentElement._owner.getName() + '.' : '') : _prodInvariant('137', component._tag, component._currentElement._owner ? ' Check the render method of ' + component._currentElement._owner.getName() + '.' : '') : void 0;
+	  }
+	  if (props.dangerouslySetInnerHTML != null) {
+	    !(props.children == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Can only set one of `children` or `props.dangerouslySetInnerHTML`.') : _prodInvariant('60') : void 0;
+	    !(typeof props.dangerouslySetInnerHTML === 'object' && HTML in props.dangerouslySetInnerHTML) ? process.env.NODE_ENV !== 'production' ? invariant(false, '`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://fb.me/react-invariant-dangerously-set-inner-html for more information.') : _prodInvariant('61') : void 0;
+	  }
+	  if (process.env.NODE_ENV !== 'production') {
+	    process.env.NODE_ENV !== 'production' ? warning(props.innerHTML == null, 'Directly setting property `innerHTML` is not permitted. ' + 'For more information, lookup documentation on `dangerouslySetInnerHTML`.') : void 0;
+	    process.env.NODE_ENV !== 'production' ? warning(props.suppressContentEditableWarning || !props.contentEditable || props.children == null, 'A component is `contentEditable` and contains `children` managed by ' + 'React. It is now your responsibility to guarantee that none of ' + 'those nodes are unexpectedly modified or duplicated. This is ' + 'probably not intentional.') : void 0;
+	    process.env.NODE_ENV !== 'production' ? warning(props.onFocusIn == null && props.onFocusOut == null, 'React uses onFocus and onBlur instead of onFocusIn and onFocusOut. ' + 'All React events are normalized to bubble, so onFocusIn and onFocusOut ' + 'are not needed/supported by React.') : void 0;
+	  }
+	  !(props.style == null || typeof props.style === 'object') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + \'em\'}} when using JSX.%s', getDeclarationErrorAddendum(component)) : _prodInvariant('62', getDeclarationErrorAddendum(component)) : void 0;
+	}
+
+	function enqueuePutListener(inst, registrationName, listener, transaction) {
+	  if (transaction instanceof ReactServerRenderingTransaction) {
+	    return;
+	  }
+	  if (process.env.NODE_ENV !== 'production') {
+	    // IE8 has no API for event capturing and the `onScroll` event doesn't
+	    // bubble.
+	    process.env.NODE_ENV !== 'production' ? warning(registrationName !== 'onScroll' || isEventSupported('scroll', true), 'This browser doesn\'t support the `onScroll` event') : void 0;
+	  }
+	  var containerInfo = inst._hostContainerInfo;
+	  var isDocumentFragment = containerInfo._node && containerInfo._node.nodeType === DOC_FRAGMENT_TYPE;
+	  var doc = isDocumentFragment ? containerInfo._node : containerInfo._ownerDocument;
+	  listenTo(registrationName, doc);
+	  transaction.getReactMountReady().enqueue(putListener, {
+	    inst: inst,
+	    registrationName: registrationName,
+	    listener: listener
+	  });
+	}
+
+	function putListener() {
+	  var listenerToPut = this;
+	  EventPluginHub.putListener(listenerToPut.inst, listenerToPut.registrationName, listenerToPut.listener);
+	}
+
+	function inputPostMount() {
+	  var inst = this;
+	  ReactDOMInput.postMountWrapper(inst);
+	}
+
+	function textareaPostMount() {
+	  var inst = this;
+	  ReactDOMTextarea.postMountWrapper(inst);
+	}
+
+	function optionPostMount() {
+	  var inst = this;
+	  ReactDOMOption.postMountWrapper(inst);
+	}
+
+	var setAndValidateContentChildDev = emptyFunction;
+	if (process.env.NODE_ENV !== 'production') {
+	  setAndValidateContentChildDev = function (content) {
+	    var hasExistingContent = this._contentDebugID != null;
+	    var debugID = this._debugID;
+	    // This ID represents the inlined child that has no backing instance:
+	    var contentDebugID = -debugID;
+
+	    if (content == null) {
+	      if (hasExistingContent) {
+	        ReactInstrumentation.debugTool.onUnmountComponent(this._contentDebugID);
+	      }
+	      this._contentDebugID = null;
+	      return;
+	    }
+
+	    validateDOMNesting(null, String(content), this, this._ancestorInfo);
+	    this._contentDebugID = contentDebugID;
+	    if (hasExistingContent) {
+	      ReactInstrumentation.debugTool.onBeforeUpdateComponent(contentDebugID, content);
+	      ReactInstrumentation.debugTool.onUpdateComponent(contentDebugID);
+	    } else {
+	      ReactInstrumentation.debugTool.onBeforeMountComponent(contentDebugID, content, debugID);
+	      ReactInstrumentation.debugTool.onMountComponent(contentDebugID);
+	      ReactInstrumentation.debugTool.onSetChildren(debugID, [contentDebugID]);
+	    }
+	  };
+	}
+
+	// There are so many media events, it makes sense to just
+	// maintain a list rather than create a `trapBubbledEvent` for each
+	var mediaEvents = {
+	  topAbort: 'abort',
+	  topCanPlay: 'canplay',
+	  topCanPlayThrough: 'canplaythrough',
+	  topDurationChange: 'durationchange',
+	  topEmptied: 'emptied',
+	  topEncrypted: 'encrypted',
+	  topEnded: 'ended',
+	  topError: 'error',
+	  topLoadedData: 'loadeddata',
+	  topLoadedMetadata: 'loadedmetadata',
+	  topLoadStart: 'loadstart',
+	  topPause: 'pause',
+	  topPlay: 'play',
+	  topPlaying: 'playing',
+	  topProgress: 'progress',
+	  topRateChange: 'ratechange',
+	  topSeeked: 'seeked',
+	  topSeeking: 'seeking',
+	  topStalled: 'stalled',
+	  topSuspend: 'suspend',
+	  topTimeUpdate: 'timeupdate',
+	  topVolumeChange: 'volumechange',
+	  topWaiting: 'waiting'
+	};
+
+	function trapBubbledEventsLocal() {
+	  var inst = this;
+	  // If a component renders to null or if another component fatals and causes
+	  // the state of the tree to be corrupted, `node` here can be null.
+	  !inst._rootNodeID ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Must be mounted to trap events') : _prodInvariant('63') : void 0;
+	  var node = getNode(inst);
+	  !node ? process.env.NODE_ENV !== 'production' ? invariant(false, 'trapBubbledEvent(...): Requires node to be rendered.') : _prodInvariant('64') : void 0;
+
+	  switch (inst._tag) {
+	    case 'iframe':
+	    case 'object':
+	      inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent('topLoad', 'load', node)];
+	      break;
+	    case 'video':
+	    case 'audio':
+
+	      inst._wrapperState.listeners = [];
+	      // Create listener for each media event
+	      for (var event in mediaEvents) {
+	        if (mediaEvents.hasOwnProperty(event)) {
+	          inst._wrapperState.listeners.push(ReactBrowserEventEmitter.trapBubbledEvent(event, mediaEvents[event], node));
+	        }
+	      }
+	      break;
+	    case 'source':
+	      inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent('topError', 'error', node)];
+	      break;
+	    case 'img':
+	      inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent('topError', 'error', node), ReactBrowserEventEmitter.trapBubbledEvent('topLoad', 'load', node)];
+	      break;
+	    case 'form':
+	      inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent('topReset', 'reset', node), ReactBrowserEventEmitter.trapBubbledEvent('topSubmit', 'submit', node)];
+	      break;
+	    case 'input':
+	    case 'select':
+	    case 'textarea':
+	      inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent('topInvalid', 'invalid', node)];
+	      break;
+	  }
+	}
+
+	function postUpdateSelectWrapper() {
+	  ReactDOMSelect.postUpdateWrapper(this);
+	}
+
+	// For HTML, certain tags should omit their close tag. We keep a whitelist for
+	// those special-case tags.
+
+	var omittedCloseTags = {
+	  'area': true,
+	  'base': true,
+	  'br': true,
+	  'col': true,
+	  'embed': true,
+	  'hr': true,
+	  'img': true,
+	  'input': true,
+	  'keygen': true,
+	  'link': true,
+	  'meta': true,
+	  'param': true,
+	  'source': true,
+	  'track': true,
+	  'wbr': true
+	};
+
+	var newlineEatingTags = {
+	  'listing': true,
+	  'pre': true,
+	  'textarea': true
+	};
+
+	// For HTML, certain tags cannot have children. This has the same purpose as
+	// `omittedCloseTags` except that `menuitem` should still have its closing tag.
+
+	var voidElementTags = _assign({
+	  'menuitem': true
+	}, omittedCloseTags);
+
+	// We accept any tag to be rendered but since this gets injected into arbitrary
+	// HTML, we want to make sure that it's a safe tag.
+	// http://www.w3.org/TR/REC-xml/#NT-Name
+
+	var VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/; // Simplified subset
+	var validatedTagCache = {};
+	var hasOwnProperty = {}.hasOwnProperty;
+
+	function validateDangerousTag(tag) {
+	  if (!hasOwnProperty.call(validatedTagCache, tag)) {
+	    !VALID_TAG_REGEX.test(tag) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Invalid tag: %s', tag) : _prodInvariant('65', tag) : void 0;
+	    validatedTagCache[tag] = true;
+	  }
+	}
+
+	function isCustomComponent(tagName, props) {
+	  return tagName.indexOf('-') >= 0 || props.is != null;
+	}
+
+	var globalIdCounter = 1;
+
+	/**
+	 * 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.
+	 *
+	 * @constructor ReactDOMComponent
+	 * @extends ReactMultiChild
+	 */
+	function ReactDOMComponent(element) {
+	  var tag = element.type;
+	  validateDangerousTag(tag);
+	  this._currentElement = element;
+	  this._tag = tag.toLowerCase();
+	  this._namespaceURI = null;
+	  this._renderedChildren = null;
+	  this._previousStyle = null;
+	  this._previousStyleCopy = null;
+	  this._hostNode = null;
+	  this._hostParent = null;
+	  this._rootNodeID = 0;
+	  this._domID = 0;
+	  this._hostContainerInfo = null;
+	  this._wrapperState = null;
+	  this._topLevelWrapper = null;
+	  this._flags = 0;
+	  if (process.env.NODE_ENV !== 'production') {
+	    this._ancestorInfo = null;
+	    setAndValidateContentChildDev.call(this, null);
+	  }
+	}
+
+	ReactDOMComponent.displayName = 'ReactDOMComponent';
+
+	ReactDOMComponent.Mixin = {
+
+	  /**
+	   * Generates root tag markup then recurses. This method has side effects and
+	   * is not idempotent.
+	   *
+	   * @internal
+	   * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
+	   * @param {?ReactDOMComponent} the parent component instance
+	   * @param {?object} info about the host container
+	   * @param {object} context
+	   * @return {string} The computed markup.
+	   */
+	  mountComponent: function (transaction, hostParent, hostContainerInfo, context) {
+	    this._rootNodeID = globalIdCounter++;
+	    this._domID = hostContainerInfo._idCounter++;
+	    this._hostParent = hostParent;
+	    this._hostContainerInfo = hostContainerInfo;
+
+	    var props = this._currentElement.props;
+
+	    switch (this._tag) {
+	      case 'audio':
+	      case 'form':
+	      case 'iframe':
+	      case 'img':
+	      case 'link':
+	      case 'object':
+	      case 'source':
+	      case 'video':
+	        this._wrapperState = {
+	          listeners: null
+	        };
+	        transaction.getReactMountReady().enqueue(trapBubbledEventsLocal, this);
+	        break;
+	      case 'input':
+	        ReactDOMInput.mountWrapper(this, props, hostParent);
+	        props = ReactDOMInput.getHostProps(this, props);
+	        transaction.getReactMountReady().enqueue(trapBubbledEventsLocal, this);
+	        break;
+	      case 'option':
+	        ReactDOMOption.mountWrapper(this, props, hostParent);
+	        props = ReactDOMOption.getHostProps(this, props);
+	        break;
+	      case 'select':
+	        ReactDOMSelect.mountWrapper(this, props, hostParent);
+	        props = ReactDOMSelect.getHostProps(this, props);
+	        transaction.getReactMountReady().enqueue(trapBubbledEventsLocal, this);
+	        break;
+	      case 'textarea':
+	        ReactDOMTextarea.mountWrapper(this, props, hostParent);
+	        props = ReactDOMTextarea.getHostProps(this, props);
+	        transaction.getReactMountReady().enqueue(trapBubbledEventsLocal, this);
+	        break;
+	    }
+
+	    assertValidProps(this, props);
+
+	    // We create tags in the namespace of their parent container, except HTML
+	    // tags get no namespace.
+	    var namespaceURI;
+	    var parentTag;
+	    if (hostParent != null) {
+	      namespaceURI = hostParent._namespaceURI;
+	      parentTag = hostParent._tag;
+	    } else if (hostContainerInfo._tag) {
+	      namespaceURI = hostContainerInfo._namespaceURI;
+	      parentTag = hostContainerInfo._tag;
+	    }
+	    if (namespaceURI == null || namespaceURI === DOMNamespaces.svg && parentTag === 'foreignobject') {
+	      namespaceURI = DOMNamespaces.html;
+	    }
+	    if (namespaceURI === DOMNamespaces.html) {
+	      if (this._tag === 'svg') {
+	        namespaceURI = DOMNamespaces.svg;
+	      } else if (this._tag === 'math') {
+	        namespaceURI = DOMNamespaces.mathml;
+	      }
+	    }
+	    this._namespaceURI = namespaceURI;
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      var parentInfo;
+	      if (hostParent != null) {
+	        parentInfo = hostParent._ancestorInfo;
+	      } else if (hostContainerInfo._tag) {
+	        parentInfo = hostContainerInfo._ancestorInfo;
+	      }
+	      if (parentInfo) {
+	        // parentInfo should always be present except for the top-level
+	        // component when server rendering
+	        validateDOMNesting(this._tag, null, this, parentInfo);
+	      }
+	      this._ancestorInfo = validateDOMNesting.updatedAncestorInfo(parentInfo, this._tag, this);
+	    }
+
+	    var mountImage;
+	    if (transaction.useCreateElement) {
+	      var ownerDocument = hostContainerInfo._ownerDocument;
+	      var el;
+	      if (namespaceURI === DOMNamespaces.html) {
+	        if (this._tag === 'script') {
+	          // Create the script via .innerHTML so its "parser-inserted" flag is
+	          // set to true and it does not execute
+	          var div = ownerDocument.createElement('div');
+	          var type = this._currentElement.type;
+	          div.innerHTML = '<' + type + '></' + type + '>';
+	          el = div.removeChild(div.firstChild);
+	        } else if (props.is) {
+	          el = ownerDocument.createElement(this._currentElement.type, props.is);
+	        } else {
+	          // Separate else branch instead of using `props.is || undefined` above becuase of a Firefox bug.
+	          // See discussion in https://github.com/facebook/react/pull/6896
+	          // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
+	          el = ownerDocument.createElement(this._currentElement.type);
+	        }
+	      } else {
+	        el = ownerDocument.createElementNS(namespaceURI, this._currentElement.type);
+	      }
+	      ReactDOMComponentTree.precacheNode(this, el);
+	      this._flags |= Flags.hasCachedChildNodes;
+	      if (!this._hostParent) {
+	        DOMPropertyOperations.setAttributeForRoot(el);
+	      }
+	      this._updateDOMProperties(null, props, transaction);
+	      var lazyTree = DOMLazyTree(el);
+	      this._createInitialChildren(transaction, props, context, lazyTree);
+	      mountImage = lazyTree;
+	    } else {
+	      var tagOpen = this._createOpenTagMarkupAndPutListeners(transaction, props);
+	      var tagContent = this._createContentMarkup(transaction, props, context);
+	      if (!tagContent && omittedCloseTags[this._tag]) {
+	        mountImage = tagOpen + '/>';
+	      } else {
+	        mountImage = tagOpen + '>' + tagContent + '</' + this._currentElement.type + '>';
+	      }
+	    }
+
+	    switch (this._tag) {
+	      case 'input':
+	        transaction.getReactMountReady().enqueue(inputPostMount, this);
+	        if (props.autoFocus) {
+	          transaction.getReactMountReady().enqueue(AutoFocusUtils.focusDOMComponent, this);
+	        }
+	        break;
+	      case 'textarea':
+	        transaction.getReactMountReady().enqueue(textareaPostMount, this);
+	        if (props.autoFocus) {
+	          transaction.getReactMountReady().enqueue(AutoFocusUtils.focusDOMComponent, this);
+	        }
+	        break;
+	      case 'select':
+	        if (props.autoFocus) {
+	          transaction.getReactMountReady().enqueue(AutoFocusUtils.focusDOMComponent, this);
+	        }
+	        break;
+	      case 'button':
+	        if (props.autoFocus) {
+	          transaction.getReactMountReady().enqueue(AutoFocusUtils.focusDOMComponent, this);
+	        }
+	        break;
+	      case 'option':
+	        transaction.getReactMountReady().enqueue(optionPostMount, this);
+	        break;
+	    }
+
+	    return mountImage;
+	  },
+
+	  /**
+	   * 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
+	   * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
+	   * @param {object} props
+	   * @return {string} Markup of opening tag.
+	   */
+	  _createOpenTagMarkupAndPutListeners: function (transaction, props) {
+	    var ret = '<' + this._currentElement.type;
+
+	    for (var propKey in props) {
+	      if (!props.hasOwnProperty(propKey)) {
+	        continue;
+	      }
+	      var propValue = props[propKey];
+	      if (propValue == null) {
+	        continue;
+	      }
+	      if (registrationNameModules.hasOwnProperty(propKey)) {
+	        if (propValue) {
+	          enqueuePutListener(this, propKey, propValue, transaction);
+	        }
+	      } else {
+	        if (propKey === STYLE) {
+	          if (propValue) {
+	            if (process.env.NODE_ENV !== 'production') {
+	              // See `_updateDOMProperties`. style block
+	              this._previousStyle = propValue;
+	            }
+	            propValue = this._previousStyleCopy = _assign({}, props.style);
+	          }
+	          propValue = CSSPropertyOperations.createMarkupForStyles(propValue, this);
+	        }
+	        var markup = null;
+	        if (this._tag != null && isCustomComponent(this._tag, props)) {
+	          if (!RESERVED_PROPS.hasOwnProperty(propKey)) {
+	            markup = DOMPropertyOperations.createMarkupForCustomAttribute(propKey, propValue);
+	          }
+	        } else {
+	          markup = DOMPropertyOperations.createMarkupForProperty(propKey, propValue);
+	        }
+	        if (markup) {
+	          ret += ' ' + markup;
+	        }
+	      }
+	    }
+
+	    // For static pages, no need to put React ID and checksum. Saves lots of
+	    // bytes.
+	    if (transaction.renderToStaticMarkup) {
+	      return ret;
+	    }
+
+	    if (!this._hostParent) {
+	      ret += ' ' + DOMPropertyOperations.createMarkupForRoot();
+	    }
+	    ret += ' ' + DOMPropertyOperations.createMarkupForID(this._domID);
+	    return ret;
+	  },
+
+	  /**
+	   * Creates markup for the content between the tags.
+	   *
+	   * @private
+	   * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
+	   * @param {object} props
+	   * @param {object} context
+	   * @return {string} Content markup.
+	   */
+	  _createContentMarkup: function (transaction, props, context) {
+	    var ret = '';
+
+	    // Intentional use of != to avoid catching zero/false.
+	    var innerHTML = props.dangerouslySetInnerHTML;
+	    if (innerHTML != null) {
+	      if (innerHTML.__html != null) {
+	        ret = innerHTML.__html;
+	      }
+	    } else {
+	      var contentToUse = CONTENT_TYPES[typeof props.children] ? props.children : null;
+	      var childrenToUse = contentToUse != null ? null : props.children;
+	      if (contentToUse != null) {
+	        // TODO: Validate that text is allowed as a child of this node
+	        ret = escapeTextContentForBrowser(contentToUse);
+	        if (process.env.NODE_ENV !== 'production') {
+	          setAndValidateContentChildDev.call(this, contentToUse);
+	        }
+	      } else if (childrenToUse != null) {
+	        var mountImages = this.mountChildren(childrenToUse, transaction, context);
+	        ret = mountImages.join('');
+	      }
+	    }
+	    if (newlineEatingTags[this._tag] && ret.charAt(0) === '\n') {
+	      // text/html ignores the first character in these tags if it's a newline
+	      // Prefer to break application/xml over text/html (for now) by adding
+	      // a newline specifically to get eaten by the parser. (Alternately for
+	      // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
+	      // \r is normalized out by HTMLTextAreaElement#value.)
+	      // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
+	      // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
+	      // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
+	      // See: Parsing of "textarea" "listing" and "pre" elements
+	      //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
+	      return '\n' + ret;
+	    } else {
+	      return ret;
+	    }
+	  },
+
+	  _createInitialChildren: function (transaction, props, context, lazyTree) {
+	    // Intentional use of != to avoid catching zero/false.
+	    var innerHTML = props.dangerouslySetInnerHTML;
+	    if (innerHTML != null) {
+	      if (innerHTML.__html != null) {
+	        DOMLazyTree.queueHTML(lazyTree, innerHTML.__html);
+	      }
+	    } else {
+	      var contentToUse = CONTENT_TYPES[typeof props.children] ? props.children : null;
+	      var childrenToUse = contentToUse != null ? null : props.children;
+	      if (contentToUse != null) {
+	        // TODO: Validate that text is allowed as a child of this node
+	        if (process.env.NODE_ENV !== 'production') {
+	          setAndValidateContentChildDev.call(this, contentToUse);
+	        }
+	        DOMLazyTree.queueText(lazyTree, contentToUse);
+	      } else if (childrenToUse != null) {
+	        var mountImages = this.mountChildren(childrenToUse, transaction, context);
+	        for (var i = 0; i < mountImages.length; i++) {
+	          DOMLazyTree.queueChild(lazyTree, mountImages[i]);
+	        }
+	      }
+	    }
+	  },
+
+	  /**
+	   * Receives a next element and updates the component.
+	   *
+	   * @internal
+	   * @param {ReactElement} nextElement
+	   * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
+	   * @param {object} context
+	   */
+	  receiveComponent: function (nextElement, transaction, context) {
+	    var prevElement = this._currentElement;
+	    this._currentElement = nextElement;
+	    this.updateComponent(transaction, prevElement, nextElement, context);
+	  },
+
+	  /**
+	   * Updates a DOM component after it has already been allocated and
+	   * attached to the DOM. Reconciles the root DOM node, then recurses.
+	   *
+	   * @param {ReactReconcileTransaction} transaction
+	   * @param {ReactElement} prevElement
+	   * @param {ReactElement} nextElement
+	   * @internal
+	   * @overridable
+	   */
+	  updateComponent: function (transaction, prevElement, nextElement, context) {
+	    var lastProps = prevElement.props;
+	    var nextProps = this._currentElement.props;
+
+	    switch (this._tag) {
+	      case 'input':
+	        lastProps = ReactDOMInput.getHostProps(this, lastProps);
+	        nextProps = ReactDOMInput.getHostProps(this, nextProps);
+	        break;
+	      case 'option':
+	        lastProps = ReactDOMOption.getHostProps(this, lastProps);
+	        nextProps = ReactDOMOption.getHostProps(this, nextProps);
+	        break;
+	      case 'select':
+	        lastProps = ReactDOMSelect.getHostProps(this, lastProps);
+	        nextProps = ReactDOMSelect.getHostProps(this, nextProps);
+	        break;
+	      case 'textarea':
+	        lastProps = ReactDOMTextarea.getHostProps(this, lastProps);
+	        nextProps = ReactDOMTextarea.getHostProps(this, nextProps);
+	        break;
+	    }
+
+	    assertValidProps(this, nextProps);
+	    this._updateDOMProperties(lastProps, nextProps, transaction);
+	    this._updateDOMChildren(lastProps, nextProps, transaction, context);
+
+	    switch (this._tag) {
+	      case 'input':
+	        // Update the wrapper around inputs *after* updating props. This has to
+	        // happen after `_updateDOMProperties`. Otherwise HTML5 input validations
+	        // raise warnings and prevent the new value from being assigned.
+	        ReactDOMInput.updateWrapper(this);
+	        break;
+	      case 'textarea':
+	        ReactDOMTextarea.updateWrapper(this);
+	        break;
+	      case 'select':
+	        // <select> value update needs to occur after <option> children
+	        // reconciliation
+	        transaction.getReactMountReady().enqueue(postUpdateSelectWrapper, this);
+	        break;
+	    }
+	  },
+
+	  /**
+	   * 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} lastProps
+	   * @param {object} nextProps
+	   * @param {?DOMElement} node
+	   */
+	  _updateDOMProperties: function (lastProps, nextProps, transaction) {
+	    var propKey;
+	    var styleName;
+	    var styleUpdates;
+	    for (propKey in lastProps) {
+	      if (nextProps.hasOwnProperty(propKey) || !lastProps.hasOwnProperty(propKey) || lastProps[propKey] == null) {
+	        continue;
+	      }
+	      if (propKey === STYLE) {
+	        var lastStyle = this._previousStyleCopy;
+	        for (styleName in lastStyle) {
+	          if (lastStyle.hasOwnProperty(styleName)) {
+	            styleUpdates = styleUpdates || {};
+	            styleUpdates[styleName] = '';
+	          }
+	        }
+	        this._previousStyleCopy = null;
+	      } else if (registrationNameModules.hasOwnProperty(propKey)) {
+	        if (lastProps[propKey]) {
+	          // Only call deleteListener if there was a listener previously or
+	          // else willDeleteListener gets called when there wasn't actually a
+	          // listener (e.g., onClick={null})
+	          deleteListener(this, propKey);
+	        }
+	      } else if (isCustomComponent(this._tag, lastProps)) {
+	        if (!RESERVED_PROPS.hasOwnProperty(propKey)) {
+	          DOMPropertyOperations.deleteValueForAttribute(getNode(this), propKey);
+	        }
+	      } else if (DOMProperty.properties[propKey] || DOMProperty.isCustomAttribute(propKey)) {
+	        DOMPropertyOperations.deleteValueForProperty(getNode(this), propKey);
+	      }
+	    }
+	    for (propKey in nextProps) {
+	      var nextProp = nextProps[propKey];
+	      var lastProp = propKey === STYLE ? this._previousStyleCopy : lastProps != null ? lastProps[propKey] : undefined;
+	      if (!nextProps.hasOwnProperty(propKey) || nextProp === lastProp || nextProp == null && lastProp == null) {
+	        continue;
+	      }
+	      if (propKey === STYLE) {
+	        if (nextProp) {
+	          if (process.env.NODE_ENV !== 'production') {
+	            checkAndWarnForMutatedStyle(this._previousStyleCopy, this._previousStyle, this);
+	            this._previousStyle = nextProp;
+	          }
+	          nextProp = this._previousStyleCopy = _assign({}, nextProp);
+	        } else {
+	          this._previousStyleCopy = null;
+	        }
+	        if (lastProp) {
+	          // Unset styles on `lastProp` but not on `nextProp`.
+	          for (styleName in lastProp) {
+	            if (lastProp.hasOwnProperty(styleName) && (!nextProp || !nextProp.hasOwnProperty(styleName))) {
+	              styleUpdates = styleUpdates || {};
+	              styleUpdates[styleName] = '';
+	            }
+	          }
+	          // Update styles that changed since `lastProp`.
+	          for (styleName in nextProp) {
+	            if (nextProp.hasOwnProperty(styleName) && lastProp[styleName] !== nextProp[styleName]) {
+	              styleUpdates = styleUpdates || {};
+	              styleUpdates[styleName] = nextProp[styleName];
+	            }
+	          }
+	        } else {
+	          // Relies on `updateStylesByID` not mutating `styleUpdates`.
+	          styleUpdates = nextProp;
+	        }
+	      } else if (registrationNameModules.hasOwnProperty(propKey)) {
+	        if (nextProp) {
+	          enqueuePutListener(this, propKey, nextProp, transaction);
+	        } else if (lastProp) {
+	          deleteListener(this, propKey);
+	        }
+	      } else if (isCustomComponent(this._tag, nextProps)) {
+	        if (!RESERVED_PROPS.hasOwnProperty(propKey)) {
+	          DOMPropertyOperations.setValueForAttribute(getNode(this), propKey, nextProp);
+	        }
+	      } else if (DOMProperty.properties[propKey] || DOMProperty.isCustomAttribute(propKey)) {
+	        var node = getNode(this);
+	        // If we're updating to null or undefined, we should remove the property
+	        // from the DOM node instead of inadvertently setting to a string. This
+	        // brings us in line with the same behavior we have on initial render.
+	        if (nextProp != null) {
+	          DOMPropertyOperations.setValueForProperty(node, propKey, nextProp);
+	        } else {
+	          DOMPropertyOperations.deleteValueForProperty(node, propKey);
+	        }
+	      }
+	    }
+	    if (styleUpdates) {
+	      CSSPropertyOperations.setValueForStyles(getNode(this), styleUpdates, this);
+	    }
+	  },
+
+	  /**
+	   * Reconciles the children with the various properties that affect the
+	   * children content.
+	   *
+	   * @param {object} lastProps
+	   * @param {object} nextProps
+	   * @param {ReactReconcileTransaction} transaction
+	   * @param {object} context
+	   */
+	  _updateDOMChildren: function (lastProps, nextProps, transaction, context) {
+	    var lastContent = CONTENT_TYPES[typeof lastProps.children] ? lastProps.children : null;
+	    var nextContent = CONTENT_TYPES[typeof nextProps.children] ? nextProps.children : null;
+
+	    var lastHtml = lastProps.dangerouslySetInnerHTML && lastProps.dangerouslySetInnerHTML.__html;
+	    var nextHtml = nextProps.dangerouslySetInnerHTML && nextProps.dangerouslySetInnerHTML.__html;
+
+	    // Note the use of `!=` which checks for null or undefined.
+	    var lastChildren = lastContent != null ? null : lastProps.children;
+	    var nextChildren = nextContent != null ? null : nextProps.children;
+
+	    // If we're switching from children to content/html or vice versa, remove
+	    // the old content
+	    var lastHasContentOrHtml = lastContent != null || lastHtml != null;
+	    var nextHasContentOrHtml = nextContent != null || nextHtml != null;
+	    if (lastChildren != null && nextChildren == null) {
+	      this.updateChildren(null, transaction, context);
+	    } else if (lastHasContentOrHtml && !nextHasContentOrHtml) {
+	      this.updateTextContent('');
+	      if (process.env.NODE_ENV !== 'production') {
+	        ReactInstrumentation.debugTool.onSetChildren(this._debugID, []);
+	      }
+	    }
+
+	    if (nextContent != null) {
+	      if (lastContent !== nextContent) {
+	        this.updateTextContent('' + nextContent);
+	        if (process.env.NODE_ENV !== 'production') {
+	          setAndValidateContentChildDev.call(this, nextContent);
+	        }
+	      }
+	    } else if (nextHtml != null) {
+	      if (lastHtml !== nextHtml) {
+	        this.updateMarkup('' + nextHtml);
+	      }
+	      if (process.env.NODE_ENV !== 'production') {
+	        ReactInstrumentation.debugTool.onSetChildren(this._debugID, []);
+	      }
+	    } else if (nextChildren != null) {
+	      if (process.env.NODE_ENV !== 'production') {
+	        setAndValidateContentChildDev.call(this, null);
+	      }
+
+	      this.updateChildren(nextChildren, transaction, context);
+	    }
+	  },
+
+	  getHostNode: function () {
+	    return getNode(this);
+	  },
+
+	  /**
+	   * Destroys all event registrations for this instance. Does not remove from
+	   * the DOM. That must be done by the parent.
+	   *
+	   * @internal
+	   */
+	  unmountComponent: function (safely) {
+	    switch (this._tag) {
+	      case 'audio':
+	      case 'form':
+	      case 'iframe':
+	      case 'img':
+	      case 'link':
+	      case 'object':
+	      case 'source':
+	      case 'video':
+	        var listeners = this._wrapperState.listeners;
+	        if (listeners) {
+	          for (var i = 0; i < listeners.length; i++) {
+	            listeners[i].remove();
+	          }
+	        }
+	        break;
+	      case 'html':
+	      case 'head':
+	      case 'body':
+	        /**
+	         * Components like <html> <head> and <body> can't be removed or added
+	         * easily in a cross-browser way, however it's valuable to be able to
+	         * take advantage of React's reconciliation for styling and <title>
+	         * management. So we just document it and throw in dangerous cases.
+	         */
+	         true ? process.env.NODE_ENV !== 'production' ? invariant(false, '<%s> tried to unmount. Because of cross-browser quirks it is impossible to unmount some top-level components (eg <html>, <head>, and <body>) reliably and efficiently. To fix this, have a single top-level component that never unmounts render these elements.', this._tag) : _prodInvariant('66', this._tag) : void 0;
+	        break;
+	    }
+
+	    this.unmountChildren(safely);
+	    ReactDOMComponentTree.uncacheNode(this);
+	    EventPluginHub.deleteAllListeners(this);
+	    this._rootNodeID = 0;
+	    this._domID = 0;
+	    this._wrapperState = null;
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      setAndValidateContentChildDev.call(this, null);
+	    }
+	  },
+
+	  getPublicInstance: function () {
+	    return getNode(this);
+	  }
+
+	};
+
+	_assign(ReactDOMComponent.prototype, ReactDOMComponent.Mixin, ReactMultiChild.Mixin);
+
+	module.exports = ReactDOMComponent;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 97 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ReactDOMComponentTree = __webpack_require__(34);
+
+	var focusNode = __webpack_require__(98);
+
+	var AutoFocusUtils = {
+	  focusDOMComponent: function () {
+	    focusNode(ReactDOMComponentTree.getNodeFromInstance(this));
+	  }
+	};
+
+	module.exports = AutoFocusUtils;
+
+/***/ },
+/* 98 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	/**
+	 * @param {DOMElement} node input/textarea to focus
+	 */
+
+	function focusNode(node) {
+	  // IE8 can throw "Can't move focus to the control because it is invisible,
+	  // not enabled, or of a type that does not accept the focus." for all kinds of
+	  // reasons that are too expensive and fragile to test.
+	  try {
+	    node.focus();
+	  } catch (e) {}
+	}
+
+	module.exports = focusNode;
+
+/***/ },
+/* 99 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var CSSProperty = __webpack_require__(100);
+	var ExecutionEnvironment = __webpack_require__(51);
+	var ReactInstrumentation = __webpack_require__(66);
+
+	var camelizeStyleName = __webpack_require__(101);
+	var dangerousStyleValue = __webpack_require__(103);
+	var hyphenateStyleName = __webpack_require__(104);
+	var memoizeStringOnly = __webpack_require__(106);
+	var warning = __webpack_require__(47);
+
+	var processStyleName = memoizeStringOnly(function (styleName) {
+	  return hyphenateStyleName(styleName);
+	});
+
+	var hasShorthandPropertyBug = false;
+	var styleFloatAccessor = 'cssFloat';
+	if (ExecutionEnvironment.canUseDOM) {
+	  var tempStyle = document.createElement('div').style;
+	  try {
+	    // IE8 throws "Invalid argument." if resetting shorthand style properties.
+	    tempStyle.font = '';
+	  } catch (e) {
+	    hasShorthandPropertyBug = true;
+	  }
+	  // IE8 only supports accessing cssFloat (standard) as styleFloat
+	  if (document.documentElement.style.cssFloat === undefined) {
+	    styleFloatAccessor = 'styleFloat';
+	  }
+	}
+
+	if (process.env.NODE_ENV !== 'production') {
+	  // 'msTransform' is correct, but the other prefixes should be capitalized
+	  var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;
+
+	  // style values shouldn't contain a semicolon
+	  var badStyleValueWithSemicolonPattern = /;\s*$/;
+
+	  var warnedStyleNames = {};
+	  var warnedStyleValues = {};
+	  var warnedForNaNValue = false;
+
+	  var warnHyphenatedStyleName = function (name, owner) {
+	    if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+	      return;
+	    }
+
+	    warnedStyleNames[name] = true;
+	    process.env.NODE_ENV !== 'production' ? warning(false, 'Unsupported style property %s. Did you mean %s?%s', name, camelizeStyleName(name), checkRenderMessage(owner)) : void 0;
+	  };
+
+	  var warnBadVendoredStyleName = function (name, owner) {
+	    if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
+	      return;
+	    }
+
+	    warnedStyleNames[name] = true;
+	    process.env.NODE_ENV !== 'production' ? warning(false, 'Unsupported vendor-prefixed style property %s. Did you mean %s?%s', name, name.charAt(0).toUpperCase() + name.slice(1), checkRenderMessage(owner)) : void 0;
+	  };
+
+	  var warnStyleValueWithSemicolon = function (name, value, owner) {
+	    if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {
+	      return;
+	    }
+
+	    warnedStyleValues[value] = true;
+	    process.env.NODE_ENV !== 'production' ? warning(false, 'Style property values shouldn\'t contain a semicolon.%s ' + 'Try "%s: %s" instead.', checkRenderMessage(owner), name, value.replace(badStyleValueWithSemicolonPattern, '')) : void 0;
+	  };
+
+	  var warnStyleValueIsNaN = function (name, value, owner) {
+	    if (warnedForNaNValue) {
+	      return;
+	    }
+
+	    warnedForNaNValue = true;
+	    process.env.NODE_ENV !== 'production' ? warning(false, '`NaN` is an invalid value for the `%s` css style property.%s', name, checkRenderMessage(owner)) : void 0;
+	  };
+
+	  var checkRenderMessage = function (owner) {
+	    if (owner) {
+	      var name = owner.getName();
+	      if (name) {
+	        return ' Check the render method of `' + name + '`.';
+	      }
+	    }
+	    return '';
+	  };
+
+	  /**
+	   * @param {string} name
+	   * @param {*} value
+	   * @param {ReactDOMComponent} component
+	   */
+	  var warnValidStyle = function (name, value, component) {
+	    var owner;
+	    if (component) {
+	      owner = component._currentElement._owner;
+	    }
+	    if (name.indexOf('-') > -1) {
+	      warnHyphenatedStyleName(name, owner);
+	    } else if (badVendoredStyleNamePattern.test(name)) {
+	      warnBadVendoredStyleName(name, owner);
+	    } else if (badStyleValueWithSemicolonPattern.test(value)) {
+	      warnStyleValueWithSemicolon(name, value, owner);
+	    }
+
+	    if (typeof value === 'number' && isNaN(value)) {
+	      warnStyleValueIsNaN(name, value, owner);
+	    }
+	  };
+	}
+
+	/**
+	 * 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.
+	   * The result should be HTML-escaped before insertion into the DOM.
+	   *
+	   * @param {object} styles
+	   * @param {ReactDOMComponent} component
+	   * @return {?string}
+	   */
+	  createMarkupForStyles: function (styles, component) {
+	    var serialized = '';
+	    for (var styleName in styles) {
+	      if (!styles.hasOwnProperty(styleName)) {
+	        continue;
+	      }
+	      var styleValue = styles[styleName];
+	      if (process.env.NODE_ENV !== 'production') {
+	        warnValidStyle(styleName, styleValue, component);
+	      }
+	      if (styleValue != null) {
+	        serialized += processStyleName(styleName) + ':';
+	        serialized += dangerousStyleValue(styleName, styleValue, component) + ';';
+	      }
+	    }
+	    return serialized || null;
+	  },
+
+	  /**
+	   * Sets the value for multiple styles on a node.  If a value is specified as
+	   * '' (empty string), the corresponding style property will be unset.
+	   *
+	   * @param {DOMElement} node
+	   * @param {object} styles
+	   * @param {ReactDOMComponent} component
+	   */
+	  setValueForStyles: function (node, styles, component) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      ReactInstrumentation.debugTool.onHostOperation({
+	        instanceID: component._debugID,
+	        type: 'update styles',
+	        payload: styles
+	      });
+	    }
+
+	    var style = node.style;
+	    for (var styleName in styles) {
+	      if (!styles.hasOwnProperty(styleName)) {
+	        continue;
+	      }
+	      if (process.env.NODE_ENV !== 'production') {
+	        warnValidStyle(styleName, styles[styleName], component);
+	      }
+	      var styleValue = dangerousStyleValue(styleName, styles[styleName], component);
+	      if (styleName === 'float' || styleName === 'cssFloat') {
+	        styleName = styleFloatAccessor;
+	      }
+	      if (styleValue) {
+	        style[styleName] = styleValue;
+	      } else {
+	        var expansion = hasShorthandPropertyBug && CSSProperty.shorthandPropertyExpansions[styleName];
+	        if (expansion) {
+	          // Shorthand property that IE8 won't like unsetting, so unset each
+	          // component to placate it
+	          for (var individualStyleName in expansion) {
+	            style[individualStyleName] = '';
+	          }
+	        } else {
+	          style[styleName] = '';
+	        }
+	      }
+	    }
+	  }
+
+	};
+
+	module.exports = CSSPropertyOperations;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 100 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	/**
+	 * CSS properties which accept numbers but are not in units of "px".
+	 */
+
+	var isUnitlessNumber = {
+	  animationIterationCount: true,
+	  borderImageOutset: true,
+	  borderImageSlice: true,
+	  borderImageWidth: true,
+	  boxFlex: true,
+	  boxFlexGroup: true,
+	  boxOrdinalGroup: true,
+	  columnCount: true,
+	  flex: true,
+	  flexGrow: true,
+	  flexPositive: true,
+	  flexShrink: true,
+	  flexNegative: true,
+	  flexOrder: true,
+	  gridRow: true,
+	  gridColumn: true,
+	  fontWeight: true,
+	  lineClamp: true,
+	  lineHeight: true,
+	  opacity: true,
+	  order: true,
+	  orphans: true,
+	  tabSize: true,
+	  widows: true,
+	  zIndex: true,
+	  zoom: true,
+
+	  // SVG-related properties
+	  fillOpacity: true,
+	  floodOpacity: true,
+	  stopOpacity: true,
+	  strokeDasharray: true,
+	  strokeDashoffset: true,
+	  strokeMiterlimit: true,
+	  strokeOpacity: true,
+	  strokeWidth: true
+	};
+
+	/**
+	 * @param {string} prefix vendor-specific prefix, eg: Webkit
+	 * @param {string} key style name, eg: transitionDuration
+	 * @return {string} style name prefixed with `prefix`, properly camelCased, eg:
+	 * WebkitTransitionDuration
+	 */
+	function prefixKey(prefix, key) {
+	  return prefix + key.charAt(0).toUpperCase() + key.substring(1);
+	}
+
+	/**
+	 * Support style names that may come passed in prefixed by adding permutations
+	 * of vendor prefixes.
+	 */
+	var prefixes = ['Webkit', 'ms', 'Moz', 'O'];
+
+	// Using Object.keys here, or else the vanilla for-in loop makes IE8 go into an
+	// infinite loop, because it iterates over the newly added props too.
+	Object.keys(isUnitlessNumber).forEach(function (prop) {
+	  prefixes.forEach(function (prefix) {
+	    isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];
+	  });
+	});
+
+	/**
+	 * Most style properties can be unset by doing .style[prop] = '' but IE8
+	 * doesn't like doing that with shorthand properties so for the properties that
+	 * IE8 breaks on, which are listed here, we instead unset each of the
+	 * individual properties. See http://bugs.jquery.com/ticket/12385.
+	 * The 4-value 'clock' properties like margin, padding, border-width seem to
+	 * behave without any problems. Curiously, list-style works too without any
+	 * special prodding.
+	 */
+	var shorthandPropertyExpansions = {
+	  background: {
+	    backgroundAttachment: true,
+	    backgroundColor: true,
+	    backgroundImage: true,
+	    backgroundPositionX: true,
+	    backgroundPositionY: true,
+	    backgroundRepeat: true
+	  },
+	  backgroundPosition: {
+	    backgroundPositionX: true,
+	    backgroundPositionY: true
+	  },
+	  border: {
+	    borderWidth: true,
+	    borderStyle: true,
+	    borderColor: true
+	  },
+	  borderBottom: {
+	    borderBottomWidth: true,
+	    borderBottomStyle: true,
+	    borderBottomColor: true
+	  },
+	  borderLeft: {
+	    borderLeftWidth: true,
+	    borderLeftStyle: true,
+	    borderLeftColor: true
+	  },
+	  borderRight: {
+	    borderRightWidth: true,
+	    borderRightStyle: true,
+	    borderRightColor: true
+	  },
+	  borderTop: {
+	    borderTopWidth: true,
+	    borderTopStyle: true,
+	    borderTopColor: true
+	  },
+	  font: {
+	    fontStyle: true,
+	    fontVariant: true,
+	    fontWeight: true,
+	    fontSize: true,
+	    lineHeight: true,
+	    fontFamily: true
+	  },
+	  outline: {
+	    outlineWidth: true,
+	    outlineStyle: true,
+	    outlineColor: true
+	  }
+	};
+
+	var CSSProperty = {
+	  isUnitlessNumber: isUnitlessNumber,
+	  shorthandPropertyExpansions: shorthandPropertyExpansions
+	};
+
+	module.exports = CSSProperty;
+
+/***/ },
+/* 101 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * @typechecks
+	 */
+
+	'use strict';
+
+	var camelize = __webpack_require__(102);
+
+	var msPattern = /^-ms-/;
+
+	/**
+	 * Camelcases a hyphenated CSS property name, for example:
+	 *
+	 *   > camelizeStyleName('background-color')
+	 *   < "backgroundColor"
+	 *   > camelizeStyleName('-moz-transition')
+	 *   < "MozTransition"
+	 *   > camelizeStyleName('-ms-transition')
+	 *   < "msTransition"
+	 *
+	 * As Andi Smith suggests
+	 * (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix
+	 * is converted to lowercase `ms`.
+	 *
+	 * @param {string} string
+	 * @return {string}
+	 */
+	function camelizeStyleName(string) {
+	  return camelize(string.replace(msPattern, 'ms-'));
+	}
+
+	module.exports = camelizeStyleName;
+
+/***/ },
+/* 102 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * @typechecks
+	 */
+
+	var _hyphenPattern = /-(.)/g;
+
+	/**
+	 * Camelcases a hyphenated string, for example:
+	 *
+	 *   > camelize('background-color')
+	 *   < "backgroundColor"
+	 *
+	 * @param {string} string
+	 * @return {string}
+	 */
+	function camelize(string) {
+	  return string.replace(_hyphenPattern, function (_, character) {
+	    return character.toUpperCase();
+	  });
+	}
+
+	module.exports = camelize;
+
+/***/ },
+/* 103 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var CSSProperty = __webpack_require__(100);
+	var warning = __webpack_require__(47);
+
+	var isUnitlessNumber = CSSProperty.isUnitlessNumber;
+	var styleWarnings = {};
+
+	/**
+	 * Convert a value into the proper css writable value. The style name `name`
+	 * should be logical (no hyphens), as specified
+	 * in `CSSProperty.isUnitlessNumber`.
+	 *
+	 * @param {string} name CSS property name such as `topMargin`.
+	 * @param {*} value CSS property value such as `10px`.
+	 * @param {ReactDOMComponent} component
+	 * @return {string} Normalized style value with dimensions applied.
+	 */
+	function dangerousStyleValue(name, value, component) {
+	  // 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
+
+	  var isEmpty = value == null || typeof value === 'boolean' || value === '';
+	  if (isEmpty) {
+	    return '';
+	  }
+
+	  var isNonNumeric = isNaN(value);
+	  if (isNonNumeric || value === 0 || isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name]) {
+	    return '' + value; // cast to string
+	  }
+
+	  if (typeof value === 'string') {
+	    if (process.env.NODE_ENV !== 'production') {
+	      // Allow '0' to pass through without warning. 0 is already special and
+	      // doesn't require units, so we don't need to warn about it.
+	      if (component && value !== '0') {
+	        var owner = component._currentElement._owner;
+	        var ownerName = owner ? owner.getName() : null;
+	        if (ownerName && !styleWarnings[ownerName]) {
+	          styleWarnings[ownerName] = {};
+	        }
+	        var warned = false;
+	        if (ownerName) {
+	          var warnings = styleWarnings[ownerName];
+	          warned = warnings[name];
+	          if (!warned) {
+	            warnings[name] = true;
+	          }
+	        }
+	        if (!warned) {
+	          process.env.NODE_ENV !== 'production' ? warning(false, 'a `%s` tag (owner: `%s`) was passed a numeric string value ' + 'for CSS property `%s` (value: `%s`) which will be treated ' + 'as a unitless number in a future version of React.', component._currentElement.type, ownerName || 'unknown', name, value) : void 0;
+	        }
+	      }
+	    }
+	    value = value.trim();
+	  }
+	  return value + 'px';
+	}
+
+	module.exports = dangerousStyleValue;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 104 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * @typechecks
+	 */
+
+	'use strict';
+
+	var hyphenate = __webpack_require__(105);
+
+	var msPattern = /^ms-/;
+
+	/**
+	 * Hyphenates a camelcased CSS property name, for example:
+	 *
+	 *   > hyphenateStyleName('backgroundColor')
+	 *   < "background-color"
+	 *   > hyphenateStyleName('MozTransition')
+	 *   < "-moz-transition"
+	 *   > hyphenateStyleName('msTransition')
+	 *   < "-ms-transition"
+	 *
+	 * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
+	 * is converted to `-ms-`.
+	 *
+	 * @param {string} string
+	 * @return {string}
+	 */
+	function hyphenateStyleName(string) {
+	  return hyphenate(string).replace(msPattern, '-ms-');
+	}
+
+	module.exports = hyphenateStyleName;
+
+/***/ },
+/* 105 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * @typechecks
+	 */
+
+	var _uppercasePattern = /([A-Z])/g;
+
+	/**
+	 * Hyphenates a camelcased string, for example:
+	 *
+	 *   > hyphenate('backgroundColor')
+	 *   < "background-color"
+	 *
+	 * For CSS style names, use `hyphenateStyleName` instead which works properly
+	 * with all vendor prefixes, including `ms`.
+	 *
+	 * @param {string} string
+	 * @return {string}
+	 */
+	function hyphenate(string) {
+	  return string.replace(_uppercasePattern, '-$1').toLowerCase();
+	}
+
+	module.exports = hyphenate;
+
+/***/ },
+/* 106 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 * @typechecks static-only
+	 */
+
+	'use strict';
+
+	/**
+	 * Memoizes the return value of a function that accepts one string argument.
+	 */
+
+	function memoizeStringOnly(callback) {
+	  var cache = {};
+	  return function (string) {
+	    if (!cache.hasOwnProperty(string)) {
+	      cache[string] = callback.call(this, string);
+	    }
+	    return cache[string];
+	  };
+	}
+
+	module.exports = memoizeStringOnly;
+
+/***/ },
+/* 107 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var DOMProperty = __webpack_require__(36);
+	var ReactDOMComponentTree = __webpack_require__(34);
+	var ReactInstrumentation = __webpack_require__(66);
+
+	var quoteAttributeValueForBrowser = __webpack_require__(108);
+	var warning = __webpack_require__(47);
+
+	var VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + DOMProperty.ATTRIBUTE_NAME_START_CHAR + '][' + DOMProperty.ATTRIBUTE_NAME_CHAR + ']*$');
+	var illegalAttributeNameCache = {};
+	var validatedAttributeNameCache = {};
+
+	function isAttributeNameSafe(attributeName) {
+	  if (validatedAttributeNameCache.hasOwnProperty(attributeName)) {
+	    return true;
+	  }
+	  if (illegalAttributeNameCache.hasOwnProperty(attributeName)) {
+	    return false;
+	  }
+	  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
+	    validatedAttributeNameCache[attributeName] = true;
+	    return true;
+	  }
+	  illegalAttributeNameCache[attributeName] = true;
+	  process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid attribute name: `%s`', attributeName) : void 0;
+	  return false;
+	}
+
+	function shouldIgnoreValue(propertyInfo, value) {
+	  return value == null || propertyInfo.hasBooleanValue && !value || propertyInfo.hasNumericValue && isNaN(value) || propertyInfo.hasPositiveNumericValue && value < 1 || propertyInfo.hasOverloadedBooleanValue && value === false;
+	}
+
+	/**
+	 * Operations for dealing with DOM properties.
+	 */
+	var DOMPropertyOperations = {
+
+	  /**
+	   * Creates markup for the ID property.
+	   *
+	   * @param {string} id Unescaped ID.
+	   * @return {string} Markup string.
+	   */
+	  createMarkupForID: function (id) {
+	    return DOMProperty.ID_ATTRIBUTE_NAME + '=' + quoteAttributeValueForBrowser(id);
+	  },
+
+	  setAttributeForID: function (node, id) {
+	    node.setAttribute(DOMProperty.ID_ATTRIBUTE_NAME, id);
+	  },
+
+	  createMarkupForRoot: function () {
+	    return DOMProperty.ROOT_ATTRIBUTE_NAME + '=""';
+	  },
+
+	  setAttributeForRoot: function (node) {
+	    node.setAttribute(DOMProperty.ROOT_ATTRIBUTE_NAME, '');
+	  },
+
+	  /**
+	   * 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) {
+	    var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null;
+	    if (propertyInfo) {
+	      if (shouldIgnoreValue(propertyInfo, value)) {
+	        return '';
+	      }
+	      var attributeName = propertyInfo.attributeName;
+	      if (propertyInfo.hasBooleanValue || propertyInfo.hasOverloadedBooleanValue && value === true) {
+	        return attributeName + '=""';
+	      }
+	      return attributeName + '=' + quoteAttributeValueForBrowser(value);
+	    } else if (DOMProperty.isCustomAttribute(name)) {
+	      if (value == null) {
+	        return '';
+	      }
+	      return name + '=' + quoteAttributeValueForBrowser(value);
+	    }
+	    return null;
+	  },
+
+	  /**
+	   * Creates markup for a custom property.
+	   *
+	   * @param {string} name
+	   * @param {*} value
+	   * @return {string} Markup string, or empty string if the property was invalid.
+	   */
+	  createMarkupForCustomAttribute: function (name, value) {
+	    if (!isAttributeNameSafe(name) || value == null) {
+	      return '';
+	    }
+	    return name + '=' + quoteAttributeValueForBrowser(value);
+	  },
+
+	  /**
+	   * Sets the value for a property on a node.
+	   *
+	   * @param {DOMElement} node
+	   * @param {string} name
+	   * @param {*} value
+	   */
+	  setValueForProperty: function (node, name, value) {
+	    var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null;
+	    if (propertyInfo) {
+	      var mutationMethod = propertyInfo.mutationMethod;
+	      if (mutationMethod) {
+	        mutationMethod(node, value);
+	      } else if (shouldIgnoreValue(propertyInfo, value)) {
+	        this.deleteValueForProperty(node, name);
+	        return;
+	      } else if (propertyInfo.mustUseProperty) {
+	        // Contrary to `setAttribute`, object properties are properly
+	        // `toString`ed by IE8/9.
+	        node[propertyInfo.propertyName] = value;
+	      } else {
+	        var attributeName = propertyInfo.attributeName;
+	        var namespace = propertyInfo.attributeNamespace;
+	        // `setAttribute` with objects becomes only `[object]` in IE8/9,
+	        // ('' + value) makes it output the correct toString()-value.
+	        if (namespace) {
+	          node.setAttributeNS(namespace, attributeName, '' + value);
+	        } else if (propertyInfo.hasBooleanValue || propertyInfo.hasOverloadedBooleanValue && value === true) {
+	          node.setAttribute(attributeName, '');
+	        } else {
+	          node.setAttribute(attributeName, '' + value);
+	        }
+	      }
+	    } else if (DOMProperty.isCustomAttribute(name)) {
+	      DOMPropertyOperations.setValueForAttribute(node, name, value);
+	      return;
+	    }
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      var payload = {};
+	      payload[name] = value;
+	      ReactInstrumentation.debugTool.onHostOperation({
+	        instanceID: ReactDOMComponentTree.getInstanceFromNode(node)._debugID,
+	        type: 'update attribute',
+	        payload: payload
+	      });
+	    }
+	  },
+
+	  setValueForAttribute: function (node, name, value) {
+	    if (!isAttributeNameSafe(name)) {
+	      return;
+	    }
+	    if (value == null) {
+	      node.removeAttribute(name);
+	    } else {
+	      node.setAttribute(name, '' + value);
+	    }
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      var payload = {};
+	      payload[name] = value;
+	      ReactInstrumentation.debugTool.onHostOperation({
+	        instanceID: ReactDOMComponentTree.getInstanceFromNode(node)._debugID,
+	        type: 'update attribute',
+	        payload: payload
+	      });
+	    }
+	  },
+
+	  /**
+	   * Deletes an attributes from a node.
+	   *
+	   * @param {DOMElement} node
+	   * @param {string} name
+	   */
+	  deleteValueForAttribute: function (node, name) {
+	    node.removeAttribute(name);
+	    if (process.env.NODE_ENV !== 'production') {
+	      ReactInstrumentation.debugTool.onHostOperation({
+	        instanceID: ReactDOMComponentTree.getInstanceFromNode(node)._debugID,
+	        type: 'remove attribute',
+	        payload: name
+	      });
+	    }
+	  },
+
+	  /**
+	   * Deletes the value for a property on a node.
+	   *
+	   * @param {DOMElement} node
+	   * @param {string} name
+	   */
+	  deleteValueForProperty: function (node, name) {
+	    var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null;
+	    if (propertyInfo) {
+	      var mutationMethod = propertyInfo.mutationMethod;
+	      if (mutationMethod) {
+	        mutationMethod(node, undefined);
+	      } else if (propertyInfo.mustUseProperty) {
+	        var propName = propertyInfo.propertyName;
+	        if (propertyInfo.hasBooleanValue) {
+	          node[propName] = false;
+	        } else {
+	          node[propName] = '';
+	        }
+	      } else {
+	        node.removeAttribute(propertyInfo.attributeName);
+	      }
+	    } else if (DOMProperty.isCustomAttribute(name)) {
+	      node.removeAttribute(name);
+	    }
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      ReactInstrumentation.debugTool.onHostOperation({
+	        instanceID: ReactDOMComponentTree.getInstanceFromNode(node)._debugID,
+	        type: 'remove attribute',
+	        payload: name
+	      });
+	    }
+	  }
+
+	};
+
+	module.exports = DOMPropertyOperations;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 108 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var escapeTextContentForBrowser = __webpack_require__(90);
+
+	/**
+	 * Escapes attribute value to prevent scripting attacks.
+	 *
+	 * @param {*} value Value to escape.
+	 * @return {string} An escaped string.
+	 */
+	function quoteAttributeValueForBrowser(value) {
+	  return '"' + escapeTextContentForBrowser(value) + '"';
+	}
+
+	module.exports = quoteAttributeValueForBrowser;
+
+/***/ },
+/* 109 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _assign = __webpack_require__(53);
+
+	var EventPluginRegistry = __webpack_require__(44);
+	var ReactEventEmitterMixin = __webpack_require__(110);
+	var ViewportMetrics = __webpack_require__(80);
+
+	var getVendorPrefixedEventName = __webpack_require__(111);
+	var isEventSupported = __webpack_require__(74);
+
+	/**
+	 * Summary of `ReactBrowserEventEmitter` event handling:
+	 *
+	 *  - Top-level delegation is used to trap most native browser events. This
+	 *    may only occur in the main thread and is the responsibility of
+	 *    ReactEventListener, which is injected and can therefore support pluggable
+	 *    event sources. This is the only work that occurs in the main thread.
+	 *
+	 *  - We normalize and de-duplicate events to account for browser quirks. This
+	 *    may be done in the worker thread.
+	 *
+	 *  - Forward these native events (with the associated top-level type used to
+	 *    trap it) to `EventPluginHub`, which in turn will ask plugins if they want
+	 *    to extract any synthetic events.
+	 *
+	 *  - The `EventPluginHub` will then process each event by annotating them with
+	 *    "dispatches", a sequence of listeners and IDs that care about that event.
+	 *
+	 *  - The `EventPluginHub` then dispatches the events.
+	 *
+	 * Overview of React and the event system:
+	 *
+	 * +------------+    .
+	 * |    DOM     |    .
+	 * +------------+    .
+	 *       |           .
+	 *       v           .
+	 * +------------+    .
+	 * | ReactEvent |    .
+	 * |  Listener  |    .
+	 * +------------+    .                         +-----------+
+	 *       |           .               +--------+|SimpleEvent|
+	 *       |           .               |         |Plugin     |
+	 * +-----|------+    .               v         +-----------+
+	 * |     |      |    .    +--------------+                    +------------+
+	 * |     +-----------.--->|EventPluginHub|                    |    Event   |
+	 * |            |    .    |              |     +-----------+  | Propagators|
+	 * | ReactEvent |    .    |              |     |TapEvent   |  |------------|
+	 * |  Emitter   |    .    |              |<---+|Plugin     |  |other plugin|
+	 * |            |    .    |              |     +-----------+  |  utilities |
+	 * |     +-----------.--->|              |                    +------------+
+	 * |     |      |    .    +--------------+
+	 * +-----|------+    .                ^        +-----------+
+	 *       |           .                |        |Enter/Leave|
+	 *       +           .                +-------+|Plugin     |
+	 * +-------------+   .                         +-----------+
+	 * | application |   .
+	 * |-------------|   .
+	 * |             |   .
+	 * |             |   .
+	 * +-------------+   .
+	 *                   .
+	 *    React Core     .  General Purpose Event Plugin System
+	 */
+
+	var hasEventPageXY;
+	var alreadyListeningTo = {};
+	var isMonitoringScrollValue = false;
+	var reactTopListenersCounter = 0;
+
+	// For events like 'submit' which don't consistently bubble (which we trap at a
+	// lower node than `document`), binding at `document` would cause duplicate
+	// events so we don't include them here
+	var topEventMapping = {
+	  topAbort: 'abort',
+	  topAnimationEnd: getVendorPrefixedEventName('animationend') || 'animationend',
+	  topAnimationIteration: getVendorPrefixedEventName('animationiteration') || 'animationiteration',
+	  topAnimationStart: getVendorPrefixedEventName('animationstart') || 'animationstart',
+	  topBlur: 'blur',
+	  topCanPlay: 'canplay',
+	  topCanPlayThrough: 'canplaythrough',
+	  topChange: 'change',
+	  topClick: 'click',
+	  topCompositionEnd: 'compositionend',
+	  topCompositionStart: 'compositionstart',
+	  topCompositionUpdate: 'compositionupdate',
+	  topContextMenu: 'contextmenu',
+	  topCopy: 'copy',
+	  topCut: 'cut',
+	  topDoubleClick: 'dblclick',
+	  topDrag: 'drag',
+	  topDragEnd: 'dragend',
+	  topDragEnter: 'dragenter',
+	  topDragExit: 'dragexit',
+	  topDragLeave: 'dragleave',
+	  topDragOver: 'dragover',
+	  topDragStart: 'dragstart',
+	  topDrop: 'drop',
+	  topDurationChange: 'durationchange',
+	  topEmptied: 'emptied',
+	  topEncrypted: 'encrypted',
+	  topEnded: 'ended',
+	  topError: 'error',
+	  topFocus: 'focus',
+	  topInput: 'input',
+	  topKeyDown: 'keydown',
+	  topKeyPress: 'keypress',
+	  topKeyUp: 'keyup',
+	  topLoadedData: 'loadeddata',
+	  topLoadedMetadata: 'loadedmetadata',
+	  topLoadStart: 'loadstart',
+	  topMouseDown: 'mousedown',
+	  topMouseMove: 'mousemove',
+	  topMouseOut: 'mouseout',
+	  topMouseOver: 'mouseover',
+	  topMouseUp: 'mouseup',
+	  topPaste: 'paste',
+	  topPause: 'pause',
+	  topPlay: 'play',
+	  topPlaying: 'playing',
+	  topProgress: 'progress',
+	  topRateChange: 'ratechange',
+	  topScroll: 'scroll',
+	  topSeeked: 'seeked',
+	  topSeeking: 'seeking',
+	  topSelectionChange: 'selectionchange',
+	  topStalled: 'stalled',
+	  topSuspend: 'suspend',
+	  topTextInput: 'textInput',
+	  topTimeUpdate: 'timeupdate',
+	  topTouchCancel: 'touchcancel',
+	  topTouchEnd: 'touchend',
+	  topTouchMove: 'touchmove',
+	  topTouchStart: 'touchstart',
+	  topTransitionEnd: getVendorPrefixedEventName('transitionend') || 'transitionend',
+	  topVolumeChange: 'volumechange',
+	  topWaiting: 'waiting',
+	  topWheel: 'wheel'
+	};
+
+	/**
+	 * To ensure no conflicts with other potential React instances on the page
+	 */
+	var topListenersIDKey = '_reactListenersID' + String(Math.random()).slice(2);
+
+	function getListeningForDocument(mountAt) {
+	  // In IE8, `mountAt` is a host object and doesn't have `hasOwnProperty`
+	  // directly.
+	  if (!Object.prototype.hasOwnProperty.call(mountAt, topListenersIDKey)) {
+	    mountAt[topListenersIDKey] = reactTopListenersCounter++;
+	    alreadyListeningTo[mountAt[topListenersIDKey]] = {};
+	  }
+	  return alreadyListeningTo[mountAt[topListenersIDKey]];
+	}
+
+	/**
+	 * `ReactBrowserEventEmitter` is used to attach top-level event listeners. For
+	 * example:
+	 *
+	 *   EventPluginHub.putListener('myID', 'onClick', myFunction);
+	 *
+	 * This would allocate a "registration" of `('onClick', myFunction)` on 'myID'.
+	 *
+	 * @internal
+	 */
+	var ReactBrowserEventEmitter = _assign({}, ReactEventEmitterMixin, {
+
+	  /**
+	   * Injectable event backend
+	   */
+	  ReactEventListener: null,
+
+	  injection: {
+	    /**
+	     * @param {object} ReactEventListener
+	     */
+	    injectReactEventListener: function (ReactEventListener) {
+	      ReactEventListener.setHandleTopLevel(ReactBrowserEventEmitter.handleTopLevel);
+	      ReactBrowserEventEmitter.ReactEventListener = ReactEventListener;
+	    }
+	  },
+
+	  /**
+	   * Sets whether or not any created callbacks should be enabled.
+	   *
+	   * @param {boolean} enabled True if callbacks should be enabled.
+	   */
+	  setEnabled: function (enabled) {
+	    if (ReactBrowserEventEmitter.ReactEventListener) {
+	      ReactBrowserEventEmitter.ReactEventListener.setEnabled(enabled);
+	    }
+	  },
+
+	  /**
+	   * @return {boolean} True if callbacks are enabled.
+	   */
+	  isEnabled: function () {
+	    return !!(ReactBrowserEventEmitter.ReactEventListener && ReactBrowserEventEmitter.ReactEventListener.isEnabled());
+	  },
+
+	  /**
+	   * 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.
+	   *
+	   * @param {string} registrationName Name of listener (e.g. `onClick`).
+	   * @param {object} contentDocumentHandle Document which owns the container
+	   */
+	  listenTo: function (registrationName, contentDocumentHandle) {
+	    var mountAt = contentDocumentHandle;
+	    var isListening = getListeningForDocument(mountAt);
+	    var dependencies = EventPluginRegistry.registrationNameDependencies[registrationName];
+
+	    for (var i = 0; i < dependencies.length; i++) {
+	      var dependency = dependencies[i];
+	      if (!(isListening.hasOwnProperty(dependency) && isListening[dependency])) {
+	        if (dependency === 'topWheel') {
+	          if (isEventSupported('wheel')) {
+	            ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topWheel', 'wheel', mountAt);
+	          } else if (isEventSupported('mousewheel')) {
+	            ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topWheel', 'mousewheel', mountAt);
+	          } else {
+	            // Firefox needs to capture a different mouse scroll event.
+	            // @see http://www.quirksmode.org/dom/events/tests/scroll.html
+	            ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topWheel', 'DOMMouseScroll', mountAt);
+	          }
+	        } else if (dependency === 'topScroll') {
+
+	          if (isEventSupported('scroll', true)) {
+	            ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent('topScroll', 'scroll', mountAt);
+	          } else {
+	            ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topScroll', 'scroll', ReactBrowserEventEmitter.ReactEventListener.WINDOW_HANDLE);
+	          }
+	        } else if (dependency === 'topFocus' || dependency === 'topBlur') {
+
+	          if (isEventSupported('focus', true)) {
+	            ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent('topFocus', 'focus', mountAt);
+	            ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent('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
+	            ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topFocus', 'focusin', mountAt);
+	            ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topBlur', 'focusout', mountAt);
+	          }
+
+	          // to make sure blur and focus event listeners are only attached once
+	          isListening.topBlur = true;
+	          isListening.topFocus = true;
+	        } else if (topEventMapping.hasOwnProperty(dependency)) {
+	          ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(dependency, topEventMapping[dependency], mountAt);
+	        }
+
+	        isListening[dependency] = true;
+	      }
+	    }
+	  },
+
+	  trapBubbledEvent: function (topLevelType, handlerBaseName, handle) {
+	    return ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelType, handlerBaseName, handle);
+	  },
+
+	  trapCapturedEvent: function (topLevelType, handlerBaseName, handle) {
+	    return ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(topLevelType, handlerBaseName, handle);
+	  },
+
+	  /**
+	   * Protect against document.createEvent() returning null
+	   * Some popup blocker extensions appear to do this:
+	   * https://github.com/facebook/react/issues/6887
+	   */
+	  supportsEventPageXY: function () {
+	    if (!document.createEvent) {
+	      return false;
+	    }
+	    var ev = document.createEvent('MouseEvent');
+	    return ev != null && 'pageX' in ev;
+	  },
+
+	  /**
+	   * Listens to window scroll and resize events. We cache scroll values so that
+	   * application code can access them without triggering reflows.
+	   *
+	   * ViewportMetrics is only used by SyntheticMouse/TouchEvent and only when
+	   * pageX/pageY isn't supported (legacy browsers).
+	   *
+	   * NOTE: Scroll events do not bubble.
+	   *
+	   * @see http://www.quirksmode.org/dom/events/scroll.html
+	   */
+	  ensureScrollValueMonitoring: function () {
+	    if (hasEventPageXY === undefined) {
+	      hasEventPageXY = ReactBrowserEventEmitter.supportsEventPageXY();
+	    }
+	    if (!hasEventPageXY && !isMonitoringScrollValue) {
+	      var refresh = ViewportMetrics.refreshScrollValues;
+	      ReactBrowserEventEmitter.ReactEventListener.monitorScrollValue(refresh);
+	      isMonitoringScrollValue = true;
+	    }
+	  }
+
+	});
+
+	module.exports = ReactBrowserEventEmitter;
+
+/***/ },
+/* 110 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var EventPluginHub = __webpack_require__(43);
+
+	function runEventQueueInBatch(events) {
+	  EventPluginHub.enqueueEvents(events);
+	  EventPluginHub.processEventQueue(false);
+	}
+
+	var ReactEventEmitterMixin = {
+
+	  /**
+	   * Streams a fired top-level event to `EventPluginHub` where plugins have the
+	   * opportunity to create `ReactEvent`s to be dispatched.
+	   */
+	  handleTopLevel: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+	    var events = EventPluginHub.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
+	    runEventQueueInBatch(events);
+	  }
+	};
+
+	module.exports = ReactEventEmitterMixin;
+
+/***/ },
+/* 111 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ExecutionEnvironment = __webpack_require__(51);
+
+	/**
+	 * Generate a mapping of standard vendor prefixes using the defined style property and event name.
+	 *
+	 * @param {string} styleProp
+	 * @param {string} eventName
+	 * @returns {object}
+	 */
+	function makePrefixMap(styleProp, eventName) {
+	  var prefixes = {};
+
+	  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
+	  prefixes['Webkit' + styleProp] = 'webkit' + eventName;
+	  prefixes['Moz' + styleProp] = 'moz' + eventName;
+	  prefixes['ms' + styleProp] = 'MS' + eventName;
+	  prefixes['O' + styleProp] = 'o' + eventName.toLowerCase();
+
+	  return prefixes;
+	}
+
+	/**
+	 * A list of event names to a configurable list of vendor prefixes.
+	 */
+	var vendorPrefixes = {
+	  animationend: makePrefixMap('Animation', 'AnimationEnd'),
+	  animationiteration: makePrefixMap('Animation', 'AnimationIteration'),
+	  animationstart: makePrefixMap('Animation', 'AnimationStart'),
+	  transitionend: makePrefixMap('Transition', 'TransitionEnd')
+	};
+
+	/**
+	 * Event names that have already been detected and prefixed (if applicable).
+	 */
+	var prefixedEventNames = {};
+
+	/**
+	 * Element to check for prefixes on.
+	 */
+	var style = {};
+
+	/**
+	 * Bootstrap if a DOM exists.
+	 */
+	if (ExecutionEnvironment.canUseDOM) {
+	  style = document.createElement('div').style;
+
+	  // On some platforms, in particular some releases of Android 4.x,
+	  // the un-prefixed "animation" and "transition" properties are defined on the
+	  // style object but the events that fire will still be prefixed, so we need
+	  // to check if the un-prefixed events are usable, and if not remove them from the map.
+	  if (!('AnimationEvent' in window)) {
+	    delete vendorPrefixes.animationend.animation;
+	    delete vendorPrefixes.animationiteration.animation;
+	    delete vendorPrefixes.animationstart.animation;
+	  }
+
+	  // Same as above
+	  if (!('TransitionEvent' in window)) {
+	    delete vendorPrefixes.transitionend.transition;
+	  }
+	}
+
+	/**
+	 * Attempts to determine the correct vendor prefixed event name.
+	 *
+	 * @param {string} eventName
+	 * @returns {string}
+	 */
+	function getVendorPrefixedEventName(eventName) {
+	  if (prefixedEventNames[eventName]) {
+	    return prefixedEventNames[eventName];
+	  } else if (!vendorPrefixes[eventName]) {
+	    return eventName;
+	  }
+
+	  var prefixMap = vendorPrefixes[eventName];
+
+	  for (var styleProp in prefixMap) {
+	    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
+	      return prefixedEventNames[eventName] = prefixMap[styleProp];
+	    }
+	  }
+
+	  return '';
+	}
+
+	module.exports = getVendorPrefixedEventName;
+
+/***/ },
+/* 112 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35),
+	    _assign = __webpack_require__(53);
+
+	var DOMPropertyOperations = __webpack_require__(107);
+	var LinkedValueUtils = __webpack_require__(113);
+	var ReactDOMComponentTree = __webpack_require__(34);
+	var ReactUpdates = __webpack_require__(60);
+
+	var invariant = __webpack_require__(37);
+	var warning = __webpack_require__(47);
+
+	var didWarnValueLink = false;
+	var didWarnCheckedLink = false;
+	var didWarnValueDefaultValue = false;
+	var didWarnCheckedDefaultChecked = false;
+	var didWarnControlledToUncontrolled = false;
+	var didWarnUncontrolledToControlled = false;
+
+	function forceUpdateIfMounted() {
+	  if (this._rootNodeID) {
+	    // DOM component is still mounted; update
+	    ReactDOMInput.updateWrapper(this);
+	  }
+	}
+
+	function isControlled(props) {
+	  var usesChecked = props.type === 'checkbox' || props.type === 'radio';
+	  return usesChecked ? props.checked != null : props.value != null;
+	}
+
+	/**
+	 * Implements an <input> host 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 = {
+	  getHostProps: function (inst, props) {
+	    var value = LinkedValueUtils.getValue(props);
+	    var checked = LinkedValueUtils.getChecked(props);
+
+	    var hostProps = _assign({
+	      // Make sure we set .type before any other properties (setting .value
+	      // before .type means .value is lost in IE11 and below)
+	      type: undefined,
+	      // Make sure we set .step before .value (setting .value before .step
+	      // means .value is rounded on mount, based upon step precision)
+	      step: undefined,
+	      // Make sure we set .min & .max before .value (to ensure proper order
+	      // in corner cases such as min or max deriving from value, e.g. Issue #7170)
+	      min: undefined,
+	      max: undefined
+	    }, props, {
+	      defaultChecked: undefined,
+	      defaultValue: undefined,
+	      value: value != null ? value : inst._wrapperState.initialValue,
+	      checked: checked != null ? checked : inst._wrapperState.initialChecked,
+	      onChange: inst._wrapperState.onChange
+	    });
+
+	    return hostProps;
+	  },
+
+	  mountWrapper: function (inst, props) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      LinkedValueUtils.checkPropTypes('input', props, inst._currentElement._owner);
+
+	      var owner = inst._currentElement._owner;
+
+	      if (props.valueLink !== undefined && !didWarnValueLink) {
+	        process.env.NODE_ENV !== 'production' ? warning(false, '`valueLink` prop on `input` is deprecated; set `value` and `onChange` instead.') : void 0;
+	        didWarnValueLink = true;
+	      }
+	      if (props.checkedLink !== undefined && !didWarnCheckedLink) {
+	        process.env.NODE_ENV !== 'production' ? warning(false, '`checkedLink` prop on `input` is deprecated; set `value` and `onChange` instead.') : void 0;
+	        didWarnCheckedLink = true;
+	      }
+	      if (props.checked !== undefined && props.defaultChecked !== undefined && !didWarnCheckedDefaultChecked) {
+	        process.env.NODE_ENV !== 'production' ? warning(false, '%s contains an input of type %s with both checked and defaultChecked props. ' + 'Input elements must be either controlled or uncontrolled ' + '(specify either the checked prop, or the defaultChecked prop, but not ' + 'both). Decide between using a controlled or uncontrolled input ' + 'element and remove one of these props. More info: ' + 'https://fb.me/react-controlled-components', owner && owner.getName() || 'A component', props.type) : void 0;
+	        didWarnCheckedDefaultChecked = true;
+	      }
+	      if (props.value !== undefined && props.defaultValue !== undefined && !didWarnValueDefaultValue) {
+	        process.env.NODE_ENV !== 'production' ? warning(false, '%s contains an input of type %s with both value and defaultValue props. ' + 'Input elements must be either controlled or uncontrolled ' + '(specify either the value prop, or the defaultValue prop, but not ' + 'both). Decide between using a controlled or uncontrolled input ' + 'element and remove one of these props. More info: ' + 'https://fb.me/react-controlled-components', owner && owner.getName() || 'A component', props.type) : void 0;
+	        didWarnValueDefaultValue = true;
+	      }
+	    }
+
+	    var defaultValue = props.defaultValue;
+	    inst._wrapperState = {
+	      initialChecked: props.checked != null ? props.checked : props.defaultChecked,
+	      initialValue: props.value != null ? props.value : defaultValue,
+	      listeners: null,
+	      onChange: _handleChange.bind(inst)
+	    };
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      inst._wrapperState.controlled = isControlled(props);
+	    }
+	  },
+
+	  updateWrapper: function (inst) {
+	    var props = inst._currentElement.props;
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      var controlled = isControlled(props);
+	      var owner = inst._currentElement._owner;
+
+	      if (!inst._wrapperState.controlled && controlled && !didWarnUncontrolledToControlled) {
+	        process.env.NODE_ENV !== 'production' ? warning(false, '%s is changing an uncontrolled input of type %s to be controlled. ' + 'Input elements should not switch from uncontrolled to controlled (or vice versa). ' + 'Decide between using a controlled or uncontrolled input ' + 'element for the lifetime of the component. More info: https://fb.me/react-controlled-components', owner && owner.getName() || 'A component', props.type) : void 0;
+	        didWarnUncontrolledToControlled = true;
+	      }
+	      if (inst._wrapperState.controlled && !controlled && !didWarnControlledToUncontrolled) {
+	        process.env.NODE_ENV !== 'production' ? warning(false, '%s is changing a controlled input of type %s to be uncontrolled. ' + 'Input elements should not switch from controlled to uncontrolled (or vice versa). ' + 'Decide between using a controlled or uncontrolled input ' + 'element for the lifetime of the component. More info: https://fb.me/react-controlled-components', owner && owner.getName() || 'A component', props.type) : void 0;
+	        didWarnControlledToUncontrolled = true;
+	      }
+	    }
+
+	    // TODO: Shouldn't this be getChecked(props)?
+	    var checked = props.checked;
+	    if (checked != null) {
+	      DOMPropertyOperations.setValueForProperty(ReactDOMComponentTree.getNodeFromInstance(inst), 'checked', checked || false);
+	    }
+
+	    var node = ReactDOMComponentTree.getNodeFromInstance(inst);
+	    var value = LinkedValueUtils.getValue(props);
+	    if (value != null) {
+
+	      // Cast `value` to a string to ensure the value is set correctly. While
+	      // browsers typically do this as necessary, jsdom doesn't.
+	      var newValue = '' + value;
+
+	      // To avoid side effects (such as losing text selection), only set value if changed
+	      if (newValue !== node.value) {
+	        node.value = newValue;
+	      }
+	    } else {
+	      if (props.value == null && props.defaultValue != null) {
+	        node.defaultValue = '' + props.defaultValue;
+	      }
+	      if (props.checked == null && props.defaultChecked != null) {
+	        node.defaultChecked = !!props.defaultChecked;
+	      }
+	    }
+	  },
+
+	  postMountWrapper: function (inst) {
+	    var props = inst._currentElement.props;
+
+	    // This is in postMount because we need access to the DOM node, which is not
+	    // available until after the component has mounted.
+	    var node = ReactDOMComponentTree.getNodeFromInstance(inst);
+
+	    // Detach value from defaultValue. We won't do anything if we're working on
+	    // submit or reset inputs as those values & defaultValues are linked. They
+	    // are not resetable nodes so this operation doesn't matter and actually
+	    // removes browser-default values (eg "Submit Query") when no value is
+	    // provided.
+
+	    switch (props.type) {
+	      case 'submit':
+	      case 'reset':
+	        break;
+	      case 'color':
+	      case 'date':
+	      case 'datetime':
+	      case 'datetime-local':
+	      case 'month':
+	      case 'time':
+	      case 'week':
+	        // This fixes the no-show issue on iOS Safari and Android Chrome:
+	        // https://github.com/facebook/react/issues/7233
+	        node.value = '';
+	        node.value = node.defaultValue;
+	        break;
+	      default:
+	        node.value = node.value;
+	        break;
+	    }
+
+	    // Normally, we'd just do `node.checked = node.checked` upon initial mount, less this bug
+	    // this is needed to work around a chrome bug where setting defaultChecked
+	    // will sometimes influence the value of checked (even after detachment).
+	    // Reference: https://bugs.chromium.org/p/chromium/issues/detail?id=608416
+	    // We need to temporarily unset name to avoid disrupting radio button groups.
+	    var name = node.name;
+	    if (name !== '') {
+	      node.name = '';
+	    }
+	    node.defaultChecked = !node.defaultChecked;
+	    node.defaultChecked = !node.defaultChecked;
+	    if (name !== '') {
+	      node.name = name;
+	    }
+	  }
+	};
+
+	function _handleChange(event) {
+	  var props = this._currentElement.props;
+
+	  var returnValue = LinkedValueUtils.executeOnChange(props, event);
+
+	  // Here we use asap to wait until all updates have propagated, which
+	  // is important when using controlled components within layers:
+	  // https://github.com/facebook/react/issues/1698
+	  ReactUpdates.asap(forceUpdateIfMounted, this);
+
+	  var name = props.name;
+	  if (props.type === 'radio' && name != null) {
+	    var rootNode = ReactDOMComponentTree.getNodeFromInstance(this);
+	    var queryRoot = rootNode;
+
+	    while (queryRoot.parentNode) {
+	      queryRoot = queryRoot.parentNode;
+	    }
+
+	    // If `rootNode.form` was non-null, then we could try `form.elements`,
+	    // but that sometimes behaves strangely in IE8. We could also try using
+	    // `form.getElementsByName`, but that will only return direct children
+	    // and won't include inputs that use the HTML5 `form=` attribute. Since
+	    // the input might not even be in a form, let's just use the global
+	    // `querySelectorAll` to ensure we don't miss anything.
+	    var group = queryRoot.querySelectorAll('input[name=' + JSON.stringify('' + name) + '][type="radio"]');
+
+	    for (var i = 0; i < group.length; i++) {
+	      var otherNode = group[i];
+	      if (otherNode === rootNode || otherNode.form !== rootNode.form) {
+	        continue;
+	      }
+	      // This will throw if radio buttons rendered by different copies of React
+	      // and the same name are rendered into the same form (same as #1939).
+	      // That's probably okay; we don't support it just as we don't support
+	      // mixing React radio buttons with non-React ones.
+	      var otherInstance = ReactDOMComponentTree.getInstanceFromNode(otherNode);
+	      !otherInstance ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactDOMInput: Mixing React and non-React radio inputs with the same `name` is not supported.') : _prodInvariant('90') : void 0;
+	      // If this is a controlled radio button group, forcing the input that
+	      // was previously checked to update will cause it to be come re-checked
+	      // as appropriate.
+	      ReactUpdates.asap(forceUpdateIfMounted, otherInstance);
+	    }
+	  }
+
+	  return returnValue;
+	}
+
+	module.exports = ReactDOMInput;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 113 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var React = __webpack_require__(2);
+	var ReactPropTypesSecret = __webpack_require__(114);
+
+	var invariant = __webpack_require__(37);
+	var warning = __webpack_require__(47);
+
+	var hasReadOnlyValue = {
+	  'button': true,
+	  'checkbox': true,
+	  'image': true,
+	  'hidden': true,
+	  'radio': true,
+	  'reset': true,
+	  'submit': true
+	};
+
+	function _assertSingleLink(inputProps) {
+	  !(inputProps.checkedLink == null || inputProps.valueLink == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Cannot provide a checkedLink and a valueLink. If you want to use checkedLink, you probably don\'t want to use valueLink and vice versa.') : _prodInvariant('87') : void 0;
+	}
+	function _assertValueLink(inputProps) {
+	  _assertSingleLink(inputProps);
+	  !(inputProps.value == null && inputProps.onChange == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Cannot provide a valueLink and a value or onChange event. If you want to use value or onChange, you probably don\'t want to use valueLink.') : _prodInvariant('88') : void 0;
+	}
+
+	function _assertCheckedLink(inputProps) {
+	  _assertSingleLink(inputProps);
+	  !(inputProps.checked == null && inputProps.onChange == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Cannot provide a checkedLink and a checked property or onChange event. If you want to use checked or onChange, you probably don\'t want to use checkedLink') : _prodInvariant('89') : void 0;
+	}
+
+	var propTypes = {
+	  value: function (props, propName, componentName) {
+	    if (!props[propName] || hasReadOnlyValue[props.type] || props.onChange || props.readOnly || props.disabled) {
+	      return null;
+	    }
+	    return new Error('You provided a `value` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultValue`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+	  },
+	  checked: function (props, propName, componentName) {
+	    if (!props[propName] || props.onChange || props.readOnly || props.disabled) {
+	      return null;
+	    }
+	    return new Error('You provided a `checked` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultChecked`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
+	  },
+	  onChange: React.PropTypes.func
+	};
+
+	var loggedTypeFailures = {};
+	function getDeclarationErrorAddendum(owner) {
+	  if (owner) {
+	    var name = owner.getName();
+	    if (name) {
+	      return ' Check the render method of `' + name + '`.';
+	    }
+	  }
+	  return '';
+	}
+
+	/**
+	 * Provide a linked `value` attribute for controlled forms. You should not use
+	 * this outside of the ReactDOM controlled form components.
+	 */
+	var LinkedValueUtils = {
+	  checkPropTypes: function (tagName, props, owner) {
+	    for (var propName in propTypes) {
+	      if (propTypes.hasOwnProperty(propName)) {
+	        var error = propTypes[propName](props, propName, tagName, 'prop', null, ReactPropTypesSecret);
+	      }
+	      if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+	        // Only monitor this failure once because there tends to be a lot of the
+	        // same error.
+	        loggedTypeFailures[error.message] = true;
+
+	        var addendum = getDeclarationErrorAddendum(owner);
+	        process.env.NODE_ENV !== 'production' ? warning(false, 'Failed form propType: %s%s', error.message, addendum) : void 0;
+	      }
+	    }
+	  },
+
+	  /**
+	   * @param {object} inputProps Props for form component
+	   * @return {*} current value of the input either from value prop or link.
+	   */
+	  getValue: function (inputProps) {
+	    if (inputProps.valueLink) {
+	      _assertValueLink(inputProps);
+	      return inputProps.valueLink.value;
+	    }
+	    return inputProps.value;
+	  },
+
+	  /**
+	   * @param {object} inputProps Props for form component
+	   * @return {*} current checked status of the input either from checked prop
+	   *             or link.
+	   */
+	  getChecked: function (inputProps) {
+	    if (inputProps.checkedLink) {
+	      _assertCheckedLink(inputProps);
+	      return inputProps.checkedLink.value;
+	    }
+	    return inputProps.checked;
+	  },
+
+	  /**
+	   * @param {object} inputProps Props for form component
+	   * @param {SyntheticEvent} event change event to handle
+	   */
+	  executeOnChange: function (inputProps, event) {
+	    if (inputProps.valueLink) {
+	      _assertValueLink(inputProps);
+	      return inputProps.valueLink.requestChange(event.target.value);
+	    } else if (inputProps.checkedLink) {
+	      _assertCheckedLink(inputProps);
+	      return inputProps.checkedLink.requestChange(event.target.checked);
+	    } else if (inputProps.onChange) {
+	      return inputProps.onChange.call(undefined, event);
+	    }
+	  }
+	};
+
+	module.exports = LinkedValueUtils;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 114 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+
+	module.exports = ReactPropTypesSecret;
+
+/***/ },
+/* 115 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _assign = __webpack_require__(53);
+
+	var React = __webpack_require__(2);
+	var ReactDOMComponentTree = __webpack_require__(34);
+	var ReactDOMSelect = __webpack_require__(116);
+
+	var warning = __webpack_require__(47);
+	var didWarnInvalidOptionChildren = false;
+
+	function flattenChildren(children) {
+	  var content = '';
+
+	  // Flatten children and warn if they aren't strings or numbers;
+	  // invalid types are ignored.
+	  React.Children.forEach(children, function (child) {
+	    if (child == null) {
+	      return;
+	    }
+	    if (typeof child === 'string' || typeof child === 'number') {
+	      content += child;
+	    } else if (!didWarnInvalidOptionChildren) {
+	      didWarnInvalidOptionChildren = true;
+	      process.env.NODE_ENV !== 'production' ? warning(false, 'Only strings and numbers are supported as <option> children.') : void 0;
+	    }
+	  });
+
+	  return content;
+	}
+
+	/**
+	 * Implements an <option> host component that warns when `selected` is set.
+	 */
+	var ReactDOMOption = {
+	  mountWrapper: function (inst, props, hostParent) {
+	    // TODO (yungsters): Remove support for `selected` in <option>.
+	    if (process.env.NODE_ENV !== 'production') {
+	      process.env.NODE_ENV !== 'production' ? warning(props.selected == null, 'Use the `defaultValue` or `value` props on <select> instead of ' + 'setting `selected` on <option>.') : void 0;
+	    }
+
+	    // Look up whether this option is 'selected'
+	    var selectValue = null;
+	    if (hostParent != null) {
+	      var selectParent = hostParent;
+
+	      if (selectParent._tag === 'optgroup') {
+	        selectParent = selectParent._hostParent;
+	      }
+
+	      if (selectParent != null && selectParent._tag === 'select') {
+	        selectValue = ReactDOMSelect.getSelectValueContext(selectParent);
+	      }
+	    }
+
+	    // If the value is null (e.g., no specified value or after initial mount)
+	    // or missing (e.g., for <datalist>), we don't change props.selected
+	    var selected = null;
+	    if (selectValue != null) {
+	      var value;
+	      if (props.value != null) {
+	        value = props.value + '';
+	      } else {
+	        value = flattenChildren(props.children);
+	      }
+	      selected = false;
+	      if (Array.isArray(selectValue)) {
+	        // multiple
+	        for (var i = 0; i < selectValue.length; i++) {
+	          if ('' + selectValue[i] === value) {
+	            selected = true;
+	            break;
+	          }
+	        }
+	      } else {
+	        selected = '' + selectValue === value;
+	      }
+	    }
+
+	    inst._wrapperState = { selected: selected };
+	  },
+
+	  postMountWrapper: function (inst) {
+	    // value="" should make a value attribute (#6219)
+	    var props = inst._currentElement.props;
+	    if (props.value != null) {
+	      var node = ReactDOMComponentTree.getNodeFromInstance(inst);
+	      node.setAttribute('value', props.value);
+	    }
+	  },
+
+	  getHostProps: function (inst, props) {
+	    var hostProps = _assign({ selected: undefined, children: undefined }, props);
+
+	    // Read state only from initial mount because <select> updates value
+	    // manually; we need the initial state only for server rendering
+	    if (inst._wrapperState.selected != null) {
+	      hostProps.selected = inst._wrapperState.selected;
+	    }
+
+	    var content = flattenChildren(props.children);
+
+	    if (content) {
+	      hostProps.children = content;
+	    }
+
+	    return hostProps;
+	  }
+
+	};
+
+	module.exports = ReactDOMOption;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 116 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _assign = __webpack_require__(53);
+
+	var LinkedValueUtils = __webpack_require__(113);
+	var ReactDOMComponentTree = __webpack_require__(34);
+	var ReactUpdates = __webpack_require__(60);
+
+	var warning = __webpack_require__(47);
+
+	var didWarnValueLink = false;
+	var didWarnValueDefaultValue = false;
+
+	function updateOptionsIfPendingUpdateAndMounted() {
+	  if (this._rootNodeID && this._wrapperState.pendingUpdate) {
+	    this._wrapperState.pendingUpdate = false;
+
+	    var props = this._currentElement.props;
+	    var value = LinkedValueUtils.getValue(props);
+
+	    if (value != null) {
+	      updateOptions(this, Boolean(props.multiple), value);
+	    }
+	  }
+	}
+
+	function getDeclarationErrorAddendum(owner) {
+	  if (owner) {
+	    var name = owner.getName();
+	    if (name) {
+	      return ' Check the render method of `' + name + '`.';
+	    }
+	  }
+	  return '';
+	}
+
+	var valuePropNames = ['value', 'defaultValue'];
+
+	/**
+	 * Validation function for `value` and `defaultValue`.
+	 * @private
+	 */
+	function checkSelectPropTypes(inst, props) {
+	  var owner = inst._currentElement._owner;
+	  LinkedValueUtils.checkPropTypes('select', props, owner);
+
+	  if (props.valueLink !== undefined && !didWarnValueLink) {
+	    process.env.NODE_ENV !== 'production' ? warning(false, '`valueLink` prop on `select` is deprecated; set `value` and `onChange` instead.') : void 0;
+	    didWarnValueLink = true;
+	  }
+
+	  for (var i = 0; i < valuePropNames.length; i++) {
+	    var propName = valuePropNames[i];
+	    if (props[propName] == null) {
+	      continue;
+	    }
+	    var isArray = Array.isArray(props[propName]);
+	    if (props.multiple && !isArray) {
+	      process.env.NODE_ENV !== 'production' ? warning(false, 'The `%s` prop supplied to <select> must be an array if ' + '`multiple` is true.%s', propName, getDeclarationErrorAddendum(owner)) : void 0;
+	    } else if (!props.multiple && isArray) {
+	      process.env.NODE_ENV !== 'production' ? warning(false, 'The `%s` prop supplied to <select> must be a scalar ' + 'value if `multiple` is false.%s', propName, getDeclarationErrorAddendum(owner)) : void 0;
+	    }
+	  }
+	}
+
+	/**
+	 * @param {ReactDOMComponent} inst
+	 * @param {boolean} multiple
+	 * @param {*} propValue A stringable (with `multiple`, a list of stringables).
+	 * @private
+	 */
+	function updateOptions(inst, multiple, propValue) {
+	  var selectedValue, i;
+	  var options = ReactDOMComponentTree.getNodeFromInstance(inst).options;
+
+	  if (multiple) {
+	    selectedValue = {};
+	    for (i = 0; i < propValue.length; i++) {
+	      selectedValue['' + propValue[i]] = true;
+	    }
+	    for (i = 0; i < options.length; i++) {
+	      var selected = selectedValue.hasOwnProperty(options[i].value);
+	      if (options[i].selected !== selected) {
+	        options[i].selected = selected;
+	      }
+	    }
+	  } else {
+	    // Do not set `select.value` as exact behavior isn't consistent across all
+	    // browsers for all cases.
+	    selectedValue = '' + propValue;
+	    for (i = 0; i < options.length; i++) {
+	      if (options[i].value === selectedValue) {
+	        options[i].selected = true;
+	        return;
+	      }
+	    }
+	    if (options.length) {
+	      options[0].selected = true;
+	    }
+	  }
+	}
+
+	/**
+	 * Implements a <select> host component that allows optionally setting the
+	 * props `value` and `defaultValue`. If `multiple` is false, the prop must be a
+	 * stringable. If `multiple` is true, the prop must be an array of stringables.
+	 *
+	 * If `value` is not supplied (or null/undefined), user actions that change the
+	 * selected option will trigger updates to the rendered options.
+	 *
+	 * If it is supplied (and not null/undefined), the rendered options will not
+	 * update in response to user actions. Instead, the `value` prop must change in
+	 * order for the rendered options to update.
+	 *
+	 * If `defaultValue` is provided, any options with the supplied values will be
+	 * selected.
+	 */
+	var ReactDOMSelect = {
+	  getHostProps: function (inst, props) {
+	    return _assign({}, props, {
+	      onChange: inst._wrapperState.onChange,
+	      value: undefined
+	    });
+	  },
+
+	  mountWrapper: function (inst, props) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      checkSelectPropTypes(inst, props);
+	    }
+
+	    var value = LinkedValueUtils.getValue(props);
+	    inst._wrapperState = {
+	      pendingUpdate: false,
+	      initialValue: value != null ? value : props.defaultValue,
+	      listeners: null,
+	      onChange: _handleChange.bind(inst),
+	      wasMultiple: Boolean(props.multiple)
+	    };
+
+	    if (props.value !== undefined && props.defaultValue !== undefined && !didWarnValueDefaultValue) {
+	      process.env.NODE_ENV !== 'production' ? warning(false, 'Select elements must be either controlled or uncontrolled ' + '(specify either the value prop, or the defaultValue prop, but not ' + 'both). Decide between using a controlled or uncontrolled select ' + 'element and remove one of these props. More info: ' + 'https://fb.me/react-controlled-components') : void 0;
+	      didWarnValueDefaultValue = true;
+	    }
+	  },
+
+	  getSelectValueContext: function (inst) {
+	    // ReactDOMOption looks at this initial value so the initial generated
+	    // markup has correct `selected` attributes
+	    return inst._wrapperState.initialValue;
+	  },
+
+	  postUpdateWrapper: function (inst) {
+	    var props = inst._currentElement.props;
+
+	    // After the initial mount, we control selected-ness manually so don't pass
+	    // this value down
+	    inst._wrapperState.initialValue = undefined;
+
+	    var wasMultiple = inst._wrapperState.wasMultiple;
+	    inst._wrapperState.wasMultiple = Boolean(props.multiple);
+
+	    var value = LinkedValueUtils.getValue(props);
+	    if (value != null) {
+	      inst._wrapperState.pendingUpdate = false;
+	      updateOptions(inst, Boolean(props.multiple), value);
+	    } else if (wasMultiple !== Boolean(props.multiple)) {
+	      // For simplicity, reapply `defaultValue` if `multiple` is toggled.
+	      if (props.defaultValue != null) {
+	        updateOptions(inst, Boolean(props.multiple), props.defaultValue);
+	      } else {
+	        // Revert the select back to its default unselected state.
+	        updateOptions(inst, Boolean(props.multiple), props.multiple ? [] : '');
+	      }
+	    }
+	  }
+	};
+
+	function _handleChange(event) {
+	  var props = this._currentElement.props;
+	  var returnValue = LinkedValueUtils.executeOnChange(props, event);
+
+	  if (this._rootNodeID) {
+	    this._wrapperState.pendingUpdate = true;
+	  }
+	  ReactUpdates.asap(updateOptionsIfPendingUpdateAndMounted, this);
+	  return returnValue;
+	}
+
+	module.exports = ReactDOMSelect;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 117 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35),
+	    _assign = __webpack_require__(53);
+
+	var LinkedValueUtils = __webpack_require__(113);
+	var ReactDOMComponentTree = __webpack_require__(34);
+	var ReactUpdates = __webpack_require__(60);
+
+	var invariant = __webpack_require__(37);
+	var warning = __webpack_require__(47);
+
+	var didWarnValueLink = false;
+	var didWarnValDefaultVal = false;
+
+	function forceUpdateIfMounted() {
+	  if (this._rootNodeID) {
+	    // DOM component is still mounted; update
+	    ReactDOMTextarea.updateWrapper(this);
+	  }
+	}
+
+	/**
+	 * Implements a <textarea> host 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 = {
+	  getHostProps: function (inst, props) {
+	    !(props.dangerouslySetInnerHTML == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, '`dangerouslySetInnerHTML` does not make sense on <textarea>.') : _prodInvariant('91') : void 0;
+
+	    // Always set children to the same thing. In IE9, the selection range will
+	    // get reset if `textContent` is mutated.  We could add a check in setTextContent
+	    // to only set the value if/when the value differs from the node value (which would
+	    // completely solve this IE9 bug), but Sebastian+Ben seemed to like this solution.
+	    // The value can be a boolean or object so that's why it's forced to be a string.
+	    var hostProps = _assign({}, props, {
+	      value: undefined,
+	      defaultValue: undefined,
+	      children: '' + inst._wrapperState.initialValue,
+	      onChange: inst._wrapperState.onChange
+	    });
+
+	    return hostProps;
+	  },
+
+	  mountWrapper: function (inst, props) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      LinkedValueUtils.checkPropTypes('textarea', props, inst._currentElement._owner);
+	      if (props.valueLink !== undefined && !didWarnValueLink) {
+	        process.env.NODE_ENV !== 'production' ? warning(false, '`valueLink` prop on `textarea` is deprecated; set `value` and `onChange` instead.') : void 0;
+	        didWarnValueLink = true;
+	      }
+	      if (props.value !== undefined && props.defaultValue !== undefined && !didWarnValDefaultVal) {
+	        process.env.NODE_ENV !== 'production' ? warning(false, 'Textarea elements must be either controlled or uncontrolled ' + '(specify either the value prop, or the defaultValue prop, but not ' + 'both). Decide between using a controlled or uncontrolled textarea ' + 'and remove one of these props. More info: ' + 'https://fb.me/react-controlled-components') : void 0;
+	        didWarnValDefaultVal = true;
+	      }
+	    }
+
+	    var value = LinkedValueUtils.getValue(props);
+	    var initialValue = value;
+
+	    // Only bother fetching default value if we're going to use it
+	    if (value == null) {
+	      var defaultValue = props.defaultValue;
+	      // TODO (yungsters): Remove support for children content in <textarea>.
+	      var children = props.children;
+	      if (children != null) {
+	        if (process.env.NODE_ENV !== 'production') {
+	          process.env.NODE_ENV !== 'production' ? warning(false, 'Use the `defaultValue` or `value` props instead of setting ' + 'children on <textarea>.') : void 0;
+	        }
+	        !(defaultValue == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'If you supply `defaultValue` on a <textarea>, do not pass children.') : _prodInvariant('92') : void 0;
+	        if (Array.isArray(children)) {
+	          !(children.length <= 1) ? process.env.NODE_ENV !== 'production' ? invariant(false, '<textarea> can only have at most one child.') : _prodInvariant('93') : void 0;
+	          children = children[0];
+	        }
+
+	        defaultValue = '' + children;
+	      }
+	      if (defaultValue == null) {
+	        defaultValue = '';
+	      }
+	      initialValue = defaultValue;
+	    }
+
+	    inst._wrapperState = {
+	      initialValue: '' + initialValue,
+	      listeners: null,
+	      onChange: _handleChange.bind(inst)
+	    };
+	  },
+
+	  updateWrapper: function (inst) {
+	    var props = inst._currentElement.props;
+
+	    var node = ReactDOMComponentTree.getNodeFromInstance(inst);
+	    var value = LinkedValueUtils.getValue(props);
+	    if (value != null) {
+	      // Cast `value` to a string to ensure the value is set correctly. While
+	      // browsers typically do this as necessary, jsdom doesn't.
+	      var newValue = '' + value;
+
+	      // To avoid side effects (such as losing text selection), only set value if changed
+	      if (newValue !== node.value) {
+	        node.value = newValue;
+	      }
+	      if (props.defaultValue == null) {
+	        node.defaultValue = newValue;
+	      }
+	    }
+	    if (props.defaultValue != null) {
+	      node.defaultValue = props.defaultValue;
+	    }
+	  },
+
+	  postMountWrapper: function (inst) {
+	    // This is in postMount because we need access to the DOM node, which is not
+	    // available until after the component has mounted.
+	    var node = ReactDOMComponentTree.getNodeFromInstance(inst);
+
+	    // Warning: node.value may be the empty string at this point (IE11) if placeholder is set.
+	    node.value = node.textContent; // Detach value from defaultValue
+	  }
+	};
+
+	function _handleChange(event) {
+	  var props = this._currentElement.props;
+	  var returnValue = LinkedValueUtils.executeOnChange(props, event);
+	  ReactUpdates.asap(forceUpdateIfMounted, this);
+	  return returnValue;
+	}
+
+	module.exports = ReactDOMTextarea;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 118 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var ReactComponentEnvironment = __webpack_require__(119);
+	var ReactInstanceMap = __webpack_require__(120);
+	var ReactInstrumentation = __webpack_require__(66);
+
+	var ReactCurrentOwner = __webpack_require__(10);
+	var ReactReconciler = __webpack_require__(63);
+	var ReactChildReconciler = __webpack_require__(121);
+
+	var emptyFunction = __webpack_require__(48);
+	var flattenChildren = __webpack_require__(137);
+	var invariant = __webpack_require__(37);
+
+	/**
+	 * Make an update for markup to be rendered and inserted at a supplied index.
+	 *
+	 * @param {string} markup Markup that renders into an element.
+	 * @param {number} toIndex Destination index.
+	 * @private
+	 */
+	function makeInsertMarkup(markup, afterNode, toIndex) {
+	  // NOTE: Null values reduce hidden classes.
+	  return {
+	    type: 'INSERT_MARKUP',
+	    content: markup,
+	    fromIndex: null,
+	    fromNode: null,
+	    toIndex: toIndex,
+	    afterNode: afterNode
+	  };
+	}
+
+	/**
+	 * Make an update for moving an existing element to another index.
+	 *
+	 * @param {number} fromIndex Source index of the existing element.
+	 * @param {number} toIndex Destination index of the element.
+	 * @private
+	 */
+	function makeMove(child, afterNode, toIndex) {
+	  // NOTE: Null values reduce hidden classes.
+	  return {
+	    type: 'MOVE_EXISTING',
+	    content: null,
+	    fromIndex: child._mountIndex,
+	    fromNode: ReactReconciler.getHostNode(child),
+	    toIndex: toIndex,
+	    afterNode: afterNode
+	  };
+	}
+
+	/**
+	 * Make an update for removing an element at an index.
+	 *
+	 * @param {number} fromIndex Index of the element to remove.
+	 * @private
+	 */
+	function makeRemove(child, node) {
+	  // NOTE: Null values reduce hidden classes.
+	  return {
+	    type: 'REMOVE_NODE',
+	    content: null,
+	    fromIndex: child._mountIndex,
+	    fromNode: node,
+	    toIndex: null,
+	    afterNode: null
+	  };
+	}
+
+	/**
+	 * Make an update for setting the markup of a node.
+	 *
+	 * @param {string} markup Markup that renders into an element.
+	 * @private
+	 */
+	function makeSetMarkup(markup) {
+	  // NOTE: Null values reduce hidden classes.
+	  return {
+	    type: 'SET_MARKUP',
+	    content: markup,
+	    fromIndex: null,
+	    fromNode: null,
+	    toIndex: null,
+	    afterNode: null
+	  };
+	}
+
+	/**
+	 * Make an update for setting the text content.
+	 *
+	 * @param {string} textContent Text content to set.
+	 * @private
+	 */
+	function makeTextContent(textContent) {
+	  // NOTE: Null values reduce hidden classes.
+	  return {
+	    type: 'TEXT_CONTENT',
+	    content: textContent,
+	    fromIndex: null,
+	    fromNode: null,
+	    toIndex: null,
+	    afterNode: null
+	  };
+	}
+
+	/**
+	 * Push an update, if any, onto the queue. Creates a new queue if none is
+	 * passed and always returns the queue. Mutative.
+	 */
+	function enqueue(queue, update) {
+	  if (update) {
+	    queue = queue || [];
+	    queue.push(update);
+	  }
+	  return queue;
+	}
+
+	/**
+	 * Processes any enqueued updates.
+	 *
+	 * @private
+	 */
+	function processQueue(inst, updateQueue) {
+	  ReactComponentEnvironment.processChildrenUpdates(inst, updateQueue);
+	}
+
+	var setChildrenForInstrumentation = emptyFunction;
+	if (process.env.NODE_ENV !== 'production') {
+	  var getDebugID = function (inst) {
+	    if (!inst._debugID) {
+	      // Check for ART-like instances. TODO: This is silly/gross.
+	      var internal;
+	      if (internal = ReactInstanceMap.get(inst)) {
+	        inst = internal;
+	      }
+	    }
+	    return inst._debugID;
+	  };
+	  setChildrenForInstrumentation = function (children) {
+	    var debugID = getDebugID(this);
+	    // TODO: React Native empty components are also multichild.
+	    // This means they still get into this method but don't have _debugID.
+	    if (debugID !== 0) {
+	      ReactInstrumentation.debugTool.onSetChildren(debugID, children ? Object.keys(children).map(function (key) {
+	        return children[key]._debugID;
+	      }) : []);
+	    }
+	  };
+	}
+
+	/**
+	 * ReactMultiChild are capable of reconciling multiple children.
+	 *
+	 * @class ReactMultiChild
+	 * @internal
+	 */
+	var ReactMultiChild = {
+
+	  /**
+	   * Provides common functionality for components that must reconcile multiple
+	   * children. This is used by `ReactDOMComponent` to mount, update, and
+	   * unmount child components.
+	   *
+	   * @lends {ReactMultiChild.prototype}
+	   */
+	  Mixin: {
+
+	    _reconcilerInstantiateChildren: function (nestedChildren, transaction, context) {
+	      if (process.env.NODE_ENV !== 'production') {
+	        var selfDebugID = getDebugID(this);
+	        if (this._currentElement) {
+	          try {
+	            ReactCurrentOwner.current = this._currentElement._owner;
+	            return ReactChildReconciler.instantiateChildren(nestedChildren, transaction, context, selfDebugID);
+	          } finally {
+	            ReactCurrentOwner.current = null;
+	          }
+	        }
+	      }
+	      return ReactChildReconciler.instantiateChildren(nestedChildren, transaction, context);
+	    },
+
+	    _reconcilerUpdateChildren: function (prevChildren, nextNestedChildrenElements, mountImages, removedNodes, transaction, context) {
+	      var nextChildren;
+	      var selfDebugID = 0;
+	      if (process.env.NODE_ENV !== 'production') {
+	        selfDebugID = getDebugID(this);
+	        if (this._currentElement) {
+	          try {
+	            ReactCurrentOwner.current = this._currentElement._owner;
+	            nextChildren = flattenChildren(nextNestedChildrenElements, selfDebugID);
+	          } finally {
+	            ReactCurrentOwner.current = null;
+	          }
+	          ReactChildReconciler.updateChildren(prevChildren, nextChildren, mountImages, removedNodes, transaction, this, this._hostContainerInfo, context, selfDebugID);
+	          return nextChildren;
+	        }
+	      }
+	      nextChildren = flattenChildren(nextNestedChildrenElements, selfDebugID);
+	      ReactChildReconciler.updateChildren(prevChildren, nextChildren, mountImages, removedNodes, transaction, this, this._hostContainerInfo, context, selfDebugID);
+	      return nextChildren;
+	    },
+
+	    /**
+	     * Generates a "mount image" for each of the supplied children. In the case
+	     * of `ReactDOMComponent`, a mount image is a string of markup.
+	     *
+	     * @param {?object} nestedChildren Nested child maps.
+	     * @return {array} An array of mounted representations.
+	     * @internal
+	     */
+	    mountChildren: function (nestedChildren, transaction, context) {
+	      var children = this._reconcilerInstantiateChildren(nestedChildren, transaction, context);
+	      this._renderedChildren = children;
+
+	      var mountImages = [];
+	      var index = 0;
+	      for (var name in children) {
+	        if (children.hasOwnProperty(name)) {
+	          var child = children[name];
+	          var selfDebugID = 0;
+	          if (process.env.NODE_ENV !== 'production') {
+	            selfDebugID = getDebugID(this);
+	          }
+	          var mountImage = ReactReconciler.mountComponent(child, transaction, this, this._hostContainerInfo, context, selfDebugID);
+	          child._mountIndex = index++;
+	          mountImages.push(mountImage);
+	        }
+	      }
+
+	      if (process.env.NODE_ENV !== 'production') {
+	        setChildrenForInstrumentation.call(this, children);
+	      }
+
+	      return mountImages;
+	    },
+
+	    /**
+	     * Replaces any rendered children with a text content string.
+	     *
+	     * @param {string} nextContent String of content.
+	     * @internal
+	     */
+	    updateTextContent: function (nextContent) {
+	      var prevChildren = this._renderedChildren;
+	      // Remove any rendered children.
+	      ReactChildReconciler.unmountChildren(prevChildren, false);
+	      for (var name in prevChildren) {
+	        if (prevChildren.hasOwnProperty(name)) {
+	           true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'updateTextContent called on non-empty component.') : _prodInvariant('118') : void 0;
+	        }
+	      }
+	      // Set new text content.
+	      var updates = [makeTextContent(nextContent)];
+	      processQueue(this, updates);
+	    },
+
+	    /**
+	     * Replaces any rendered children with a markup string.
+	     *
+	     * @param {string} nextMarkup String of markup.
+	     * @internal
+	     */
+	    updateMarkup: function (nextMarkup) {
+	      var prevChildren = this._renderedChildren;
+	      // Remove any rendered children.
+	      ReactChildReconciler.unmountChildren(prevChildren, false);
+	      for (var name in prevChildren) {
+	        if (prevChildren.hasOwnProperty(name)) {
+	           true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'updateTextContent called on non-empty component.') : _prodInvariant('118') : void 0;
+	        }
+	      }
+	      var updates = [makeSetMarkup(nextMarkup)];
+	      processQueue(this, updates);
+	    },
+
+	    /**
+	     * Updates the rendered children with new children.
+	     *
+	     * @param {?object} nextNestedChildrenElements Nested child element maps.
+	     * @param {ReactReconcileTransaction} transaction
+	     * @internal
+	     */
+	    updateChildren: function (nextNestedChildrenElements, transaction, context) {
+	      // Hook used by React ART
+	      this._updateChildren(nextNestedChildrenElements, transaction, context);
+	    },
+
+	    /**
+	     * @param {?object} nextNestedChildrenElements Nested child element maps.
+	     * @param {ReactReconcileTransaction} transaction
+	     * @final
+	     * @protected
+	     */
+	    _updateChildren: function (nextNestedChildrenElements, transaction, context) {
+	      var prevChildren = this._renderedChildren;
+	      var removedNodes = {};
+	      var mountImages = [];
+	      var nextChildren = this._reconcilerUpdateChildren(prevChildren, nextNestedChildrenElements, mountImages, removedNodes, transaction, context);
+	      if (!nextChildren && !prevChildren) {
+	        return;
+	      }
+	      var updates = null;
+	      var name;
+	      // `nextIndex` will increment for each child in `nextChildren`, but
+	      // `lastIndex` will be the last index visited in `prevChildren`.
+	      var nextIndex = 0;
+	      var lastIndex = 0;
+	      // `nextMountIndex` will increment for each newly mounted child.
+	      var nextMountIndex = 0;
+	      var lastPlacedNode = null;
+	      for (name in nextChildren) {
+	        if (!nextChildren.hasOwnProperty(name)) {
+	          continue;
+	        }
+	        var prevChild = prevChildren && prevChildren[name];
+	        var nextChild = nextChildren[name];
+	        if (prevChild === nextChild) {
+	          updates = enqueue(updates, this.moveChild(prevChild, lastPlacedNode, nextIndex, lastIndex));
+	          lastIndex = Math.max(prevChild._mountIndex, lastIndex);
+	          prevChild._mountIndex = nextIndex;
+	        } else {
+	          if (prevChild) {
+	            // Update `lastIndex` before `_mountIndex` gets unset by unmounting.
+	            lastIndex = Math.max(prevChild._mountIndex, lastIndex);
+	            // The `removedNodes` loop below will actually remove the child.
+	          }
+	          // The child must be instantiated before it's mounted.
+	          updates = enqueue(updates, this._mountChildAtIndex(nextChild, mountImages[nextMountIndex], lastPlacedNode, nextIndex, transaction, context));
+	          nextMountIndex++;
+	        }
+	        nextIndex++;
+	        lastPlacedNode = ReactReconciler.getHostNode(nextChild);
+	      }
+	      // Remove children that are no longer present.
+	      for (name in removedNodes) {
+	        if (removedNodes.hasOwnProperty(name)) {
+	          updates = enqueue(updates, this._unmountChild(prevChildren[name], removedNodes[name]));
+	        }
+	      }
+	      if (updates) {
+	        processQueue(this, updates);
+	      }
+	      this._renderedChildren = nextChildren;
+
+	      if (process.env.NODE_ENV !== 'production') {
+	        setChildrenForInstrumentation.call(this, nextChildren);
+	      }
+	    },
+
+	    /**
+	     * Unmounts all rendered children. This should be used to clean up children
+	     * when this component is unmounted. It does not actually perform any
+	     * backend operations.
+	     *
+	     * @internal
+	     */
+	    unmountChildren: function (safely) {
+	      var renderedChildren = this._renderedChildren;
+	      ReactChildReconciler.unmountChildren(renderedChildren, safely);
+	      this._renderedChildren = null;
+	    },
+
+	    /**
+	     * Moves a child component to the supplied index.
+	     *
+	     * @param {ReactComponent} child Component to move.
+	     * @param {number} toIndex Destination index of the element.
+	     * @param {number} lastIndex Last index visited of the siblings of `child`.
+	     * @protected
+	     */
+	    moveChild: function (child, afterNode, toIndex, lastIndex) {
+	      // If the index of `child` is less than `lastIndex`, then it needs to
+	      // be moved. Otherwise, we do not need to move it because a child will be
+	      // inserted or moved before `child`.
+	      if (child._mountIndex < lastIndex) {
+	        return makeMove(child, afterNode, toIndex);
+	      }
+	    },
+
+	    /**
+	     * Creates a child component.
+	     *
+	     * @param {ReactComponent} child Component to create.
+	     * @param {string} mountImage Markup to insert.
+	     * @protected
+	     */
+	    createChild: function (child, afterNode, mountImage) {
+	      return makeInsertMarkup(mountImage, afterNode, child._mountIndex);
+	    },
+
+	    /**
+	     * Removes a child component.
+	     *
+	     * @param {ReactComponent} child Child to remove.
+	     * @protected
+	     */
+	    removeChild: function (child, node) {
+	      return makeRemove(child, node);
+	    },
+
+	    /**
+	     * Mounts a child with the supplied name.
+	     *
+	     * NOTE: This is part of `updateChildren` and is here for readability.
+	     *
+	     * @param {ReactComponent} child Component to mount.
+	     * @param {string} name Name of the child.
+	     * @param {number} index Index at which to insert the child.
+	     * @param {ReactReconcileTransaction} transaction
+	     * @private
+	     */
+	    _mountChildAtIndex: function (child, mountImage, afterNode, index, transaction, context) {
+	      child._mountIndex = index;
+	      return this.createChild(child, afterNode, mountImage);
+	    },
+
+	    /**
+	     * Unmounts a rendered child.
+	     *
+	     * NOTE: This is part of `updateChildren` and is here for readability.
+	     *
+	     * @param {ReactComponent} child Component to unmount.
+	     * @private
+	     */
+	    _unmountChild: function (child, node) {
+	      var update = this.removeChild(child, node);
+	      child._mountIndex = null;
+	      return update;
+	    }
+
+	  }
+
+	};
+
+	module.exports = ReactMultiChild;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 119 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2014-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var invariant = __webpack_require__(37);
+
+	var injected = false;
+
+	var ReactComponentEnvironment = {
+
+	  /**
+	   * Optionally injectable hook for swapping out mount images in the middle of
+	   * the tree.
+	   */
+	  replaceNodeWithMarkup: null,
+
+	  /**
+	   * Optionally injectable hook for processing a queue of child updates. Will
+	   * later move into MultiChildComponents.
+	   */
+	  processChildrenUpdates: null,
+
+	  injection: {
+	    injectEnvironment: function (environment) {
+	      !!injected ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactCompositeComponent: injectEnvironment() can only be called once.') : _prodInvariant('104') : void 0;
+	      ReactComponentEnvironment.replaceNodeWithMarkup = environment.replaceNodeWithMarkup;
+	      ReactComponentEnvironment.processChildrenUpdates = environment.processChildrenUpdates;
+	      injected = true;
+	    }
+	  }
+
+	};
+
+	module.exports = ReactComponentEnvironment;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 120 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	/**
+	 * `ReactInstanceMap` maintains a mapping from a public facing stateful
+	 * instance (key) and the internal representation (value). This allows public
+	 * methods to accept the user facing instance as an argument and map them back
+	 * to internal methods.
+	 */
+
+	// TODO: Replace this with ES6: var ReactInstanceMap = new Map();
+
+	var ReactInstanceMap = {
+
+	  /**
+	   * This API should be called `delete` but we'd have to make sure to always
+	   * transform these to strings for IE support. When this transform is fully
+	   * supported we can rename it.
+	   */
+	  remove: function (key) {
+	    key._reactInternalInstance = undefined;
+	  },
+
+	  get: function (key) {
+	    return key._reactInternalInstance;
+	  },
+
+	  has: function (key) {
+	    return key._reactInternalInstance !== undefined;
+	  },
+
+	  set: function (key, value) {
+	    key._reactInternalInstance = value;
+	  }
+
+	};
+
+	module.exports = ReactInstanceMap;
+
+/***/ },
+/* 121 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2014-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ReactReconciler = __webpack_require__(63);
+
+	var instantiateReactComponent = __webpack_require__(122);
+	var KeyEscapeUtils = __webpack_require__(133);
+	var shouldUpdateReactComponent = __webpack_require__(129);
+	var traverseAllChildren = __webpack_require__(134);
+	var warning = __webpack_require__(47);
+
+	var ReactComponentTreeHook;
+
+	if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV === 'test') {
+	  // Temporary hack.
+	  // Inline requires don't work well with Jest:
+	  // https://github.com/facebook/react/issues/7240
+	  // Remove the inline requires when we don't need them anymore:
+	  // https://github.com/facebook/react/pull/7178
+	  ReactComponentTreeHook = __webpack_require__(26);
+	}
+
+	function instantiateChild(childInstances, child, name, selfDebugID) {
+	  // We found a component instance.
+	  var keyUnique = childInstances[name] === undefined;
+	  if (process.env.NODE_ENV !== 'production') {
+	    if (!ReactComponentTreeHook) {
+	      ReactComponentTreeHook = __webpack_require__(26);
+	    }
+	    if (!keyUnique) {
+	      process.env.NODE_ENV !== 'production' ? warning(false, 'flattenChildren(...): Encountered two children with the same key, ' + '`%s`. Child keys must be unique; when two children share a key, only ' + 'the first child will be used.%s', KeyEscapeUtils.unescape(name), ReactComponentTreeHook.getStackAddendumByID(selfDebugID)) : void 0;
+	    }
+	  }
+	  if (child != null && keyUnique) {
+	    childInstances[name] = instantiateReactComponent(child, true);
+	  }
+	}
+
+	/**
+	 * ReactChildReconciler provides helpers for initializing or updating a set of
+	 * children. Its output is suitable for passing it onto ReactMultiChild which
+	 * does diffed reordering and insertion.
+	 */
+	var ReactChildReconciler = {
+	  /**
+	   * Generates a "mount image" for each of the supplied children. In the case
+	   * of `ReactDOMComponent`, a mount image is a string of markup.
+	   *
+	   * @param {?object} nestedChildNodes Nested child maps.
+	   * @return {?object} A set of child instances.
+	   * @internal
+	   */
+	  instantiateChildren: function (nestedChildNodes, transaction, context, selfDebugID // 0 in production and for roots
+	  ) {
+	    if (nestedChildNodes == null) {
+	      return null;
+	    }
+	    var childInstances = {};
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      traverseAllChildren(nestedChildNodes, function (childInsts, child, name) {
+	        return instantiateChild(childInsts, child, name, selfDebugID);
+	      }, childInstances);
+	    } else {
+	      traverseAllChildren(nestedChildNodes, instantiateChild, childInstances);
+	    }
+	    return childInstances;
+	  },
+
+	  /**
+	   * Updates the rendered children and returns a new set of children.
+	   *
+	   * @param {?object} prevChildren Previously initialized set of children.
+	   * @param {?object} nextChildren Flat child element maps.
+	   * @param {ReactReconcileTransaction} transaction
+	   * @param {object} context
+	   * @return {?object} A new set of child instances.
+	   * @internal
+	   */
+	  updateChildren: function (prevChildren, nextChildren, mountImages, removedNodes, transaction, hostParent, hostContainerInfo, context, selfDebugID // 0 in production and for roots
+	  ) {
+	    // We currently don't have a way to track moves here but if we use iterators
+	    // instead of for..in we can zip the iterators and check if an item has
+	    // moved.
+	    // TODO: If nothing has changed, return the prevChildren object so that we
+	    // can quickly bailout if nothing has changed.
+	    if (!nextChildren && !prevChildren) {
+	      return;
+	    }
+	    var name;
+	    var prevChild;
+	    for (name in nextChildren) {
+	      if (!nextChildren.hasOwnProperty(name)) {
+	        continue;
+	      }
+	      prevChild = prevChildren && prevChildren[name];
+	      var prevElement = prevChild && prevChild._currentElement;
+	      var nextElement = nextChildren[name];
+	      if (prevChild != null && shouldUpdateReactComponent(prevElement, nextElement)) {
+	        ReactReconciler.receiveComponent(prevChild, nextElement, transaction, context);
+	        nextChildren[name] = prevChild;
+	      } else {
+	        if (prevChild) {
+	          removedNodes[name] = ReactReconciler.getHostNode(prevChild);
+	          ReactReconciler.unmountComponent(prevChild, false);
+	        }
+	        // The child must be instantiated before it's mounted.
+	        var nextChildInstance = instantiateReactComponent(nextElement, true);
+	        nextChildren[name] = nextChildInstance;
+	        // Creating mount image now ensures refs are resolved in right order
+	        // (see https://github.com/facebook/react/pull/7101 for explanation).
+	        var nextChildMountImage = ReactReconciler.mountComponent(nextChildInstance, transaction, hostParent, hostContainerInfo, context, selfDebugID);
+	        mountImages.push(nextChildMountImage);
+	      }
+	    }
+	    // Unmount children that are no longer present.
+	    for (name in prevChildren) {
+	      if (prevChildren.hasOwnProperty(name) && !(nextChildren && nextChildren.hasOwnProperty(name))) {
+	        prevChild = prevChildren[name];
+	        removedNodes[name] = ReactReconciler.getHostNode(prevChild);
+	        ReactReconciler.unmountComponent(prevChild, false);
+	      }
+	    }
+	  },
+
+	  /**
+	   * Unmounts all rendered children. This should be used to clean up children
+	   * when this component is unmounted.
+	   *
+	   * @param {?object} renderedChildren Previously initialized set of children.
+	   * @internal
+	   */
+	  unmountChildren: function (renderedChildren, safely) {
+	    for (var name in renderedChildren) {
+	      if (renderedChildren.hasOwnProperty(name)) {
+	        var renderedChild = renderedChildren[name];
+	        ReactReconciler.unmountComponent(renderedChild, safely);
+	      }
+	    }
+	  }
+
+	};
+
+	module.exports = ReactChildReconciler;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 122 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35),
+	    _assign = __webpack_require__(53);
+
+	var ReactCompositeComponent = __webpack_require__(123);
+	var ReactEmptyComponent = __webpack_require__(130);
+	var ReactHostComponent = __webpack_require__(131);
+
+	var getNextDebugID = __webpack_require__(132);
+	var invariant = __webpack_require__(37);
+	var warning = __webpack_require__(47);
+
+	// To avoid a cyclic dependency, we create the final class in this module
+	var ReactCompositeComponentWrapper = function (element) {
+	  this.construct(element);
+	};
+	_assign(ReactCompositeComponentWrapper.prototype, ReactCompositeComponent, {
+	  _instantiateReactComponent: instantiateReactComponent
+	});
+
+	function getDeclarationErrorAddendum(owner) {
+	  if (owner) {
+	    var name = owner.getName();
+	    if (name) {
+	      return ' Check the render method of `' + name + '`.';
+	    }
+	  }
+	  return '';
+	}
+
+	/**
+	 * Check if the type reference is a known internal type. I.e. not a user
+	 * provided composite type.
+	 *
+	 * @param {function} type
+	 * @return {boolean} Returns true if this is a valid internal type.
+	 */
+	function isInternalComponentType(type) {
+	  return typeof type === 'function' && typeof type.prototype !== 'undefined' && typeof type.prototype.mountComponent === 'function' && typeof type.prototype.receiveComponent === 'function';
+	}
+
+	/**
+	 * Given a ReactNode, create an instance that will actually be mounted.
+	 *
+	 * @param {ReactNode} node
+	 * @param {boolean} shouldHaveDebugID
+	 * @return {object} A new instance of the element's constructor.
+	 * @protected
+	 */
+	function instantiateReactComponent(node, shouldHaveDebugID) {
+	  var instance;
+
+	  if (node === null || node === false) {
+	    instance = ReactEmptyComponent.create(instantiateReactComponent);
+	  } else if (typeof node === 'object') {
+	    var element = node;
+	    !(element && (typeof element.type === 'function' || typeof element.type === 'string')) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s', element.type == null ? element.type : typeof element.type, getDeclarationErrorAddendum(element._owner)) : _prodInvariant('130', element.type == null ? element.type : typeof element.type, getDeclarationErrorAddendum(element._owner)) : void 0;
+
+	    // Special case string values
+	    if (typeof element.type === 'string') {
+	      instance = ReactHostComponent.createInternalComponent(element);
+	    } else if (isInternalComponentType(element.type)) {
+	      // This is temporarily available for custom components that are not string
+	      // representations. I.e. ART. Once those are updated to use the string
+	      // representation, we can drop this code path.
+	      instance = new element.type(element);
+
+	      // We renamed this. Allow the old name for compat. :(
+	      if (!instance.getHostNode) {
+	        instance.getHostNode = instance.getNativeNode;
+	      }
+	    } else {
+	      instance = new ReactCompositeComponentWrapper(element);
+	    }
+	  } else if (typeof node === 'string' || typeof node === 'number') {
+	    instance = ReactHostComponent.createInstanceForText(node);
+	  } else {
+	     true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Encountered invalid React node of type %s', typeof node) : _prodInvariant('131', typeof node) : void 0;
+	  }
+
+	  if (process.env.NODE_ENV !== 'production') {
+	    process.env.NODE_ENV !== 'production' ? warning(typeof instance.mountComponent === 'function' && typeof instance.receiveComponent === 'function' && typeof instance.getHostNode === 'function' && typeof instance.unmountComponent === 'function', 'Only React Components can be mounted.') : void 0;
+	  }
+
+	  // These two fields are used by the DOM and ART diffing algorithms
+	  // respectively. Instead of using expandos on components, we should be
+	  // storing the state needed by the diffing algorithms elsewhere.
+	  instance._mountIndex = 0;
+	  instance._mountImage = null;
+
+	  if (process.env.NODE_ENV !== 'production') {
+	    instance._debugID = shouldHaveDebugID ? getNextDebugID() : 0;
+	  }
+
+	  // Internal instances should fully constructed at this point, so they should
+	  // not get any new fields added to them at this point.
+	  if (process.env.NODE_ENV !== 'production') {
+	    if (Object.preventExtensions) {
+	      Object.preventExtensions(instance);
+	    }
+	  }
+
+	  return instance;
+	}
+
+	module.exports = instantiateReactComponent;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 123 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35),
+	    _assign = __webpack_require__(53);
+
+	var React = __webpack_require__(2);
+	var ReactComponentEnvironment = __webpack_require__(119);
+	var ReactCurrentOwner = __webpack_require__(10);
+	var ReactErrorUtils = __webpack_require__(46);
+	var ReactInstanceMap = __webpack_require__(120);
+	var ReactInstrumentation = __webpack_require__(66);
+	var ReactNodeTypes = __webpack_require__(124);
+	var ReactReconciler = __webpack_require__(63);
+
+	if (process.env.NODE_ENV !== 'production') {
+	  var checkReactTypeSpec = __webpack_require__(125);
+	}
+
+	var emptyObject = __webpack_require__(127);
+	var invariant = __webpack_require__(37);
+	var shallowEqual = __webpack_require__(128);
+	var shouldUpdateReactComponent = __webpack_require__(129);
+	var warning = __webpack_require__(47);
+
+	var CompositeTypes = {
+	  ImpureClass: 0,
+	  PureClass: 1,
+	  StatelessFunctional: 2
+	};
+
+	function StatelessComponent(Component) {}
+	StatelessComponent.prototype.render = function () {
+	  var Component = ReactInstanceMap.get(this)._currentElement.type;
+	  var element = Component(this.props, this.context, this.updater);
+	  warnIfInvalidElement(Component, element);
+	  return element;
+	};
+
+	function warnIfInvalidElement(Component, element) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    process.env.NODE_ENV !== 'production' ? warning(element === null || element === false || React.isValidElement(element), '%s(...): A valid React element (or null) must be returned. You may have ' + 'returned undefined, an array or some other invalid object.', Component.displayName || Component.name || 'Component') : void 0;
+	    process.env.NODE_ENV !== 'production' ? warning(!Component.childContextTypes, '%s(...): childContextTypes cannot be defined on a functional component.', Component.displayName || Component.name || 'Component') : void 0;
+	  }
+	}
+
+	function shouldConstruct(Component) {
+	  return !!(Component.prototype && Component.prototype.isReactComponent);
+	}
+
+	function isPureComponent(Component) {
+	  return !!(Component.prototype && Component.prototype.isPureReactComponent);
+	}
+
+	// Separated into a function to contain deoptimizations caused by try/finally.
+	function measureLifeCyclePerf(fn, debugID, timerType) {
+	  if (debugID === 0) {
+	    // Top-level wrappers (see ReactMount) and empty components (see
+	    // ReactDOMEmptyComponent) are invisible to hooks and devtools.
+	    // Both are implementation details that should go away in the future.
+	    return fn();
+	  }
+
+	  ReactInstrumentation.debugTool.onBeginLifeCycleTimer(debugID, timerType);
+	  try {
+	    return fn();
+	  } finally {
+	    ReactInstrumentation.debugTool.onEndLifeCycleTimer(debugID, timerType);
+	  }
+	}
+
+	/**
+	 * ------------------ The Life-Cycle of a Composite Component ------------------
+	 *
+	 * - constructor: Initialization of state. The instance is now retained.
+	 *   - componentWillMount
+	 *   - render
+	 *   - [children's constructors]
+	 *     - [children's componentWillMount and render]
+	 *     - [children's componentDidMount]
+	 *     - componentDidMount
+	 *
+	 *       Update Phases:
+	 *       - componentWillReceiveProps (only called if parent updated)
+	 *       - shouldComponentUpdate
+	 *         - componentWillUpdate
+	 *           - render
+	 *           - [children's constructors or receive props phases]
+	 *         - componentDidUpdate
+	 *
+	 *     - componentWillUnmount
+	 *     - [children's componentWillUnmount]
+	 *   - [children destroyed]
+	 * - (destroyed): The instance is now blank, released by React and ready for GC.
+	 *
+	 * -----------------------------------------------------------------------------
+	 */
+
+	/**
+	 * An incrementing ID assigned to each component when it is mounted. This is
+	 * used to enforce the order in which `ReactUpdates` updates dirty components.
+	 *
+	 * @private
+	 */
+	var nextMountID = 1;
+
+	/**
+	 * @lends {ReactCompositeComponent.prototype}
+	 */
+	var ReactCompositeComponent = {
+
+	  /**
+	   * Base constructor for all composite component.
+	   *
+	   * @param {ReactElement} element
+	   * @final
+	   * @internal
+	   */
+	  construct: function (element) {
+	    this._currentElement = element;
+	    this._rootNodeID = 0;
+	    this._compositeType = null;
+	    this._instance = null;
+	    this._hostParent = null;
+	    this._hostContainerInfo = null;
+
+	    // See ReactUpdateQueue
+	    this._updateBatchNumber = null;
+	    this._pendingElement = null;
+	    this._pendingStateQueue = null;
+	    this._pendingReplaceState = false;
+	    this._pendingForceUpdate = false;
+
+	    this._renderedNodeType = null;
+	    this._renderedComponent = null;
+	    this._context = null;
+	    this._mountOrder = 0;
+	    this._topLevelWrapper = null;
+
+	    // See ReactUpdates and ReactUpdateQueue.
+	    this._pendingCallbacks = null;
+
+	    // ComponentWillUnmount shall only be called once
+	    this._calledComponentWillUnmount = false;
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      this._warnedAboutRefsInRender = false;
+	    }
+	  },
+
+	  /**
+	   * Initializes the component, renders markup, and registers event listeners.
+	   *
+	   * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
+	   * @param {?object} hostParent
+	   * @param {?object} hostContainerInfo
+	   * @param {?object} context
+	   * @return {?string} Rendered markup to be inserted into the DOM.
+	   * @final
+	   * @internal
+	   */
+	  mountComponent: function (transaction, hostParent, hostContainerInfo, context) {
+	    var _this = this;
+
+	    this._context = context;
+	    this._mountOrder = nextMountID++;
+	    this._hostParent = hostParent;
+	    this._hostContainerInfo = hostContainerInfo;
+
+	    var publicProps = this._currentElement.props;
+	    var publicContext = this._processContext(context);
+
+	    var Component = this._currentElement.type;
+
+	    var updateQueue = transaction.getUpdateQueue();
+
+	    // Initialize the public class
+	    var doConstruct = shouldConstruct(Component);
+	    var inst = this._constructComponent(doConstruct, publicProps, publicContext, updateQueue);
+	    var renderedElement;
+
+	    // Support functional components
+	    if (!doConstruct && (inst == null || inst.render == null)) {
+	      renderedElement = inst;
+	      warnIfInvalidElement(Component, renderedElement);
+	      !(inst === null || inst === false || React.isValidElement(inst)) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s(...): A valid React element (or null) must be returned. You may have returned undefined, an array or some other invalid object.', Component.displayName || Component.name || 'Component') : _prodInvariant('105', Component.displayName || Component.name || 'Component') : void 0;
+	      inst = new StatelessComponent(Component);
+	      this._compositeType = CompositeTypes.StatelessFunctional;
+	    } else {
+	      if (isPureComponent(Component)) {
+	        this._compositeType = CompositeTypes.PureClass;
+	      } else {
+	        this._compositeType = CompositeTypes.ImpureClass;
+	      }
+	    }
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      // This will throw later in _renderValidatedComponent, but add an early
+	      // warning now to help debugging
+	      if (inst.render == null) {
+	        process.env.NODE_ENV !== 'production' ? warning(false, '%s(...): No `render` method found on the returned component ' + 'instance: you may have forgotten to define `render`.', Component.displayName || Component.name || 'Component') : void 0;
+	      }
+
+	      var propsMutated = inst.props !== publicProps;
+	      var componentName = Component.displayName || Component.name || 'Component';
+
+	      process.env.NODE_ENV !== 'production' ? warning(inst.props === undefined || !propsMutated, '%s(...): When calling super() in `%s`, make sure to pass ' + 'up the same props that your component\'s constructor was passed.', componentName, componentName) : void 0;
+	    }
+
+	    // These should be set up in the constructor, but as a convenience for
+	    // simpler class abstractions, we set them up after the fact.
+	    inst.props = publicProps;
+	    inst.context = publicContext;
+	    inst.refs = emptyObject;
+	    inst.updater = updateQueue;
+
+	    this._instance = inst;
+
+	    // Store a reference from the instance back to the internal representation
+	    ReactInstanceMap.set(inst, this);
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      // Since plain JS classes are defined without any special initialization
+	      // logic, we can not catch common errors early. Therefore, we have to
+	      // catch them here, at initialization time, instead.
+	      process.env.NODE_ENV !== 'production' ? warning(!inst.getInitialState || inst.getInitialState.isReactClassApproved, 'getInitialState was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Did you mean to define a state property instead?', this.getName() || 'a component') : void 0;
+	      process.env.NODE_ENV !== 'production' ? warning(!inst.getDefaultProps || inst.getDefaultProps.isReactClassApproved, 'getDefaultProps was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Use a static property to define defaultProps instead.', this.getName() || 'a component') : void 0;
+	      process.env.NODE_ENV !== 'production' ? warning(!inst.propTypes, 'propTypes was defined as an instance property on %s. Use a static ' + 'property to define propTypes instead.', this.getName() || 'a component') : void 0;
+	      process.env.NODE_ENV !== 'production' ? warning(!inst.contextTypes, 'contextTypes was defined as an instance property on %s. Use a ' + 'static property to define contextTypes instead.', this.getName() || 'a component') : void 0;
+	      process.env.NODE_ENV !== 'production' ? warning(typeof inst.componentShouldUpdate !== 'function', '%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', this.getName() || 'A component') : void 0;
+	      process.env.NODE_ENV !== 'production' ? warning(typeof inst.componentDidUnmount !== 'function', '%s has a method called ' + 'componentDidUnmount(). But there is no such lifecycle method. ' + 'Did you mean componentWillUnmount()?', this.getName() || 'A component') : void 0;
+	      process.env.NODE_ENV !== 'production' ? warning(typeof inst.componentWillRecieveProps !== 'function', '%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', this.getName() || 'A component') : void 0;
+	    }
+
+	    var initialState = inst.state;
+	    if (initialState === undefined) {
+	      inst.state = initialState = null;
+	    }
+	    !(typeof initialState === 'object' && !Array.isArray(initialState)) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.state: must be set to an object or null', this.getName() || 'ReactCompositeComponent') : _prodInvariant('106', this.getName() || 'ReactCompositeComponent') : void 0;
+
+	    this._pendingStateQueue = null;
+	    this._pendingReplaceState = false;
+	    this._pendingForceUpdate = false;
+
+	    var markup;
+	    if (inst.unstable_handleError) {
+	      markup = this.performInitialMountWithErrorHandling(renderedElement, hostParent, hostContainerInfo, transaction, context);
+	    } else {
+	      markup = this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context);
+	    }
+
+	    if (inst.componentDidMount) {
+	      if (process.env.NODE_ENV !== 'production') {
+	        transaction.getReactMountReady().enqueue(function () {
+	          measureLifeCyclePerf(function () {
+	            return inst.componentDidMount();
+	          }, _this._debugID, 'componentDidMount');
+	        });
+	      } else {
+	        transaction.getReactMountReady().enqueue(inst.componentDidMount, inst);
+	      }
+	    }
+
+	    return markup;
+	  },
+
+	  _constructComponent: function (doConstruct, publicProps, publicContext, updateQueue) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      ReactCurrentOwner.current = this;
+	      try {
+	        return this._constructComponentWithoutOwner(doConstruct, publicProps, publicContext, updateQueue);
+	      } finally {
+	        ReactCurrentOwner.current = null;
+	      }
+	    } else {
+	      return this._constructComponentWithoutOwner(doConstruct, publicProps, publicContext, updateQueue);
+	    }
+	  },
+
+	  _constructComponentWithoutOwner: function (doConstruct, publicProps, publicContext, updateQueue) {
+	    var Component = this._currentElement.type;
+
+	    if (doConstruct) {
+	      if (process.env.NODE_ENV !== 'production') {
+	        return measureLifeCyclePerf(function () {
+	          return new Component(publicProps, publicContext, updateQueue);
+	        }, this._debugID, 'ctor');
+	      } else {
+	        return new Component(publicProps, publicContext, updateQueue);
+	      }
+	    }
+
+	    // This can still be an instance in case of factory components
+	    // but we'll count this as time spent rendering as the more common case.
+	    if (process.env.NODE_ENV !== 'production') {
+	      return measureLifeCyclePerf(function () {
+	        return Component(publicProps, publicContext, updateQueue);
+	      }, this._debugID, 'render');
+	    } else {
+	      return Component(publicProps, publicContext, updateQueue);
+	    }
+	  },
+
+	  performInitialMountWithErrorHandling: function (renderedElement, hostParent, hostContainerInfo, transaction, context) {
+	    var markup;
+	    var checkpoint = transaction.checkpoint();
+	    try {
+	      markup = this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context);
+	    } catch (e) {
+	      // Roll back to checkpoint, handle error (which may add items to the transaction), and take a new checkpoint
+	      transaction.rollback(checkpoint);
+	      this._instance.unstable_handleError(e);
+	      if (this._pendingStateQueue) {
+	        this._instance.state = this._processPendingState(this._instance.props, this._instance.context);
+	      }
+	      checkpoint = transaction.checkpoint();
+
+	      this._renderedComponent.unmountComponent(true);
+	      transaction.rollback(checkpoint);
+
+	      // Try again - we've informed the component about the error, so they can render an error message this time.
+	      // If this throws again, the error will bubble up (and can be caught by a higher error boundary).
+	      markup = this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context);
+	    }
+	    return markup;
+	  },
+
+	  performInitialMount: function (renderedElement, hostParent, hostContainerInfo, transaction, context) {
+	    var inst = this._instance;
+
+	    var debugID = 0;
+	    if (process.env.NODE_ENV !== 'production') {
+	      debugID = this._debugID;
+	    }
+
+	    if (inst.componentWillMount) {
+	      if (process.env.NODE_ENV !== 'production') {
+	        measureLifeCyclePerf(function () {
+	          return inst.componentWillMount();
+	        }, debugID, 'componentWillMount');
+	      } else {
+	        inst.componentWillMount();
+	      }
+	      // When mounting, calls to `setState` by `componentWillMount` will set
+	      // `this._pendingStateQueue` without triggering a re-render.
+	      if (this._pendingStateQueue) {
+	        inst.state = this._processPendingState(inst.props, inst.context);
+	      }
+	    }
+
+	    // If not a stateless component, we now render
+	    if (renderedElement === undefined) {
+	      renderedElement = this._renderValidatedComponent();
+	    }
+
+	    var nodeType = ReactNodeTypes.getType(renderedElement);
+	    this._renderedNodeType = nodeType;
+	    var child = this._instantiateReactComponent(renderedElement, nodeType !== ReactNodeTypes.EMPTY /* shouldHaveDebugID */
+	    );
+	    this._renderedComponent = child;
+
+	    var markup = ReactReconciler.mountComponent(child, transaction, hostParent, hostContainerInfo, this._processChildContext(context), debugID);
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      if (debugID !== 0) {
+	        var childDebugIDs = child._debugID !== 0 ? [child._debugID] : [];
+	        ReactInstrumentation.debugTool.onSetChildren(debugID, childDebugIDs);
+	      }
+	    }
+
+	    return markup;
+	  },
+
+	  getHostNode: function () {
+	    return ReactReconciler.getHostNode(this._renderedComponent);
+	  },
+
+	  /**
+	   * Releases any resources allocated by `mountComponent`.
+	   *
+	   * @final
+	   * @internal
+	   */
+	  unmountComponent: function (safely) {
+	    if (!this._renderedComponent) {
+	      return;
+	    }
+
+	    var inst = this._instance;
+
+	    if (inst.componentWillUnmount && !inst._calledComponentWillUnmount) {
+	      inst._calledComponentWillUnmount = true;
+
+	      if (safely) {
+	        var name = this.getName() + '.componentWillUnmount()';
+	        ReactErrorUtils.invokeGuardedCallback(name, inst.componentWillUnmount.bind(inst));
+	      } else {
+	        if (process.env.NODE_ENV !== 'production') {
+	          measureLifeCyclePerf(function () {
+	            return inst.componentWillUnmount();
+	          }, this._debugID, 'componentWillUnmount');
+	        } else {
+	          inst.componentWillUnmount();
+	        }
+	      }
+	    }
+
+	    if (this._renderedComponent) {
+	      ReactReconciler.unmountComponent(this._renderedComponent, safely);
+	      this._renderedNodeType = null;
+	      this._renderedComponent = null;
+	      this._instance = null;
+	    }
+
+	    // Reset pending fields
+	    // Even if this component is scheduled for another update in ReactUpdates,
+	    // it would still be ignored because these fields are reset.
+	    this._pendingStateQueue = null;
+	    this._pendingReplaceState = false;
+	    this._pendingForceUpdate = false;
+	    this._pendingCallbacks = null;
+	    this._pendingElement = null;
+
+	    // These fields do not really need to be reset since this object is no
+	    // longer accessible.
+	    this._context = null;
+	    this._rootNodeID = 0;
+	    this._topLevelWrapper = null;
+
+	    // Delete the reference from the instance to this internal representation
+	    // which allow the internals to be properly cleaned up even if the user
+	    // leaks a reference to the public instance.
+	    ReactInstanceMap.remove(inst);
+
+	    // Some existing components rely on inst.props even after they've been
+	    // destroyed (in event handlers).
+	    // TODO: inst.props = null;
+	    // TODO: inst.state = null;
+	    // TODO: inst.context = null;
+	  },
+
+	  /**
+	   * Filters the context object to only contain keys specified in
+	   * `contextTypes`
+	   *
+	   * @param {object} context
+	   * @return {?object}
+	   * @private
+	   */
+	  _maskContext: function (context) {
+	    var Component = this._currentElement.type;
+	    var contextTypes = Component.contextTypes;
+	    if (!contextTypes) {
+	      return emptyObject;
+	    }
+	    var maskedContext = {};
+	    for (var contextName in contextTypes) {
+	      maskedContext[contextName] = context[contextName];
+	    }
+	    return maskedContext;
+	  },
+
+	  /**
+	   * Filters the context object to only contain keys specified in
+	   * `contextTypes`, and asserts that they are valid.
+	   *
+	   * @param {object} context
+	   * @return {?object}
+	   * @private
+	   */
+	  _processContext: function (context) {
+	    var maskedContext = this._maskContext(context);
+	    if (process.env.NODE_ENV !== 'production') {
+	      var Component = this._currentElement.type;
+	      if (Component.contextTypes) {
+	        this._checkContextTypes(Component.contextTypes, maskedContext, 'context');
+	      }
+	    }
+	    return maskedContext;
+	  },
+
+	  /**
+	   * @param {object} currentContext
+	   * @return {object}
+	   * @private
+	   */
+	  _processChildContext: function (currentContext) {
+	    var Component = this._currentElement.type;
+	    var inst = this._instance;
+	    var childContext;
+
+	    if (inst.getChildContext) {
+	      if (process.env.NODE_ENV !== 'production') {
+	        ReactInstrumentation.debugTool.onBeginProcessingChildContext();
+	        try {
+	          childContext = inst.getChildContext();
+	        } finally {
+	          ReactInstrumentation.debugTool.onEndProcessingChildContext();
+	        }
+	      } else {
+	        childContext = inst.getChildContext();
+	      }
+	    }
+
+	    if (childContext) {
+	      !(typeof Component.childContextTypes === 'object') ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.getChildContext(): childContextTypes must be defined in order to use getChildContext().', this.getName() || 'ReactCompositeComponent') : _prodInvariant('107', this.getName() || 'ReactCompositeComponent') : void 0;
+	      if (process.env.NODE_ENV !== 'production') {
+	        this._checkContextTypes(Component.childContextTypes, childContext, 'childContext');
+	      }
+	      for (var name in childContext) {
+	        !(name in Component.childContextTypes) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', this.getName() || 'ReactCompositeComponent', name) : _prodInvariant('108', this.getName() || 'ReactCompositeComponent', name) : void 0;
+	      }
+	      return _assign({}, currentContext, childContext);
+	    }
+	    return currentContext;
+	  },
+
+	  /**
+	   * Assert that the context types are valid
+	   *
+	   * @param {object} typeSpecs Map of context field to a ReactPropType
+	   * @param {object} values Runtime values that need to be type-checked
+	   * @param {string} location e.g. "prop", "context", "child context"
+	   * @private
+	   */
+	  _checkContextTypes: function (typeSpecs, values, location) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      checkReactTypeSpec(typeSpecs, values, location, this.getName(), null, this._debugID);
+	    }
+	  },
+
+	  receiveComponent: function (nextElement, transaction, nextContext) {
+	    var prevElement = this._currentElement;
+	    var prevContext = this._context;
+
+	    this._pendingElement = null;
+
+	    this.updateComponent(transaction, prevElement, nextElement, prevContext, nextContext);
+	  },
+
+	  /**
+	   * If any of `_pendingElement`, `_pendingStateQueue`, or `_pendingForceUpdate`
+	   * is set, update the component.
+	   *
+	   * @param {ReactReconcileTransaction} transaction
+	   * @internal
+	   */
+	  performUpdateIfNecessary: function (transaction) {
+	    if (this._pendingElement != null) {
+	      ReactReconciler.receiveComponent(this, this._pendingElement, transaction, this._context);
+	    } else if (this._pendingStateQueue !== null || this._pendingForceUpdate) {
+	      this.updateComponent(transaction, this._currentElement, this._currentElement, this._context, this._context);
+	    } else {
+	      this._updateBatchNumber = null;
+	    }
+	  },
+
+	  /**
+	   * Perform an update to a mounted component. The componentWillReceiveProps and
+	   * shouldComponentUpdate methods are called, then (assuming the update isn't
+	   * skipped) the remaining update lifecycle methods are called and the DOM
+	   * representation is updated.
+	   *
+	   * By default, this implements React's rendering and reconciliation algorithm.
+	   * Sophisticated clients may wish to override this.
+	   *
+	   * @param {ReactReconcileTransaction} transaction
+	   * @param {ReactElement} prevParentElement
+	   * @param {ReactElement} nextParentElement
+	   * @internal
+	   * @overridable
+	   */
+	  updateComponent: function (transaction, prevParentElement, nextParentElement, prevUnmaskedContext, nextUnmaskedContext) {
+	    var inst = this._instance;
+	    !(inst != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Attempted to update component `%s` that has already been unmounted (or failed to mount).', this.getName() || 'ReactCompositeComponent') : _prodInvariant('136', this.getName() || 'ReactCompositeComponent') : void 0;
+
+	    var willReceive = false;
+	    var nextContext;
+
+	    // Determine if the context has changed or not
+	    if (this._context === nextUnmaskedContext) {
+	      nextContext = inst.context;
+	    } else {
+	      nextContext = this._processContext(nextUnmaskedContext);
+	      willReceive = true;
+	    }
+
+	    var prevProps = prevParentElement.props;
+	    var nextProps = nextParentElement.props;
+
+	    // Not a simple state update but a props update
+	    if (prevParentElement !== nextParentElement) {
+	      willReceive = true;
+	    }
+
+	    // An update here will schedule an update but immediately set
+	    // _pendingStateQueue which will ensure that any state updates gets
+	    // immediately reconciled instead of waiting for the next batch.
+	    if (willReceive && inst.componentWillReceiveProps) {
+	      if (process.env.NODE_ENV !== 'production') {
+	        measureLifeCyclePerf(function () {
+	          return inst.componentWillReceiveProps(nextProps, nextContext);
+	        }, this._debugID, 'componentWillReceiveProps');
+	      } else {
+	        inst.componentWillReceiveProps(nextProps, nextContext);
+	      }
+	    }
+
+	    var nextState = this._processPendingState(nextProps, nextContext);
+	    var shouldUpdate = true;
+
+	    if (!this._pendingForceUpdate) {
+	      if (inst.shouldComponentUpdate) {
+	        if (process.env.NODE_ENV !== 'production') {
+	          shouldUpdate = measureLifeCyclePerf(function () {
+	            return inst.shouldComponentUpdate(nextProps, nextState, nextContext);
+	          }, this._debugID, 'shouldComponentUpdate');
+	        } else {
+	          shouldUpdate = inst.shouldComponentUpdate(nextProps, nextState, nextContext);
+	        }
+	      } else {
+	        if (this._compositeType === CompositeTypes.PureClass) {
+	          shouldUpdate = !shallowEqual(prevProps, nextProps) || !shallowEqual(inst.state, nextState);
+	        }
+	      }
+	    }
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      process.env.NODE_ENV !== 'production' ? warning(shouldUpdate !== undefined, '%s.shouldComponentUpdate(): Returned undefined instead of a ' + 'boolean value. Make sure to return true or false.', this.getName() || 'ReactCompositeComponent') : void 0;
+	    }
+
+	    this._updateBatchNumber = null;
+	    if (shouldUpdate) {
+	      this._pendingForceUpdate = false;
+	      // Will set `this.props`, `this.state` and `this.context`.
+	      this._performComponentUpdate(nextParentElement, nextProps, nextState, nextContext, transaction, nextUnmaskedContext);
+	    } else {
+	      // If it's determined that a component should not update, we still want
+	      // to set props and state but we shortcut the rest of the update.
+	      this._currentElement = nextParentElement;
+	      this._context = nextUnmaskedContext;
+	      inst.props = nextProps;
+	      inst.state = nextState;
+	      inst.context = nextContext;
+	    }
+	  },
+
+	  _processPendingState: function (props, context) {
+	    var inst = this._instance;
+	    var queue = this._pendingStateQueue;
+	    var replace = this._pendingReplaceState;
+	    this._pendingReplaceState = false;
+	    this._pendingStateQueue = null;
+
+	    if (!queue) {
+	      return inst.state;
+	    }
+
+	    if (replace && queue.length === 1) {
+	      return queue[0];
+	    }
+
+	    var nextState = _assign({}, replace ? queue[0] : inst.state);
+	    for (var i = replace ? 1 : 0; i < queue.length; i++) {
+	      var partial = queue[i];
+	      _assign(nextState, typeof partial === 'function' ? partial.call(inst, nextState, props, context) : partial);
+	    }
+
+	    return nextState;
+	  },
+
+	  /**
+	   * Merges new props and state, notifies delegate methods of update and
+	   * performs update.
+	   *
+	   * @param {ReactElement} nextElement Next element
+	   * @param {object} nextProps Next public object to set as properties.
+	   * @param {?object} nextState Next object to set as state.
+	   * @param {?object} nextContext Next public object to set as context.
+	   * @param {ReactReconcileTransaction} transaction
+	   * @param {?object} unmaskedContext
+	   * @private
+	   */
+	  _performComponentUpdate: function (nextElement, nextProps, nextState, nextContext, transaction, unmaskedContext) {
+	    var _this2 = this;
+
+	    var inst = this._instance;
+
+	    var hasComponentDidUpdate = Boolean(inst.componentDidUpdate);
+	    var prevProps;
+	    var prevState;
+	    var prevContext;
+	    if (hasComponentDidUpdate) {
+	      prevProps = inst.props;
+	      prevState = inst.state;
+	      prevContext = inst.context;
+	    }
+
+	    if (inst.componentWillUpdate) {
+	      if (process.env.NODE_ENV !== 'production') {
+	        measureLifeCyclePerf(function () {
+	          return inst.componentWillUpdate(nextProps, nextState, nextContext);
+	        }, this._debugID, 'componentWillUpdate');
+	      } else {
+	        inst.componentWillUpdate(nextProps, nextState, nextContext);
+	      }
+	    }
+
+	    this._currentElement = nextElement;
+	    this._context = unmaskedContext;
+	    inst.props = nextProps;
+	    inst.state = nextState;
+	    inst.context = nextContext;
+
+	    this._updateRenderedComponent(transaction, unmaskedContext);
+
+	    if (hasComponentDidUpdate) {
+	      if (process.env.NODE_ENV !== 'production') {
+	        transaction.getReactMountReady().enqueue(function () {
+	          measureLifeCyclePerf(inst.componentDidUpdate.bind(inst, prevProps, prevState, prevContext), _this2._debugID, 'componentDidUpdate');
+	        });
+	      } else {
+	        transaction.getReactMountReady().enqueue(inst.componentDidUpdate.bind(inst, prevProps, prevState, prevContext), inst);
+	      }
+	    }
+	  },
+
+	  /**
+	   * Call the component's `render` method and update the DOM accordingly.
+	   *
+	   * @param {ReactReconcileTransaction} transaction
+	   * @internal
+	   */
+	  _updateRenderedComponent: function (transaction, context) {
+	    var prevComponentInstance = this._renderedComponent;
+	    var prevRenderedElement = prevComponentInstance._currentElement;
+	    var nextRenderedElement = this._renderValidatedComponent();
+
+	    var debugID = 0;
+	    if (process.env.NODE_ENV !== 'production') {
+	      debugID = this._debugID;
+	    }
+
+	    if (shouldUpdateReactComponent(prevRenderedElement, nextRenderedElement)) {
+	      ReactReconciler.receiveComponent(prevComponentInstance, nextRenderedElement, transaction, this._processChildContext(context));
+	    } else {
+	      var oldHostNode = ReactReconciler.getHostNode(prevComponentInstance);
+	      ReactReconciler.unmountComponent(prevComponentInstance, false);
+
+	      var nodeType = ReactNodeTypes.getType(nextRenderedElement);
+	      this._renderedNodeType = nodeType;
+	      var child = this._instantiateReactComponent(nextRenderedElement, nodeType !== ReactNodeTypes.EMPTY /* shouldHaveDebugID */
+	      );
+	      this._renderedComponent = child;
+
+	      var nextMarkup = ReactReconciler.mountComponent(child, transaction, this._hostParent, this._hostContainerInfo, this._processChildContext(context), debugID);
+
+	      if (process.env.NODE_ENV !== 'production') {
+	        if (debugID !== 0) {
+	          var childDebugIDs = child._debugID !== 0 ? [child._debugID] : [];
+	          ReactInstrumentation.debugTool.onSetChildren(debugID, childDebugIDs);
+	        }
+	      }
+
+	      this._replaceNodeWithMarkup(oldHostNode, nextMarkup, prevComponentInstance);
+	    }
+	  },
+
+	  /**
+	   * Overridden in shallow rendering.
+	   *
+	   * @protected
+	   */
+	  _replaceNodeWithMarkup: function (oldHostNode, nextMarkup, prevInstance) {
+	    ReactComponentEnvironment.replaceNodeWithMarkup(oldHostNode, nextMarkup, prevInstance);
+	  },
+
+	  /**
+	   * @protected
+	   */
+	  _renderValidatedComponentWithoutOwnerOrContext: function () {
+	    var inst = this._instance;
+	    var renderedElement;
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      renderedElement = measureLifeCyclePerf(function () {
+	        return inst.render();
+	      }, this._debugID, 'render');
+	    } else {
+	      renderedElement = inst.render();
+	    }
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      // We allow auto-mocks to proceed as if they're returning null.
+	      if (renderedElement === undefined && inst.render._isMockFunction) {
+	        // This is probably bad practice. Consider warning here and
+	        // deprecating this convenience.
+	        renderedElement = null;
+	      }
+	    }
+
+	    return renderedElement;
+	  },
+
+	  /**
+	   * @private
+	   */
+	  _renderValidatedComponent: function () {
+	    var renderedElement;
+	    if (process.env.NODE_ENV !== 'production' || this._compositeType !== CompositeTypes.StatelessFunctional) {
+	      ReactCurrentOwner.current = this;
+	      try {
+	        renderedElement = this._renderValidatedComponentWithoutOwnerOrContext();
+	      } finally {
+	        ReactCurrentOwner.current = null;
+	      }
+	    } else {
+	      renderedElement = this._renderValidatedComponentWithoutOwnerOrContext();
+	    }
+	    !(
+	    // TODO: An `isValidNode` function would probably be more appropriate
+	    renderedElement === null || renderedElement === false || React.isValidElement(renderedElement)) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.render(): A valid React element (or null) must be returned. You may have returned undefined, an array or some other invalid object.', this.getName() || 'ReactCompositeComponent') : _prodInvariant('109', this.getName() || 'ReactCompositeComponent') : void 0;
+
+	    return renderedElement;
+	  },
+
+	  /**
+	   * 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) {
+	    var inst = this.getPublicInstance();
+	    !(inst != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Stateless function components cannot have refs.') : _prodInvariant('110') : void 0;
+	    var publicComponentInstance = component.getPublicInstance();
+	    if (process.env.NODE_ENV !== 'production') {
+	      var componentName = component && component.getName ? component.getName() : 'a component';
+	      process.env.NODE_ENV !== 'production' ? warning(publicComponentInstance != null || component._compositeType !== CompositeTypes.StatelessFunctional, 'Stateless function components cannot be given refs ' + '(See ref "%s" in %s created by %s). ' + 'Attempts to access this ref will fail.', ref, componentName, this.getName()) : void 0;
+	    }
+	    var refs = inst.refs === emptyObject ? inst.refs = {} : inst.refs;
+	    refs[ref] = publicComponentInstance;
+	  },
+
+	  /**
+	   * Detaches a reference name.
+	   *
+	   * @param {string} ref Name to dereference.
+	   * @final
+	   * @private
+	   */
+	  detachRef: function (ref) {
+	    var refs = this.getPublicInstance().refs;
+	    delete refs[ref];
+	  },
+
+	  /**
+	   * Get a text description of the component that can be used to identify it
+	   * in error messages.
+	   * @return {string} The name or null.
+	   * @internal
+	   */
+	  getName: function () {
+	    var type = this._currentElement.type;
+	    var constructor = this._instance && this._instance.constructor;
+	    return type.displayName || constructor && constructor.displayName || type.name || constructor && constructor.name || null;
+	  },
+
+	  /**
+	   * Get the publicly accessible representation of this component - i.e. what
+	   * is exposed by refs and returned by render. Can be null for stateless
+	   * components.
+	   *
+	   * @return {ReactComponent} the public component instance.
+	   * @internal
+	   */
+	  getPublicInstance: function () {
+	    var inst = this._instance;
+	    if (this._compositeType === CompositeTypes.StatelessFunctional) {
+	      return null;
+	    }
+	    return inst;
+	  },
+
+	  // Stub
+	  _instantiateReactComponent: null
+
+	};
+
+	module.exports = ReactCompositeComponent;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 124 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var React = __webpack_require__(2);
+
+	var invariant = __webpack_require__(37);
+
+	var ReactNodeTypes = {
+	  HOST: 0,
+	  COMPOSITE: 1,
+	  EMPTY: 2,
+
+	  getType: function (node) {
+	    if (node === null || node === false) {
+	      return ReactNodeTypes.EMPTY;
+	    } else if (React.isValidElement(node)) {
+	      if (typeof node.type === 'function') {
+	        return ReactNodeTypes.COMPOSITE;
+	      } else {
+	        return ReactNodeTypes.HOST;
+	      }
+	    }
+	     true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Unexpected node: %s', node) : _prodInvariant('26', node) : void 0;
+	  }
+	};
+
+	module.exports = ReactNodeTypes;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 125 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var ReactPropTypeLocationNames = __webpack_require__(126);
+	var ReactPropTypesSecret = __webpack_require__(114);
+
+	var invariant = __webpack_require__(37);
+	var warning = __webpack_require__(47);
+
+	var ReactComponentTreeHook;
+
+	if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV === 'test') {
+	  // Temporary hack.
+	  // Inline requires don't work well with Jest:
+	  // https://github.com/facebook/react/issues/7240
+	  // Remove the inline requires when we don't need them anymore:
+	  // https://github.com/facebook/react/pull/7178
+	  ReactComponentTreeHook = __webpack_require__(26);
+	}
+
+	var loggedTypeFailures = {};
+
+	/**
+	 * Assert that the values match with the type specs.
+	 * Error messages are memorized and will only be shown once.
+	 *
+	 * @param {object} typeSpecs Map of name to a ReactPropType
+	 * @param {object} values Runtime values that need to be type-checked
+	 * @param {string} location e.g. "prop", "context", "child context"
+	 * @param {string} componentName Name of the component for error messages.
+	 * @param {?object} element The React element that is being type-checked
+	 * @param {?number} debugID The React component instance that is being type-checked
+	 * @private
+	 */
+	function checkReactTypeSpec(typeSpecs, values, location, componentName, element, debugID) {
+	  for (var typeSpecName in typeSpecs) {
+	    if (typeSpecs.hasOwnProperty(typeSpecName)) {
+	      var error;
+	      // Prop type validation may throw. In case they do, we don't want to
+	      // fail the render phase where it didn't fail before. So we log it.
+	      // After these have been cleaned up, we'll let them throw.
+	      try {
+	        // This is intentionally an invariant that gets caught. It's the same
+	        // behavior as without this statement except with a better message.
+	        !(typeof typeSpecs[typeSpecName] === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s: %s type `%s` is invalid; it must be a function, usually from React.PropTypes.', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName) : _prodInvariant('84', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName) : void 0;
+	        error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+	      } catch (ex) {
+	        error = ex;
+	      }
+	      process.env.NODE_ENV !== 'production' ? warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName, typeof error) : void 0;
+	      if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+	        // Only monitor this failure once because there tends to be a lot of the
+	        // same error.
+	        loggedTypeFailures[error.message] = true;
+
+	        var componentStackInfo = '';
+
+	        if (process.env.NODE_ENV !== 'production') {
+	          if (!ReactComponentTreeHook) {
+	            ReactComponentTreeHook = __webpack_require__(26);
+	          }
+	          if (debugID !== null) {
+	            componentStackInfo = ReactComponentTreeHook.getStackAddendumByID(debugID);
+	          } else if (element !== null) {
+	            componentStackInfo = ReactComponentTreeHook.getCurrentStackAddendum(element);
+	          }
+	        }
+
+	        process.env.NODE_ENV !== 'production' ? warning(false, 'Failed %s type: %s%s', location, error.message, componentStackInfo) : void 0;
+	      }
+	    }
+	  }
+	}
+
+	module.exports = checkReactTypeSpec;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 126 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var ReactPropTypeLocationNames = {};
+
+	if (process.env.NODE_ENV !== 'production') {
+	  ReactPropTypeLocationNames = {
+	    prop: 'prop',
+	    context: 'context',
+	    childContext: 'child context'
+	  };
+	}
+
+	module.exports = ReactPropTypeLocationNames;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 127 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var emptyObject = {};
+
+	if (process.env.NODE_ENV !== 'production') {
+	  Object.freeze(emptyObject);
+	}
+
+	module.exports = emptyObject;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 128 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * @typechecks
+	 * 
+	 */
+
+	/*eslint-disable no-self-compare */
+
+	'use strict';
+
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+	/**
+	 * inlined Object.is polyfill to avoid requiring consumers ship their own
+	 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+	 */
+	function is(x, y) {
+	  // SameValue algorithm
+	  if (x === y) {
+	    // Steps 1-5, 7-10
+	    // Steps 6.b-6.e: +0 != -0
+	    // Added the nonzero y check to make Flow happy, but it is redundant
+	    return x !== 0 || y !== 0 || 1 / x === 1 / y;
+	  } else {
+	    // Step 6.a: NaN == NaN
+	    return x !== x && y !== y;
+	  }
+	}
+
+	/**
+	 * Performs equality by iterating through keys on an object and returning false
+	 * when any key has values which are not strictly equal between the arguments.
+	 * Returns true when the values of all keys are strictly equal.
+	 */
+	function shallowEqual(objA, objB) {
+	  if (is(objA, objB)) {
+	    return true;
+	  }
+
+	  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
+	    return false;
+	  }
+
+	  var keysA = Object.keys(objA);
+	  var keysB = Object.keys(objB);
+
+	  if (keysA.length !== keysB.length) {
+	    return false;
+	  }
+
+	  // Test for A's keys different from B.
+	  for (var i = 0; i < keysA.length; i++) {
+	    if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
+	      return false;
+	    }
+	  }
+
+	  return true;
+	}
+
+	module.exports = shallowEqual;
+
+/***/ },
+/* 129 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	/**
+	 * Given a `prevElement` and `nextElement`, determines if the existing
+	 * instance should be updated as opposed to being destroyed or replaced by a new
+	 * instance. Both arguments are elements. This ensures that this logic can
+	 * operate on stateless trees without any backing instance.
+	 *
+	 * @param {?object} prevElement
+	 * @param {?object} nextElement
+	 * @return {boolean} True if the existing instance should be updated.
+	 * @protected
+	 */
+
+	function shouldUpdateReactComponent(prevElement, nextElement) {
+	  var prevEmpty = prevElement === null || prevElement === false;
+	  var nextEmpty = nextElement === null || nextElement === false;
+	  if (prevEmpty || nextEmpty) {
+	    return prevEmpty === nextEmpty;
+	  }
+
+	  var prevType = typeof prevElement;
+	  var nextType = typeof nextElement;
+	  if (prevType === 'string' || prevType === 'number') {
+	    return nextType === 'string' || nextType === 'number';
+	  } else {
+	    return nextType === 'object' && prevElement.type === nextElement.type && prevElement.key === nextElement.key;
+	  }
+	}
+
+	module.exports = shouldUpdateReactComponent;
+
+/***/ },
+/* 130 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2014-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var emptyComponentFactory;
+
+	var ReactEmptyComponentInjection = {
+	  injectEmptyComponentFactory: function (factory) {
+	    emptyComponentFactory = factory;
+	  }
+	};
+
+	var ReactEmptyComponent = {
+	  create: function (instantiate) {
+	    return emptyComponentFactory(instantiate);
+	  }
+	};
+
+	ReactEmptyComponent.injection = ReactEmptyComponentInjection;
+
+	module.exports = ReactEmptyComponent;
+
+/***/ },
+/* 131 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2014-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35),
+	    _assign = __webpack_require__(53);
+
+	var invariant = __webpack_require__(37);
+
+	var genericComponentClass = null;
+	// This registry keeps track of wrapper classes around host tags.
+	var tagToComponentClass = {};
+	var textComponentClass = null;
+
+	var ReactHostComponentInjection = {
+	  // This accepts a class that receives the tag string. This is a catch all
+	  // that can render any kind of tag.
+	  injectGenericComponentClass: function (componentClass) {
+	    genericComponentClass = componentClass;
+	  },
+	  // This accepts a text component class that takes the text string to be
+	  // rendered as props.
+	  injectTextComponentClass: function (componentClass) {
+	    textComponentClass = componentClass;
+	  },
+	  // This accepts a keyed object with classes as values. Each key represents a
+	  // tag. That particular tag will use this class instead of the generic one.
+	  injectComponentClasses: function (componentClasses) {
+	    _assign(tagToComponentClass, componentClasses);
+	  }
+	};
+
+	/**
+	 * Get a host internal component class for a specific tag.
+	 *
+	 * @param {ReactElement} element The element to create.
+	 * @return {function} The internal class constructor function.
+	 */
+	function createInternalComponent(element) {
+	  !genericComponentClass ? process.env.NODE_ENV !== 'production' ? invariant(false, 'There is no registered component for the tag %s', element.type) : _prodInvariant('111', element.type) : void 0;
+	  return new genericComponentClass(element);
+	}
+
+	/**
+	 * @param {ReactText} text
+	 * @return {ReactComponent}
+	 */
+	function createInstanceForText(text) {
+	  return new textComponentClass(text);
+	}
+
+	/**
+	 * @param {ReactComponent} component
+	 * @return {boolean}
+	 */
+	function isTextComponent(component) {
+	  return component instanceof textComponentClass;
+	}
+
+	var ReactHostComponent = {
+	  createInternalComponent: createInternalComponent,
+	  createInstanceForText: createInstanceForText,
+	  isTextComponent: isTextComponent,
+	  injection: ReactHostComponentInjection
+	};
+
+	module.exports = ReactHostComponent;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 132 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var nextDebugID = 1;
+
+	function getNextDebugID() {
+	  return nextDebugID++;
+	}
+
+	module.exports = getNextDebugID;
+
+/***/ },
+/* 133 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	/**
+	 * Escape and wrap key so it is safe to use as a reactid
+	 *
+	 * @param {string} key to be escaped.
+	 * @return {string} the escaped key.
+	 */
+
+	function escape(key) {
+	  var escapeRegex = /[=:]/g;
+	  var escaperLookup = {
+	    '=': '=0',
+	    ':': '=2'
+	  };
+	  var escapedString = ('' + key).replace(escapeRegex, function (match) {
+	    return escaperLookup[match];
+	  });
+
+	  return '$' + escapedString;
+	}
+
+	/**
+	 * Unescape and unwrap key for human-readable display
+	 *
+	 * @param {string} key to unescape.
+	 * @return {string} the unescaped key.
+	 */
+	function unescape(key) {
+	  var unescapeRegex = /(=0|=2)/g;
+	  var unescaperLookup = {
+	    '=0': '=',
+	    '=2': ':'
+	  };
+	  var keySubstring = key[0] === '.' && key[1] === '$' ? key.substring(2) : key.substring(1);
+
+	  return ('' + keySubstring).replace(unescapeRegex, function (match) {
+	    return unescaperLookup[match];
+	  });
+	}
+
+	var KeyEscapeUtils = {
+	  escape: escape,
+	  unescape: unescape
+	};
+
+	module.exports = KeyEscapeUtils;
+
+/***/ },
+/* 134 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var ReactCurrentOwner = __webpack_require__(10);
+	var REACT_ELEMENT_TYPE = __webpack_require__(135);
+
+	var getIteratorFn = __webpack_require__(136);
+	var invariant = __webpack_require__(37);
+	var KeyEscapeUtils = __webpack_require__(133);
+	var warning = __webpack_require__(47);
+
+	var SEPARATOR = '.';
+	var SUBSEPARATOR = ':';
+
+	/**
+	 * This is inlined from ReactElement since this file is shared between
+	 * isomorphic and renderers. We could extract this to a
+	 *
+	 */
+
+	/**
+	 * TODO: Test that a single child and an array with one item have the same key
+	 * pattern.
+	 */
+
+	var didWarnAboutMaps = false;
+
+	/**
+	 * 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}
+	 */
+	function getComponentKey(component, index) {
+	  // Do some typechecking here since we call this blindly. We want to ensure
+	  // that we don't block potential future ES APIs.
+	  if (component && typeof component === 'object' && component.key != null) {
+	    // Explicit key
+	    return KeyEscapeUtils.escape(component.key);
+	  }
+	  // Implicit key determined by the index in the set
+	  return index.toString(36);
+	}
+
+	/**
+	 * @param {?*} children Children tree container.
+	 * @param {!string} nameSoFar Name of the key path so far.
+	 * @param {!function} callback Callback to invoke with each child found.
+	 * @param {?*} traverseContext Used to pass information throughout the traversal
+	 * process.
+	 * @return {!number} The number of children in this subtree.
+	 */
+	function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {
+	  var type = typeof children;
+
+	  if (type === 'undefined' || type === 'boolean') {
+	    // All of the above are perceived as null.
+	    children = null;
+	  }
+
+	  if (children === null || type === 'string' || type === 'number' ||
+	  // The following is inlined from ReactElement. This means we can optimize
+	  // some checks. React Fiber also inlines this logic for similar purposes.
+	  type === 'object' && children.$$typeof === REACT_ELEMENT_TYPE) {
+	    callback(traverseContext, children,
+	    // 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.
+	    nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);
+	    return 1;
+	  }
+
+	  var child;
+	  var nextName;
+	  var subtreeCount = 0; // Count of children found in the current subtree.
+	  var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;
+
+	  if (Array.isArray(children)) {
+	    for (var i = 0; i < children.length; i++) {
+	      child = children[i];
+	      nextName = nextNamePrefix + getComponentKey(child, i);
+	      subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
+	    }
+	  } else {
+	    var iteratorFn = getIteratorFn(children);
+	    if (iteratorFn) {
+	      var iterator = iteratorFn.call(children);
+	      var step;
+	      if (iteratorFn !== children.entries) {
+	        var ii = 0;
+	        while (!(step = iterator.next()).done) {
+	          child = step.value;
+	          nextName = nextNamePrefix + getComponentKey(child, ii++);
+	          subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
+	        }
+	      } else {
+	        if (process.env.NODE_ENV !== 'production') {
+	          var mapsAsChildrenAddendum = '';
+	          if (ReactCurrentOwner.current) {
+	            var mapsAsChildrenOwnerName = ReactCurrentOwner.current.getName();
+	            if (mapsAsChildrenOwnerName) {
+	              mapsAsChildrenAddendum = ' Check the render method of `' + mapsAsChildrenOwnerName + '`.';
+	            }
+	          }
+	          process.env.NODE_ENV !== 'production' ? warning(didWarnAboutMaps, 'Using Maps as children is not yet fully supported. It is an ' + 'experimental feature that might be removed. Convert it to a ' + 'sequence / iterable of keyed ReactElements instead.%s', mapsAsChildrenAddendum) : void 0;
+	          didWarnAboutMaps = true;
+	        }
+	        // Iterator will provide entry [k,v] tuples rather than values.
+	        while (!(step = iterator.next()).done) {
+	          var entry = step.value;
+	          if (entry) {
+	            child = entry[1];
+	            nextName = nextNamePrefix + KeyEscapeUtils.escape(entry[0]) + SUBSEPARATOR + getComponentKey(child, 0);
+	            subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
+	          }
+	        }
+	      }
+	    } else if (type === 'object') {
+	      var addendum = '';
+	      if (process.env.NODE_ENV !== 'production') {
+	        addendum = ' If you meant to render a collection of children, use an array ' + 'instead or wrap the object using createFragment(object) from the ' + 'React add-ons.';
+	        if (children._isReactElement) {
+	          addendum = ' It looks like you\'re using an element created by a different ' + 'version of React. Make sure to use only one copy of React.';
+	        }
+	        if (ReactCurrentOwner.current) {
+	          var name = ReactCurrentOwner.current.getName();
+	          if (name) {
+	            addendum += ' Check the render method of `' + name + '`.';
+	          }
+	        }
+	      }
+	      var childrenString = String(children);
+	       true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum) : _prodInvariant('31', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum) : void 0;
+	    }
+	  }
+
+	  return subtreeCount;
+	}
+
+	/**
+	 * Traverses children that are typically specified as `props.children`, but
+	 * might also be specified through attributes:
+	 *
+	 * - `traverseAllChildren(this.props.children, ...)`
+	 * - `traverseAllChildren(this.props.leftPanelChildren, ...)`
+	 *
+	 * The `traverseContext` is an optional argument that is passed through the
+	 * entire traversal. It can be used to store accumulations or anything else that
+	 * the callback might find relevant.
+	 *
+	 * @param {?*} children Children tree object.
+	 * @param {!function} callback To invoke upon traversing each child.
+	 * @param {?*} traverseContext Context for traversal.
+	 * @return {!number} The number of children in this subtree.
+	 */
+	function traverseAllChildren(children, callback, traverseContext) {
+	  if (children == null) {
+	    return 0;
+	  }
+
+	  return traverseAllChildrenImpl(children, '', callback, traverseContext);
+	}
+
+	module.exports = traverseAllChildren;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 135 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2014-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	// The Symbol used to tag the ReactElement type. If there is no native Symbol
+	// nor polyfill, then a plain number is used for performance.
+
+	var REACT_ELEMENT_TYPE = typeof Symbol === 'function' && Symbol['for'] && Symbol['for']('react.element') || 0xeac7;
+
+	module.exports = REACT_ELEMENT_TYPE;
+
+/***/ },
+/* 136 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	/* global Symbol */
+
+	var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
+	var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
+
+	/**
+	 * Returns the iterator method function contained on the iterable object.
+	 *
+	 * Be sure to invoke the function with the iterable as context:
+	 *
+	 *     var iteratorFn = getIteratorFn(myIterable);
+	 *     if (iteratorFn) {
+	 *       var iterator = iteratorFn.call(myIterable);
+	 *       ...
+	 *     }
+	 *
+	 * @param {?object} maybeIterable
+	 * @return {?function}
+	 */
+	function getIteratorFn(maybeIterable) {
+	  var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
+	  if (typeof iteratorFn === 'function') {
+	    return iteratorFn;
+	  }
+	}
+
+	module.exports = getIteratorFn;
+
+/***/ },
+/* 137 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var KeyEscapeUtils = __webpack_require__(133);
+	var traverseAllChildren = __webpack_require__(134);
+	var warning = __webpack_require__(47);
+
+	var ReactComponentTreeHook;
+
+	if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV === 'test') {
+	  // Temporary hack.
+	  // Inline requires don't work well with Jest:
+	  // https://github.com/facebook/react/issues/7240
+	  // Remove the inline requires when we don't need them anymore:
+	  // https://github.com/facebook/react/pull/7178
+	  ReactComponentTreeHook = __webpack_require__(26);
+	}
+
+	/**
+	 * @param {function} traverseContext Context passed through traversal.
+	 * @param {?ReactComponent} child React child component.
+	 * @param {!string} name String name of key path to child.
+	 * @param {number=} selfDebugID Optional debugID of the current internal instance.
+	 */
+	function flattenSingleChildIntoContext(traverseContext, child, name, selfDebugID) {
+	  // We found a component instance.
+	  if (traverseContext && typeof traverseContext === 'object') {
+	    var result = traverseContext;
+	    var keyUnique = result[name] === undefined;
+	    if (process.env.NODE_ENV !== 'production') {
+	      if (!ReactComponentTreeHook) {
+	        ReactComponentTreeHook = __webpack_require__(26);
+	      }
+	      if (!keyUnique) {
+	        process.env.NODE_ENV !== 'production' ? warning(false, 'flattenChildren(...): Encountered two children with the same key, ' + '`%s`. Child keys must be unique; when two children share a key, only ' + 'the first child will be used.%s', KeyEscapeUtils.unescape(name), ReactComponentTreeHook.getStackAddendumByID(selfDebugID)) : void 0;
+	      }
+	    }
+	    if (keyUnique && child != null) {
+	      result[name] = child;
+	    }
+	  }
+	}
+
+	/**
+	 * Flattens children that are typically specified as `props.children`. Any null
+	 * children will not be included in the resulting object.
+	 * @return {!object} flattened children keyed by name.
+	 */
+	function flattenChildren(children, selfDebugID) {
+	  if (children == null) {
+	    return children;
+	  }
+	  var result = {};
+
+	  if (process.env.NODE_ENV !== 'production') {
+	    traverseAllChildren(children, function (traverseContext, child, name) {
+	      return flattenSingleChildIntoContext(traverseContext, child, name, selfDebugID);
+	    }, result);
+	  } else {
+	    traverseAllChildren(children, flattenSingleChildIntoContext, result);
+	  }
+	  return result;
+	}
+
+	module.exports = flattenChildren;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 138 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2014-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _assign = __webpack_require__(53);
+
+	var PooledClass = __webpack_require__(54);
+	var Transaction = __webpack_require__(72);
+	var ReactInstrumentation = __webpack_require__(66);
+	var ReactServerUpdateQueue = __webpack_require__(139);
+
+	/**
+	 * 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 = [];
+
+	if (process.env.NODE_ENV !== 'production') {
+	  TRANSACTION_WRAPPERS.push({
+	    initialize: ReactInstrumentation.debugTool.onBeginFlush,
+	    close: ReactInstrumentation.debugTool.onEndFlush
+	  });
+	}
+
+	var noopCallbackQueue = {
+	  enqueue: function () {}
+	};
+
+	/**
+	 * @class ReactServerRenderingTransaction
+	 * @param {boolean} renderToStaticMarkup
+	 */
+	function ReactServerRenderingTransaction(renderToStaticMarkup) {
+	  this.reinitializeTransaction();
+	  this.renderToStaticMarkup = renderToStaticMarkup;
+	  this.useCreateElement = false;
+	  this.updateQueue = new ReactServerUpdateQueue(this);
+	}
+
+	var Mixin = {
+	  /**
+	   * @see Transaction
+	   * @abstract
+	   * @final
+	   * @return {array} Empty list of operation wrap procedures.
+	   */
+	  getTransactionWrappers: function () {
+	    return TRANSACTION_WRAPPERS;
+	  },
+
+	  /**
+	   * @return {object} The queue to collect `onDOMReady` callbacks with.
+	   */
+	  getReactMountReady: function () {
+	    return noopCallbackQueue;
+	  },
+
+	  /**
+	   * @return {object} The queue to collect React async events.
+	   */
+	  getUpdateQueue: function () {
+	    return this.updateQueue;
+	  },
+
+	  /**
+	   * `PooledClass` looks for this, and will invoke this before allowing this
+	   * instance to be reused.
+	   */
+	  destructor: function () {},
+
+	  checkpoint: function () {},
+
+	  rollback: function () {}
+	};
+
+	_assign(ReactServerRenderingTransaction.prototype, Transaction, Mixin);
+
+	PooledClass.addPoolingTo(ReactServerRenderingTransaction);
+
+	module.exports = ReactServerRenderingTransaction;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 139 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2015-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var ReactUpdateQueue = __webpack_require__(140);
+
+	var warning = __webpack_require__(47);
+
+	function warnNoop(publicInstance, callerName) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    var constructor = publicInstance.constructor;
+	    process.env.NODE_ENV !== 'production' ? warning(false, '%s(...): Can only update a mounting component. ' + 'This usually means you called %s() outside componentWillMount() on the server. ' + 'This is a no-op. Please check the code for the %s component.', callerName, callerName, constructor && (constructor.displayName || constructor.name) || 'ReactClass') : void 0;
+	  }
+	}
+
+	/**
+	 * This is the update queue used for server rendering.
+	 * It delegates to ReactUpdateQueue while server rendering is in progress and
+	 * switches to ReactNoopUpdateQueue after the transaction has completed.
+	 * @class ReactServerUpdateQueue
+	 * @param {Transaction} transaction
+	 */
+
+	var ReactServerUpdateQueue = function () {
+	  function ReactServerUpdateQueue(transaction) {
+	    _classCallCheck(this, ReactServerUpdateQueue);
+
+	    this.transaction = transaction;
+	  }
+
+	  /**
+	   * Checks whether or not this composite component is mounted.
+	   * @param {ReactClass} publicInstance The instance we want to test.
+	   * @return {boolean} True if mounted, false otherwise.
+	   * @protected
+	   * @final
+	   */
+
+
+	  ReactServerUpdateQueue.prototype.isMounted = function isMounted(publicInstance) {
+	    return false;
+	  };
+
+	  /**
+	   * Enqueue a callback that will be executed after all the pending updates
+	   * have processed.
+	   *
+	   * @param {ReactClass} publicInstance The instance to use as `this` context.
+	   * @param {?function} callback Called after state is updated.
+	   * @internal
+	   */
+
+
+	  ReactServerUpdateQueue.prototype.enqueueCallback = function enqueueCallback(publicInstance, callback, callerName) {
+	    if (this.transaction.isInTransaction()) {
+	      ReactUpdateQueue.enqueueCallback(publicInstance, callback, callerName);
+	    }
+	  };
+
+	  /**
+	   * 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 `shouldComponentUpdate`, but it will invoke
+	   * `componentWillUpdate` and `componentDidUpdate`.
+	   *
+	   * @param {ReactClass} publicInstance The instance that should rerender.
+	   * @internal
+	   */
+
+
+	  ReactServerUpdateQueue.prototype.enqueueForceUpdate = function enqueueForceUpdate(publicInstance) {
+	    if (this.transaction.isInTransaction()) {
+	      ReactUpdateQueue.enqueueForceUpdate(publicInstance);
+	    } else {
+	      warnNoop(publicInstance, 'forceUpdate');
+	    }
+	  };
+
+	  /**
+	   * 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 {ReactClass} publicInstance The instance that should rerender.
+	   * @param {object|function} completeState Next state.
+	   * @internal
+	   */
+
+
+	  ReactServerUpdateQueue.prototype.enqueueReplaceState = function enqueueReplaceState(publicInstance, completeState) {
+	    if (this.transaction.isInTransaction()) {
+	      ReactUpdateQueue.enqueueReplaceState(publicInstance, completeState);
+	    } else {
+	      warnNoop(publicInstance, 'replaceState');
+	    }
+	  };
+
+	  /**
+	   * Sets a subset of the state. This only exists because _pendingState is
+	   * internal. This provides a merging strategy that is not available to deep
+	   * properties which is confusing. TODO: Expose pendingState or don't use it
+	   * during the merge.
+	   *
+	   * @param {ReactClass} publicInstance The instance that should rerender.
+	   * @param {object|function} partialState Next partial state to be merged with state.
+	   * @internal
+	   */
+
+
+	  ReactServerUpdateQueue.prototype.enqueueSetState = function enqueueSetState(publicInstance, partialState) {
+	    if (this.transaction.isInTransaction()) {
+	      ReactUpdateQueue.enqueueSetState(publicInstance, partialState);
+	    } else {
+	      warnNoop(publicInstance, 'setState');
+	    }
+	  };
+
+	  return ReactServerUpdateQueue;
+	}();
+
+	module.exports = ReactServerUpdateQueue;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 140 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2015-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var ReactCurrentOwner = __webpack_require__(10);
+	var ReactInstanceMap = __webpack_require__(120);
+	var ReactInstrumentation = __webpack_require__(66);
+	var ReactUpdates = __webpack_require__(60);
+
+	var invariant = __webpack_require__(37);
+	var warning = __webpack_require__(47);
+
+	function enqueueUpdate(internalInstance) {
+	  ReactUpdates.enqueueUpdate(internalInstance);
+	}
+
+	function formatUnexpectedArgument(arg) {
+	  var type = typeof arg;
+	  if (type !== 'object') {
+	    return type;
+	  }
+	  var displayName = arg.constructor && arg.constructor.name || type;
+	  var keys = Object.keys(arg);
+	  if (keys.length > 0 && keys.length < 20) {
+	    return displayName + ' (keys: ' + keys.join(', ') + ')';
+	  }
+	  return displayName;
+	}
+
+	function getInternalInstanceReadyForUpdate(publicInstance, callerName) {
+	  var internalInstance = ReactInstanceMap.get(publicInstance);
+	  if (!internalInstance) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      var ctor = publicInstance.constructor;
+	      // Only warn when we have a callerName. Otherwise we should be silent.
+	      // We're probably calling from enqueueCallback. We don't want to warn
+	      // there because we already warned for the corresponding lifecycle method.
+	      process.env.NODE_ENV !== 'production' ? warning(!callerName, '%s(...): Can only update a mounted or mounting component. ' + 'This usually means you called %s() on an unmounted component. ' + 'This is a no-op. Please check the code for the %s component.', callerName, callerName, ctor && (ctor.displayName || ctor.name) || 'ReactClass') : void 0;
+	    }
+	    return null;
+	  }
+
+	  if (process.env.NODE_ENV !== 'production') {
+	    process.env.NODE_ENV !== 'production' ? warning(ReactCurrentOwner.current == null, '%s(...): Cannot update during an existing state transition (such as ' + 'within `render` or another component\'s constructor). Render methods ' + 'should be a pure function of props and state; constructor ' + 'side-effects are an anti-pattern, but can be moved to ' + '`componentWillMount`.', callerName) : void 0;
+	  }
+
+	  return internalInstance;
+	}
+
+	/**
+	 * ReactUpdateQueue allows for state updates to be scheduled into a later
+	 * reconciliation step.
+	 */
+	var ReactUpdateQueue = {
+
+	  /**
+	   * Checks whether or not this composite component is mounted.
+	   * @param {ReactClass} publicInstance The instance we want to test.
+	   * @return {boolean} True if mounted, false otherwise.
+	   * @protected
+	   * @final
+	   */
+	  isMounted: function (publicInstance) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      var owner = ReactCurrentOwner.current;
+	      if (owner !== null) {
+	        process.env.NODE_ENV !== 'production' ? warning(owner._warnedAboutRefsInRender, '%s is accessing isMounted inside its render() function. ' + 'render() should be a pure function of props and state. It should ' + 'never access something that requires stale data from the previous ' + 'render, such as refs. Move this logic to componentDidMount and ' + 'componentDidUpdate instead.', owner.getName() || 'A component') : void 0;
+	        owner._warnedAboutRefsInRender = true;
+	      }
+	    }
+	    var internalInstance = ReactInstanceMap.get(publicInstance);
+	    if (internalInstance) {
+	      // During componentWillMount and render this will still be null but after
+	      // that will always render to something. At least for now. So we can use
+	      // this hack.
+	      return !!internalInstance._renderedComponent;
+	    } else {
+	      return false;
+	    }
+	  },
+
+	  /**
+	   * Enqueue a callback that will be executed after all the pending updates
+	   * have processed.
+	   *
+	   * @param {ReactClass} publicInstance The instance to use as `this` context.
+	   * @param {?function} callback Called after state is updated.
+	   * @param {string} callerName Name of the calling function in the public API.
+	   * @internal
+	   */
+	  enqueueCallback: function (publicInstance, callback, callerName) {
+	    ReactUpdateQueue.validateCallback(callback, callerName);
+	    var internalInstance = getInternalInstanceReadyForUpdate(publicInstance);
+
+	    // Previously we would throw an error if we didn't have an internal
+	    // instance. Since we want to make it a no-op instead, we mirror the same
+	    // behavior we have in other enqueue* methods.
+	    // We also need to ignore callbacks in componentWillMount. See
+	    // enqueueUpdates.
+	    if (!internalInstance) {
+	      return null;
+	    }
+
+	    if (internalInstance._pendingCallbacks) {
+	      internalInstance._pendingCallbacks.push(callback);
+	    } else {
+	      internalInstance._pendingCallbacks = [callback];
+	    }
+	    // TODO: The callback here is ignored when setState is called from
+	    // componentWillMount. Either fix it or disallow doing so completely in
+	    // favor of getInitialState. Alternatively, we can disallow
+	    // componentWillMount during server-side rendering.
+	    enqueueUpdate(internalInstance);
+	  },
+
+	  enqueueCallbackInternal: function (internalInstance, callback) {
+	    if (internalInstance._pendingCallbacks) {
+	      internalInstance._pendingCallbacks.push(callback);
+	    } else {
+	      internalInstance._pendingCallbacks = [callback];
+	    }
+	    enqueueUpdate(internalInstance);
+	  },
+
+	  /**
+	   * 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 `shouldComponentUpdate`, but it will invoke
+	   * `componentWillUpdate` and `componentDidUpdate`.
+	   *
+	   * @param {ReactClass} publicInstance The instance that should rerender.
+	   * @internal
+	   */
+	  enqueueForceUpdate: function (publicInstance) {
+	    var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'forceUpdate');
+
+	    if (!internalInstance) {
+	      return;
+	    }
+
+	    internalInstance._pendingForceUpdate = true;
+
+	    enqueueUpdate(internalInstance);
+	  },
+
+	  /**
+	   * 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 {ReactClass} publicInstance The instance that should rerender.
+	   * @param {object} completeState Next state.
+	   * @internal
+	   */
+	  enqueueReplaceState: function (publicInstance, completeState) {
+	    var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'replaceState');
+
+	    if (!internalInstance) {
+	      return;
+	    }
+
+	    internalInstance._pendingStateQueue = [completeState];
+	    internalInstance._pendingReplaceState = true;
+
+	    enqueueUpdate(internalInstance);
+	  },
+
+	  /**
+	   * Sets a subset of the state. This only exists because _pendingState is
+	   * internal. This provides a merging strategy that is not available to deep
+	   * properties which is confusing. TODO: Expose pendingState or don't use it
+	   * during the merge.
+	   *
+	   * @param {ReactClass} publicInstance The instance that should rerender.
+	   * @param {object} partialState Next partial state to be merged with state.
+	   * @internal
+	   */
+	  enqueueSetState: function (publicInstance, partialState) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      ReactInstrumentation.debugTool.onSetState();
+	      process.env.NODE_ENV !== 'production' ? warning(partialState != null, 'setState(...): You passed an undefined or null state object; ' + 'instead, use forceUpdate().') : void 0;
+	    }
+
+	    var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'setState');
+
+	    if (!internalInstance) {
+	      return;
+	    }
+
+	    var queue = internalInstance._pendingStateQueue || (internalInstance._pendingStateQueue = []);
+	    queue.push(partialState);
+
+	    enqueueUpdate(internalInstance);
+	  },
+
+	  enqueueElementInternal: function (internalInstance, nextElement, nextContext) {
+	    internalInstance._pendingElement = nextElement;
+	    // TODO: introduce _pendingContext instead of setting it directly.
+	    internalInstance._context = nextContext;
+	    enqueueUpdate(internalInstance);
+	  },
+
+	  validateCallback: function (callback, callerName) {
+	    !(!callback || typeof callback === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s(...): Expected the last optional `callback` argument to be a function. Instead received: %s.', callerName, formatUnexpectedArgument(callback)) : _prodInvariant('122', callerName, formatUnexpectedArgument(callback)) : void 0;
+	  }
+
+	};
+
+	module.exports = ReactUpdateQueue;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 141 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2015-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _assign = __webpack_require__(53);
+
+	var emptyFunction = __webpack_require__(48);
+	var warning = __webpack_require__(47);
+
+	var validateDOMNesting = emptyFunction;
+
+	if (process.env.NODE_ENV !== 'production') {
+	  // This validation code was written based on the HTML5 parsing spec:
+	  // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope
+	  //
+	  // Note: this does not catch all invalid nesting, nor does it try to (as it's
+	  // not clear what practical benefit doing so provides); instead, we warn only
+	  // for cases where the parser will give a parse tree differing from what React
+	  // intended. For example, <b><div></div></b> is invalid but we don't warn
+	  // because it still parses correctly; we do warn for other cases like nested
+	  // <p> tags where the beginning of the second element implicitly closes the
+	  // first, causing a confusing mess.
+
+	  // https://html.spec.whatwg.org/multipage/syntax.html#special
+	  var specialTags = ['address', 'applet', 'area', 'article', 'aside', 'base', 'basefont', 'bgsound', 'blockquote', 'body', 'br', 'button', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dir', 'div', 'dl', 'dt', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'iframe', 'img', 'input', 'isindex', 'li', 'link', 'listing', 'main', 'marquee', 'menu', 'menuitem', 'meta', 'nav', 'noembed', 'noframes', 'noscript', 'object', 'ol', 'p', 'param', 'plaintext', 'pre', 'script', 'section', 'select', 'source', 'style', 'summary', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul', 'wbr', 'xmp'];
+
+	  // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope
+	  var inScopeTags = ['applet', 'caption', 'html', 'table', 'td', 'th', 'marquee', 'object', 'template',
+
+	  // https://html.spec.whatwg.org/multipage/syntax.html#html-integration-point
+	  // TODO: Distinguish by namespace here -- for <title>, including it here
+	  // errs on the side of fewer warnings
+	  'foreignObject', 'desc', 'title'];
+
+	  // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-button-scope
+	  var buttonScopeTags = inScopeTags.concat(['button']);
+
+	  // https://html.spec.whatwg.org/multipage/syntax.html#generate-implied-end-tags
+	  var impliedEndTags = ['dd', 'dt', 'li', 'option', 'optgroup', 'p', 'rp', 'rt'];
+
+	  var emptyAncestorInfo = {
+	    current: null,
+
+	    formTag: null,
+	    aTagInScope: null,
+	    buttonTagInScope: null,
+	    nobrTagInScope: null,
+	    pTagInButtonScope: null,
+
+	    listItemTagAutoclosing: null,
+	    dlItemTagAutoclosing: null
+	  };
+
+	  var updatedAncestorInfo = function (oldInfo, tag, instance) {
+	    var ancestorInfo = _assign({}, oldInfo || emptyAncestorInfo);
+	    var info = { tag: tag, instance: instance };
+
+	    if (inScopeTags.indexOf(tag) !== -1) {
+	      ancestorInfo.aTagInScope = null;
+	      ancestorInfo.buttonTagInScope = null;
+	      ancestorInfo.nobrTagInScope = null;
+	    }
+	    if (buttonScopeTags.indexOf(tag) !== -1) {
+	      ancestorInfo.pTagInButtonScope = null;
+	    }
+
+	    // See rules for 'li', 'dd', 'dt' start tags in
+	    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody
+	    if (specialTags.indexOf(tag) !== -1 && tag !== 'address' && tag !== 'div' && tag !== 'p') {
+	      ancestorInfo.listItemTagAutoclosing = null;
+	      ancestorInfo.dlItemTagAutoclosing = null;
+	    }
+
+	    ancestorInfo.current = info;
+
+	    if (tag === 'form') {
+	      ancestorInfo.formTag = info;
+	    }
+	    if (tag === 'a') {
+	      ancestorInfo.aTagInScope = info;
+	    }
+	    if (tag === 'button') {
+	      ancestorInfo.buttonTagInScope = info;
+	    }
+	    if (tag === 'nobr') {
+	      ancestorInfo.nobrTagInScope = info;
+	    }
+	    if (tag === 'p') {
+	      ancestorInfo.pTagInButtonScope = info;
+	    }
+	    if (tag === 'li') {
+	      ancestorInfo.listItemTagAutoclosing = info;
+	    }
+	    if (tag === 'dd' || tag === 'dt') {
+	      ancestorInfo.dlItemTagAutoclosing = info;
+	    }
+
+	    return ancestorInfo;
+	  };
+
+	  /**
+	   * Returns whether
+	   */
+	  var isTagValidWithParent = function (tag, parentTag) {
+	    // First, let's check if we're in an unusual parsing mode...
+	    switch (parentTag) {
+	      // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inselect
+	      case 'select':
+	        return tag === 'option' || tag === 'optgroup' || tag === '#text';
+	      case 'optgroup':
+	        return tag === 'option' || tag === '#text';
+	      // Strictly speaking, seeing an <option> doesn't mean we're in a <select>
+	      // but
+	      case 'option':
+	        return tag === '#text';
+
+	      // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intd
+	      // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incaption
+	      // No special behavior since these rules fall back to "in body" mode for
+	      // all except special table nodes which cause bad parsing behavior anyway.
+
+	      // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intr
+	      case 'tr':
+	        return tag === 'th' || tag === 'td' || tag === 'style' || tag === 'script' || tag === 'template';
+
+	      // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intbody
+	      case 'tbody':
+	      case 'thead':
+	      case 'tfoot':
+	        return tag === 'tr' || tag === 'style' || tag === 'script' || tag === 'template';
+
+	      // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incolgroup
+	      case 'colgroup':
+	        return tag === 'col' || tag === 'template';
+
+	      // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intable
+	      case 'table':
+	        return tag === 'caption' || tag === 'colgroup' || tag === 'tbody' || tag === 'tfoot' || tag === 'thead' || tag === 'style' || tag === 'script' || tag === 'template';
+
+	      // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inhead
+	      case 'head':
+	        return tag === 'base' || tag === 'basefont' || tag === 'bgsound' || tag === 'link' || tag === 'meta' || tag === 'title' || tag === 'noscript' || tag === 'noframes' || tag === 'style' || tag === 'script' || tag === 'template';
+
+	      // https://html.spec.whatwg.org/multipage/semantics.html#the-html-element
+	      case 'html':
+	        return tag === 'head' || tag === 'body';
+	      case '#document':
+	        return tag === 'html';
+	    }
+
+	    // Probably in the "in body" parsing mode, so we outlaw only tag combos
+	    // where the parsing rules cause implicit opens or closes to be added.
+	    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody
+	    switch (tag) {
+	      case 'h1':
+	      case 'h2':
+	      case 'h3':
+	      case 'h4':
+	      case 'h5':
+	      case 'h6':
+	        return parentTag !== 'h1' && parentTag !== 'h2' && parentTag !== 'h3' && parentTag !== 'h4' && parentTag !== 'h5' && parentTag !== 'h6';
+
+	      case 'rp':
+	      case 'rt':
+	        return impliedEndTags.indexOf(parentTag) === -1;
+
+	      case 'body':
+	      case 'caption':
+	      case 'col':
+	      case 'colgroup':
+	      case 'frame':
+	      case 'head':
+	      case 'html':
+	      case 'tbody':
+	      case 'td':
+	      case 'tfoot':
+	      case 'th':
+	      case 'thead':
+	      case 'tr':
+	        // These tags are only valid with a few parents that have special child
+	        // parsing rules -- if we're down here, then none of those matched and
+	        // so we allow it only if we don't know what the parent is, as all other
+	        // cases are invalid.
+	        return parentTag == null;
+	    }
+
+	    return true;
+	  };
+
+	  /**
+	   * Returns whether
+	   */
+	  var findInvalidAncestorForTag = function (tag, ancestorInfo) {
+	    switch (tag) {
+	      case 'address':
+	      case 'article':
+	      case 'aside':
+	      case 'blockquote':
+	      case 'center':
+	      case 'details':
+	      case 'dialog':
+	      case 'dir':
+	      case 'div':
+	      case 'dl':
+	      case 'fieldset':
+	      case 'figcaption':
+	      case 'figure':
+	      case 'footer':
+	      case 'header':
+	      case 'hgroup':
+	      case 'main':
+	      case 'menu':
+	      case 'nav':
+	      case 'ol':
+	      case 'p':
+	      case 'section':
+	      case 'summary':
+	      case 'ul':
+
+	      case 'pre':
+	      case 'listing':
+
+	      case 'table':
+
+	      case 'hr':
+
+	      case 'xmp':
+
+	      case 'h1':
+	      case 'h2':
+	      case 'h3':
+	      case 'h4':
+	      case 'h5':
+	      case 'h6':
+	        return ancestorInfo.pTagInButtonScope;
+
+	      case 'form':
+	        return ancestorInfo.formTag || ancestorInfo.pTagInButtonScope;
+
+	      case 'li':
+	        return ancestorInfo.listItemTagAutoclosing;
+
+	      case 'dd':
+	      case 'dt':
+	        return ancestorInfo.dlItemTagAutoclosing;
+
+	      case 'button':
+	        return ancestorInfo.buttonTagInScope;
+
+	      case 'a':
+	        // Spec says something about storing a list of markers, but it sounds
+	        // equivalent to this check.
+	        return ancestorInfo.aTagInScope;
+
+	      case 'nobr':
+	        return ancestorInfo.nobrTagInScope;
+	    }
+
+	    return null;
+	  };
+
+	  /**
+	   * Given a ReactCompositeComponent instance, return a list of its recursive
+	   * owners, starting at the root and ending with the instance itself.
+	   */
+	  var findOwnerStack = function (instance) {
+	    if (!instance) {
+	      return [];
+	    }
+
+	    var stack = [];
+	    do {
+	      stack.push(instance);
+	    } while (instance = instance._currentElement._owner);
+	    stack.reverse();
+	    return stack;
+	  };
+
+	  var didWarn = {};
+
+	  validateDOMNesting = function (childTag, childText, childInstance, ancestorInfo) {
+	    ancestorInfo = ancestorInfo || emptyAncestorInfo;
+	    var parentInfo = ancestorInfo.current;
+	    var parentTag = parentInfo && parentInfo.tag;
+
+	    if (childText != null) {
+	      process.env.NODE_ENV !== 'production' ? warning(childTag == null, 'validateDOMNesting: when childText is passed, childTag should be null') : void 0;
+	      childTag = '#text';
+	    }
+
+	    var invalidParent = isTagValidWithParent(childTag, parentTag) ? null : parentInfo;
+	    var invalidAncestor = invalidParent ? null : findInvalidAncestorForTag(childTag, ancestorInfo);
+	    var problematic = invalidParent || invalidAncestor;
+
+	    if (problematic) {
+	      var ancestorTag = problematic.tag;
+	      var ancestorInstance = problematic.instance;
+
+	      var childOwner = childInstance && childInstance._currentElement._owner;
+	      var ancestorOwner = ancestorInstance && ancestorInstance._currentElement._owner;
+
+	      var childOwners = findOwnerStack(childOwner);
+	      var ancestorOwners = findOwnerStack(ancestorOwner);
+
+	      var minStackLen = Math.min(childOwners.length, ancestorOwners.length);
+	      var i;
+
+	      var deepestCommon = -1;
+	      for (i = 0; i < minStackLen; i++) {
+	        if (childOwners[i] === ancestorOwners[i]) {
+	          deepestCommon = i;
+	        } else {
+	          break;
+	        }
+	      }
+
+	      var UNKNOWN = '(unknown)';
+	      var childOwnerNames = childOwners.slice(deepestCommon + 1).map(function (inst) {
+	        return inst.getName() || UNKNOWN;
+	      });
+	      var ancestorOwnerNames = ancestorOwners.slice(deepestCommon + 1).map(function (inst) {
+	        return inst.getName() || UNKNOWN;
+	      });
+	      var ownerInfo = [].concat(
+	      // If the parent and child instances have a common owner ancestor, start
+	      // with that -- otherwise we just start with the parent's owners.
+	      deepestCommon !== -1 ? childOwners[deepestCommon].getName() || UNKNOWN : [], ancestorOwnerNames, ancestorTag,
+	      // If we're warning about an invalid (non-parent) ancestry, add '...'
+	      invalidAncestor ? ['...'] : [], childOwnerNames, childTag).join(' > ');
+
+	      var warnKey = !!invalidParent + '|' + childTag + '|' + ancestorTag + '|' + ownerInfo;
+	      if (didWarn[warnKey]) {
+	        return;
+	      }
+	      didWarn[warnKey] = true;
+
+	      var tagDisplayName = childTag;
+	      var whitespaceInfo = '';
+	      if (childTag === '#text') {
+	        if (/\S/.test(childText)) {
+	          tagDisplayName = 'Text nodes';
+	        } else {
+	          tagDisplayName = 'Whitespace text nodes';
+	          whitespaceInfo = ' Make sure you don\'t have any extra whitespace between tags on ' + 'each line of your source code.';
+	        }
+	      } else {
+	        tagDisplayName = '<' + childTag + '>';
+	      }
+
+	      if (invalidParent) {
+	        var info = '';
+	        if (ancestorTag === 'table' && childTag === 'tr') {
+	          info += ' Add a <tbody> to your code to match the DOM tree generated by ' + 'the browser.';
+	        }
+	        process.env.NODE_ENV !== 'production' ? warning(false, 'validateDOMNesting(...): %s cannot appear as a child of <%s>.%s ' + 'See %s.%s', tagDisplayName, ancestorTag, whitespaceInfo, ownerInfo, info) : void 0;
+	      } else {
+	        process.env.NODE_ENV !== 'production' ? warning(false, 'validateDOMNesting(...): %s cannot appear as a descendant of ' + '<%s>. See %s.', tagDisplayName, ancestorTag, ownerInfo) : void 0;
+	      }
+	    }
+	  };
+
+	  validateDOMNesting.updatedAncestorInfo = updatedAncestorInfo;
+
+	  // For testing
+	  validateDOMNesting.isTagValidInContext = function (tag, ancestorInfo) {
+	    ancestorInfo = ancestorInfo || emptyAncestorInfo;
+	    var parentInfo = ancestorInfo.current;
+	    var parentTag = parentInfo && parentInfo.tag;
+	    return isTagValidWithParent(tag, parentTag) && !findInvalidAncestorForTag(tag, ancestorInfo);
+	  };
+	}
+
+	module.exports = validateDOMNesting;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 142 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2014-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _assign = __webpack_require__(53);
+
+	var DOMLazyTree = __webpack_require__(85);
+	var ReactDOMComponentTree = __webpack_require__(34);
+
+	var ReactDOMEmptyComponent = function (instantiate) {
+	  // ReactCompositeComponent uses this:
+	  this._currentElement = null;
+	  // ReactDOMComponentTree uses these:
+	  this._hostNode = null;
+	  this._hostParent = null;
+	  this._hostContainerInfo = null;
+	  this._domID = 0;
+	};
+	_assign(ReactDOMEmptyComponent.prototype, {
+	  mountComponent: function (transaction, hostParent, hostContainerInfo, context) {
+	    var domID = hostContainerInfo._idCounter++;
+	    this._domID = domID;
+	    this._hostParent = hostParent;
+	    this._hostContainerInfo = hostContainerInfo;
+
+	    var nodeValue = ' react-empty: ' + this._domID + ' ';
+	    if (transaction.useCreateElement) {
+	      var ownerDocument = hostContainerInfo._ownerDocument;
+	      var node = ownerDocument.createComment(nodeValue);
+	      ReactDOMComponentTree.precacheNode(this, node);
+	      return DOMLazyTree(node);
+	    } else {
+	      if (transaction.renderToStaticMarkup) {
+	        // Normally we'd insert a comment node, but since this is a situation
+	        // where React won't take over (static pages), we can simply return
+	        // nothing.
+	        return '';
+	      }
+	      return '<!--' + nodeValue + '-->';
+	    }
+	  },
+	  receiveComponent: function () {},
+	  getHostNode: function () {
+	    return ReactDOMComponentTree.getNodeFromInstance(this);
+	  },
+	  unmountComponent: function () {
+	    ReactDOMComponentTree.uncacheNode(this);
+	  }
+	});
+
+	module.exports = ReactDOMEmptyComponent;
+
+/***/ },
+/* 143 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2015-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var invariant = __webpack_require__(37);
+
+	/**
+	 * Return the lowest common ancestor of A and B, or null if they are in
+	 * different trees.
+	 */
+	function getLowestCommonAncestor(instA, instB) {
+	  !('_hostNode' in instA) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getNodeFromInstance: Invalid argument.') : _prodInvariant('33') : void 0;
+	  !('_hostNode' in instB) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getNodeFromInstance: Invalid argument.') : _prodInvariant('33') : void 0;
+
+	  var depthA = 0;
+	  for (var tempA = instA; tempA; tempA = tempA._hostParent) {
+	    depthA++;
+	  }
+	  var depthB = 0;
+	  for (var tempB = instB; tempB; tempB = tempB._hostParent) {
+	    depthB++;
+	  }
+
+	  // If A is deeper, crawl up.
+	  while (depthA - depthB > 0) {
+	    instA = instA._hostParent;
+	    depthA--;
+	  }
+
+	  // If B is deeper, crawl up.
+	  while (depthB - depthA > 0) {
+	    instB = instB._hostParent;
+	    depthB--;
+	  }
+
+	  // Walk in lockstep until we find a match.
+	  var depth = depthA;
+	  while (depth--) {
+	    if (instA === instB) {
+	      return instA;
+	    }
+	    instA = instA._hostParent;
+	    instB = instB._hostParent;
+	  }
+	  return null;
+	}
+
+	/**
+	 * Return if A is an ancestor of B.
+	 */
+	function isAncestor(instA, instB) {
+	  !('_hostNode' in instA) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'isAncestor: Invalid argument.') : _prodInvariant('35') : void 0;
+	  !('_hostNode' in instB) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'isAncestor: Invalid argument.') : _prodInvariant('35') : void 0;
+
+	  while (instB) {
+	    if (instB === instA) {
+	      return true;
+	    }
+	    instB = instB._hostParent;
+	  }
+	  return false;
+	}
+
+	/**
+	 * Return the parent instance of the passed-in instance.
+	 */
+	function getParentInstance(inst) {
+	  !('_hostNode' in inst) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getParentInstance: Invalid argument.') : _prodInvariant('36') : void 0;
+
+	  return inst._hostParent;
+	}
+
+	/**
+	 * Simulates the traversal of a two-phase, capture/bubble event dispatch.
+	 */
+	function traverseTwoPhase(inst, fn, arg) {
+	  var path = [];
+	  while (inst) {
+	    path.push(inst);
+	    inst = inst._hostParent;
+	  }
+	  var i;
+	  for (i = path.length; i-- > 0;) {
+	    fn(path[i], 'captured', arg);
+	  }
+	  for (i = 0; i < path.length; i++) {
+	    fn(path[i], 'bubbled', arg);
+	  }
+	}
+
+	/**
+	 * Traverses the ID hierarchy and invokes the supplied `cb` on any IDs that
+	 * should would receive a `mouseEnter` or `mouseLeave` event.
+	 *
+	 * Does not invoke the callback on the nearest common ancestor because nothing
+	 * "entered" or "left" that element.
+	 */
+	function traverseEnterLeave(from, to, fn, argFrom, argTo) {
+	  var common = from && to ? getLowestCommonAncestor(from, to) : null;
+	  var pathFrom = [];
+	  while (from && from !== common) {
+	    pathFrom.push(from);
+	    from = from._hostParent;
+	  }
+	  var pathTo = [];
+	  while (to && to !== common) {
+	    pathTo.push(to);
+	    to = to._hostParent;
+	  }
+	  var i;
+	  for (i = 0; i < pathFrom.length; i++) {
+	    fn(pathFrom[i], 'bubbled', argFrom);
+	  }
+	  for (i = pathTo.length; i-- > 0;) {
+	    fn(pathTo[i], 'captured', argTo);
+	  }
+	}
+
+	module.exports = {
+	  isAncestor: isAncestor,
+	  getLowestCommonAncestor: getLowestCommonAncestor,
+	  getParentInstance: getParentInstance,
+	  traverseTwoPhase: traverseTwoPhase,
+	  traverseEnterLeave: traverseEnterLeave
+	};
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 144 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35),
+	    _assign = __webpack_require__(53);
+
+	var DOMChildrenOperations = __webpack_require__(84);
+	var DOMLazyTree = __webpack_require__(85);
+	var ReactDOMComponentTree = __webpack_require__(34);
+
+	var escapeTextContentForBrowser = __webpack_require__(90);
+	var invariant = __webpack_require__(37);
+	var validateDOMNesting = __webpack_require__(141);
+
+	/**
+	 * 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 between comment nodes 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 ReactDOMTextComponent
+	 * @extends ReactComponent
+	 * @internal
+	 */
+	var ReactDOMTextComponent = function (text) {
+	  // TODO: This is really a ReactText (ReactNode), not a ReactElement
+	  this._currentElement = text;
+	  this._stringText = '' + text;
+	  // ReactDOMComponentTree uses these:
+	  this._hostNode = null;
+	  this._hostParent = null;
+
+	  // Properties
+	  this._domID = 0;
+	  this._mountIndex = 0;
+	  this._closingComment = null;
+	  this._commentNodes = null;
+	};
+
+	_assign(ReactDOMTextComponent.prototype, {
+
+	  /**
+	   * Creates the markup for this text node. This node is not intended to have
+	   * any features besides containing text content.
+	   *
+	   * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
+	   * @return {string} Markup for this text node.
+	   * @internal
+	   */
+	  mountComponent: function (transaction, hostParent, hostContainerInfo, context) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      var parentInfo;
+	      if (hostParent != null) {
+	        parentInfo = hostParent._ancestorInfo;
+	      } else if (hostContainerInfo != null) {
+	        parentInfo = hostContainerInfo._ancestorInfo;
+	      }
+	      if (parentInfo) {
+	        // parentInfo should always be present except for the top-level
+	        // component when server rendering
+	        validateDOMNesting(null, this._stringText, this, parentInfo);
+	      }
+	    }
+
+	    var domID = hostContainerInfo._idCounter++;
+	    var openingValue = ' react-text: ' + domID + ' ';
+	    var closingValue = ' /react-text ';
+	    this._domID = domID;
+	    this._hostParent = hostParent;
+	    if (transaction.useCreateElement) {
+	      var ownerDocument = hostContainerInfo._ownerDocument;
+	      var openingComment = ownerDocument.createComment(openingValue);
+	      var closingComment = ownerDocument.createComment(closingValue);
+	      var lazyTree = DOMLazyTree(ownerDocument.createDocumentFragment());
+	      DOMLazyTree.queueChild(lazyTree, DOMLazyTree(openingComment));
+	      if (this._stringText) {
+	        DOMLazyTree.queueChild(lazyTree, DOMLazyTree(ownerDocument.createTextNode(this._stringText)));
+	      }
+	      DOMLazyTree.queueChild(lazyTree, DOMLazyTree(closingComment));
+	      ReactDOMComponentTree.precacheNode(this, openingComment);
+	      this._closingComment = closingComment;
+	      return lazyTree;
+	    } else {
+	      var escapedText = escapeTextContentForBrowser(this._stringText);
+
+	      if (transaction.renderToStaticMarkup) {
+	        // Normally we'd wrap this between comment nodes for the reasons stated
+	        // above, but since this is a situation where React won't take over
+	        // (static pages), we can simply return the text as it is.
+	        return escapedText;
+	      }
+
+	      return '<!--' + openingValue + '-->' + escapedText + '<!--' + closingValue + '-->';
+	    }
+	  },
+
+	  /**
+	   * Updates this component by updating the text content.
+	   *
+	   * @param {ReactText} nextText The next text content
+	   * @param {ReactReconcileTransaction} transaction
+	   * @internal
+	   */
+	  receiveComponent: function (nextText, transaction) {
+	    if (nextText !== this._currentElement) {
+	      this._currentElement = nextText;
+	      var nextStringText = '' + nextText;
+	      if (nextStringText !== this._stringText) {
+	        // TODO: Save this as pending props and use performUpdateIfNecessary
+	        // and/or updateComponent to do the actual update for consistency with
+	        // other component types?
+	        this._stringText = nextStringText;
+	        var commentNodes = this.getHostNode();
+	        DOMChildrenOperations.replaceDelimitedText(commentNodes[0], commentNodes[1], nextStringText);
+	      }
+	    }
+	  },
+
+	  getHostNode: function () {
+	    var hostNode = this._commentNodes;
+	    if (hostNode) {
+	      return hostNode;
+	    }
+	    if (!this._closingComment) {
+	      var openingComment = ReactDOMComponentTree.getNodeFromInstance(this);
+	      var node = openingComment.nextSibling;
+	      while (true) {
+	        !(node != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Missing closing comment for text component %s', this._domID) : _prodInvariant('67', this._domID) : void 0;
+	        if (node.nodeType === 8 && node.nodeValue === ' /react-text ') {
+	          this._closingComment = node;
+	          break;
+	        }
+	        node = node.nextSibling;
+	      }
+	    }
+	    hostNode = [this._hostNode, this._closingComment];
+	    this._commentNodes = hostNode;
+	    return hostNode;
+	  },
+
+	  unmountComponent: function () {
+	    this._closingComment = null;
+	    this._commentNodes = null;
+	    ReactDOMComponentTree.uncacheNode(this);
+	  }
+
+	});
+
+	module.exports = ReactDOMTextComponent;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 145 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _assign = __webpack_require__(53);
+
+	var ReactUpdates = __webpack_require__(60);
+	var Transaction = __webpack_require__(72);
+
+	var emptyFunction = __webpack_require__(48);
+
+	var RESET_BATCHED_UPDATES = {
+	  initialize: emptyFunction,
+	  close: function () {
+	    ReactDefaultBatchingStrategy.isBatchingUpdates = false;
+	  }
+	};
+
+	var FLUSH_BATCHED_UPDATES = {
+	  initialize: emptyFunction,
+	  close: ReactUpdates.flushBatchedUpdates.bind(ReactUpdates)
+	};
+
+	var TRANSACTION_WRAPPERS = [FLUSH_BATCHED_UPDATES, RESET_BATCHED_UPDATES];
+
+	function ReactDefaultBatchingStrategyTransaction() {
+	  this.reinitializeTransaction();
+	}
+
+	_assign(ReactDefaultBatchingStrategyTransaction.prototype, Transaction, {
+	  getTransactionWrappers: function () {
+	    return TRANSACTION_WRAPPERS;
+	  }
+	});
+
+	var transaction = new ReactDefaultBatchingStrategyTransaction();
+
+	var ReactDefaultBatchingStrategy = {
+	  isBatchingUpdates: false,
+
+	  /**
+	   * Call the provided function in a context within which calls to `setState`
+	   * and friends are batched such that components aren't updated unnecessarily.
+	   */
+	  batchedUpdates: function (callback, a, b, c, d, e) {
+	    var alreadyBatchingUpdates = ReactDefaultBatchingStrategy.isBatchingUpdates;
+
+	    ReactDefaultBatchingStrategy.isBatchingUpdates = true;
+
+	    // The code is written this way to avoid extra allocations
+	    if (alreadyBatchingUpdates) {
+	      return callback(a, b, c, d, e);
+	    } else {
+	      return transaction.perform(callback, null, a, b, c, d, e);
+	    }
+	  }
+	};
+
+	module.exports = ReactDefaultBatchingStrategy;
+
+/***/ },
+/* 146 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _assign = __webpack_require__(53);
+
+	var EventListener = __webpack_require__(147);
+	var ExecutionEnvironment = __webpack_require__(51);
+	var PooledClass = __webpack_require__(54);
+	var ReactDOMComponentTree = __webpack_require__(34);
+	var ReactUpdates = __webpack_require__(60);
+
+	var getEventTarget = __webpack_require__(73);
+	var getUnboundedScrollPosition = __webpack_require__(148);
+
+	/**
+	 * Find the deepest React component completely containing the root of the
+	 * passed-in instance (for use when entire React trees are nested within each
+	 * other). If React trees are not nested, returns null.
+	 */
+	function findParent(inst) {
+	  // TODO: It may be a good idea to cache this to prevent unnecessary DOM
+	  // traversal, but caching is difficult to do correctly without using a
+	  // mutation observer to listen for all DOM changes.
+	  while (inst._hostParent) {
+	    inst = inst._hostParent;
+	  }
+	  var rootNode = ReactDOMComponentTree.getNodeFromInstance(inst);
+	  var container = rootNode.parentNode;
+	  return ReactDOMComponentTree.getClosestInstanceFromNode(container);
+	}
+
+	// Used to store ancestor hierarchy in top level callback
+	function TopLevelCallbackBookKeeping(topLevelType, nativeEvent) {
+	  this.topLevelType = topLevelType;
+	  this.nativeEvent = nativeEvent;
+	  this.ancestors = [];
+	}
+	_assign(TopLevelCallbackBookKeeping.prototype, {
+	  destructor: function () {
+	    this.topLevelType = null;
+	    this.nativeEvent = null;
+	    this.ancestors.length = 0;
+	  }
+	});
+	PooledClass.addPoolingTo(TopLevelCallbackBookKeeping, PooledClass.twoArgumentPooler);
+
+	function handleTopLevelImpl(bookKeeping) {
+	  var nativeEventTarget = getEventTarget(bookKeeping.nativeEvent);
+	  var targetInst = ReactDOMComponentTree.getClosestInstanceFromNode(nativeEventTarget);
+
+	  // Loop through the hierarchy, in case there's any nested components.
+	  // It's important that we build the array of ancestors before calling any
+	  // event handlers, because event handlers can modify the DOM, leading to
+	  // inconsistencies with ReactMount's node cache. See #1105.
+	  var ancestor = targetInst;
+	  do {
+	    bookKeeping.ancestors.push(ancestor);
+	    ancestor = ancestor && findParent(ancestor);
+	  } while (ancestor);
+
+	  for (var i = 0; i < bookKeeping.ancestors.length; i++) {
+	    targetInst = bookKeeping.ancestors[i];
+	    ReactEventListener._handleTopLevel(bookKeeping.topLevelType, targetInst, bookKeeping.nativeEvent, getEventTarget(bookKeeping.nativeEvent));
+	  }
+	}
+
+	function scrollValueMonitor(cb) {
+	  var scrollPosition = getUnboundedScrollPosition(window);
+	  cb(scrollPosition);
+	}
+
+	var ReactEventListener = {
+	  _enabled: true,
+	  _handleTopLevel: null,
+
+	  WINDOW_HANDLE: ExecutionEnvironment.canUseDOM ? window : null,
+
+	  setHandleTopLevel: function (handleTopLevel) {
+	    ReactEventListener._handleTopLevel = handleTopLevel;
+	  },
+
+	  setEnabled: function (enabled) {
+	    ReactEventListener._enabled = !!enabled;
+	  },
+
+	  isEnabled: function () {
+	    return ReactEventListener._enabled;
+	  },
+
+	  /**
+	   * Traps top-level events by using event bubbling.
+	   *
+	   * @param {string} topLevelType Record from `EventConstants`.
+	   * @param {string} handlerBaseName Event name (e.g. "click").
+	   * @param {object} element Element on which to attach listener.
+	   * @return {?object} An object with a remove function which will forcefully
+	   *                  remove the listener.
+	   * @internal
+	   */
+	  trapBubbledEvent: function (topLevelType, handlerBaseName, element) {
+	    if (!element) {
+	      return null;
+	    }
+	    return EventListener.listen(element, handlerBaseName, ReactEventListener.dispatchEvent.bind(null, topLevelType));
+	  },
+
+	  /**
+	   * Traps a top-level event by using event capturing.
+	   *
+	   * @param {string} topLevelType Record from `EventConstants`.
+	   * @param {string} handlerBaseName Event name (e.g. "click").
+	   * @param {object} element Element on which to attach listener.
+	   * @return {?object} An object with a remove function which will forcefully
+	   *                  remove the listener.
+	   * @internal
+	   */
+	  trapCapturedEvent: function (topLevelType, handlerBaseName, element) {
+	    if (!element) {
+	      return null;
+	    }
+	    return EventListener.capture(element, handlerBaseName, ReactEventListener.dispatchEvent.bind(null, topLevelType));
+	  },
+
+	  monitorScrollValue: function (refresh) {
+	    var callback = scrollValueMonitor.bind(null, refresh);
+	    EventListener.listen(window, 'scroll', callback);
+	  },
+
+	  dispatchEvent: function (topLevelType, nativeEvent) {
+	    if (!ReactEventListener._enabled) {
+	      return;
+	    }
+
+	    var bookKeeping = TopLevelCallbackBookKeeping.getPooled(topLevelType, nativeEvent);
+	    try {
+	      // Event queue being processed in the same cycle allows
+	      // `preventDefault`.
+	      ReactUpdates.batchedUpdates(handleTopLevelImpl, bookKeeping);
+	    } finally {
+	      TopLevelCallbackBookKeeping.release(bookKeeping);
+	    }
+	  }
+	};
+
+	module.exports = ReactEventListener;
+
+/***/ },
+/* 147 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
+
+	/**
+	 * Copyright (c) 2013-present, 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.
+	 *
+	 * @typechecks
+	 */
+
+	var emptyFunction = __webpack_require__(48);
+
+	/**
+	 * Upstream version of event listener. Does not take into account specific
+	 * nature of platform.
+	 */
+	var EventListener = {
+	  /**
+	   * Listen to DOM events during the bubble phase.
+	   *
+	   * @param {DOMEventTarget} target DOM element to register listener on.
+	   * @param {string} eventType Event type, e.g. 'click' or 'mouseover'.
+	   * @param {function} callback Callback function.
+	   * @return {object} Object with a `remove` method.
+	   */
+	  listen: function listen(target, eventType, callback) {
+	    if (target.addEventListener) {
+	      target.addEventListener(eventType, callback, false);
+	      return {
+	        remove: function remove() {
+	          target.removeEventListener(eventType, callback, false);
+	        }
+	      };
+	    } else if (target.attachEvent) {
+	      target.attachEvent('on' + eventType, callback);
+	      return {
+	        remove: function remove() {
+	          target.detachEvent('on' + eventType, callback);
+	        }
+	      };
+	    }
+	  },
+
+	  /**
+	   * Listen to DOM events during the capture phase.
+	   *
+	   * @param {DOMEventTarget} target DOM element to register listener on.
+	   * @param {string} eventType Event type, e.g. 'click' or 'mouseover'.
+	   * @param {function} callback Callback function.
+	   * @return {object} Object with a `remove` method.
+	   */
+	  capture: function capture(target, eventType, callback) {
+	    if (target.addEventListener) {
+	      target.addEventListener(eventType, callback, true);
+	      return {
+	        remove: function remove() {
+	          target.removeEventListener(eventType, callback, true);
+	        }
+	      };
+	    } else {
+	      if (process.env.NODE_ENV !== 'production') {
+	        console.error('Attempted to listen to events during the capture phase on a ' + 'browser that does not support the capture phase. Your application ' + 'will not receive some events.');
+	      }
+	      return {
+	        remove: emptyFunction
+	      };
+	    }
+	  },
+
+	  registerDefault: function registerDefault() {}
+	};
+
+	module.exports = EventListener;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 148 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * @typechecks
+	 */
+
+	'use strict';
+
+	/**
+	 * Gets the scroll position of the supplied element or window.
+	 *
+	 * The return values are unbounded, unlike `getScrollPosition`. This means they
+	 * may be negative or exceed the element boundaries (which is possible using
+	 * inertial scrolling).
+	 *
+	 * @param {DOMWindow|DOMElement} scrollable
+	 * @return {object} Map with `x` and `y` keys.
+	 */
+
+	function getUnboundedScrollPosition(scrollable) {
+	  if (scrollable === window) {
+	    return {
+	      x: window.pageXOffset || document.documentElement.scrollLeft,
+	      y: window.pageYOffset || document.documentElement.scrollTop
+	    };
+	  }
+	  return {
+	    x: scrollable.scrollLeft,
+	    y: scrollable.scrollTop
+	  };
+	}
+
+	module.exports = getUnboundedScrollPosition;
+
+/***/ },
+/* 149 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var DOMProperty = __webpack_require__(36);
+	var EventPluginHub = __webpack_require__(43);
+	var EventPluginUtils = __webpack_require__(45);
+	var ReactComponentEnvironment = __webpack_require__(119);
+	var ReactEmptyComponent = __webpack_require__(130);
+	var ReactBrowserEventEmitter = __webpack_require__(109);
+	var ReactHostComponent = __webpack_require__(131);
+	var ReactUpdates = __webpack_require__(60);
+
+	var ReactInjection = {
+	  Component: ReactComponentEnvironment.injection,
+	  DOMProperty: DOMProperty.injection,
+	  EmptyComponent: ReactEmptyComponent.injection,
+	  EventPluginHub: EventPluginHub.injection,
+	  EventPluginUtils: EventPluginUtils.injection,
+	  EventEmitter: ReactBrowserEventEmitter.injection,
+	  HostComponent: ReactHostComponent.injection,
+	  Updates: ReactUpdates.injection
+	};
+
+	module.exports = ReactInjection;
+
+/***/ },
+/* 150 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _assign = __webpack_require__(53);
+
+	var CallbackQueue = __webpack_require__(61);
+	var PooledClass = __webpack_require__(54);
+	var ReactBrowserEventEmitter = __webpack_require__(109);
+	var ReactInputSelection = __webpack_require__(151);
+	var ReactInstrumentation = __webpack_require__(66);
+	var Transaction = __webpack_require__(72);
+	var ReactUpdateQueue = __webpack_require__(140);
+
+	/**
+	 * 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 `ReactBrowserEventEmitter` before
+	   * the reconciliation.
+	   */
+	  initialize: function () {
+	    var currentlyEnabled = ReactBrowserEventEmitter.isEnabled();
+	    ReactBrowserEventEmitter.setEnabled(false);
+	    return currentlyEnabled;
+	  },
+
+	  /**
+	   * @param {boolean} previouslyEnabled Enabled status of
+	   *   `ReactBrowserEventEmitter` before the reconciliation occurred. `close`
+	   *   restores the previous value.
+	   */
+	  close: function (previouslyEnabled) {
+	    ReactBrowserEventEmitter.setEnabled(previouslyEnabled);
+	  }
+	};
+
+	/**
+	 * Provides a queue for collecting `componentDidMount` and
+	 * `componentDidUpdate` callbacks during the transaction.
+	 */
+	var ON_DOM_READY_QUEUEING = {
+	  /**
+	   * Initializes the internal `onDOMReady` queue.
+	   */
+	  initialize: function () {
+	    this.reactMountReady.reset();
+	  },
+
+	  /**
+	   * After DOM is flushed, invoke all registered `onDOMReady` callbacks.
+	   */
+	  close: function () {
+	    this.reactMountReady.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];
+
+	if (process.env.NODE_ENV !== 'production') {
+	  TRANSACTION_WRAPPERS.push({
+	    initialize: ReactInstrumentation.debugTool.onBeginFlush,
+	    close: ReactInstrumentation.debugTool.onEndFlush
+	  });
+	}
+
+	/**
+	 * 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(useCreateElement) {
+	  this.reinitializeTransaction();
+	  // Only server-side rendering really needs this option (see
+	  // `ReactServerRendering`), but server-side uses
+	  // `ReactServerRenderingTransaction` instead. This option is here so that it's
+	  // accessible and defaults to false when `ReactDOMComponent` and
+	  // `ReactDOMTextComponent` checks it in `mountComponent`.`
+	  this.renderToStaticMarkup = false;
+	  this.reactMountReady = CallbackQueue.getPooled(null);
+	  this.useCreateElement = useCreateElement;
+	}
+
+	var Mixin = {
+	  /**
+	   * @see Transaction
+	   * @abstract
+	   * @final
+	   * @return {array<object>} List of operation wrap procedures.
+	   *   TODO: convert to array<TransactionWrapper>
+	   */
+	  getTransactionWrappers: function () {
+	    return TRANSACTION_WRAPPERS;
+	  },
+
+	  /**
+	   * @return {object} The queue to collect `onDOMReady` callbacks with.
+	   */
+	  getReactMountReady: function () {
+	    return this.reactMountReady;
+	  },
+
+	  /**
+	   * @return {object} The queue to collect React async events.
+	   */
+	  getUpdateQueue: function () {
+	    return ReactUpdateQueue;
+	  },
+
+	  /**
+	   * Save current transaction state -- if the return value from this method is
+	   * passed to `rollback`, the transaction will be reset to that state.
+	   */
+	  checkpoint: function () {
+	    // reactMountReady is the our only stateful wrapper
+	    return this.reactMountReady.checkpoint();
+	  },
+
+	  rollback: function (checkpoint) {
+	    this.reactMountReady.rollback(checkpoint);
+	  },
+
+	  /**
+	   * `PooledClass` looks for this, and will invoke this before allowing this
+	   * instance to be reused.
+	   */
+	  destructor: function () {
+	    CallbackQueue.release(this.reactMountReady);
+	    this.reactMountReady = null;
+	  }
+	};
+
+	_assign(ReactReconcileTransaction.prototype, Transaction, Mixin);
+
+	PooledClass.addPoolingTo(ReactReconcileTransaction);
+
+	module.exports = ReactReconcileTransaction;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 151 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ReactDOMSelection = __webpack_require__(152);
+
+	var containsNode = __webpack_require__(154);
+	var focusNode = __webpack_require__(98);
+	var getActiveElement = __webpack_require__(157);
+
+	function isInDocument(node) {
+	  return containsNode(document.documentElement, 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
+	 * assume buttons have range selections allowed).
+	 * Input selection module for React.
+	 */
+	var ReactInputSelection = {
+
+	  hasSelectionCapabilities: function (elem) {
+	    var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
+	    return nodeName && (nodeName === 'input' && elem.type === 'text' || 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 && isInDocument(priorFocusedElem)) {
+	      if (ReactInputSelection.hasSelectionCapabilities(priorFocusedElem)) {
+	        ReactInputSelection.setSelection(priorFocusedElem, priorSelectionRange);
+	      }
+	      focusNode(priorFocusedElem);
+	    }
+	  },
+
+	  /**
+	   * @getSelection: Gets the selection bounds of a focused textarea, input or
+	   * contentEditable node.
+	   * -@input: Look up selection bounds of this input
+	   * -@return {start: selectionStart, end: selectionEnd}
+	   */
+	  getSelection: function (input) {
+	    var selection;
+
+	    if ('selectionStart' in input) {
+	      // Modern browser with input or textarea.
+	      selection = {
+	        start: input.selectionStart,
+	        end: input.selectionEnd
+	      };
+	    } else if (document.selection && input.nodeName && input.nodeName.toLowerCase() === 'input') {
+	      // IE8 input.
+	      var range = document.selection.createRange();
+	      // There can only be one selection per document in IE, so it must
+	      // be in our element.
+	      if (range.parentElement() === input) {
+	        selection = {
+	          start: -range.moveStart('character', -input.value.length),
+	          end: -range.moveEnd('character', -input.value.length)
+	        };
+	      }
+	    } else {
+	      // Content editable or old IE textarea.
+	      selection = ReactDOMSelection.getOffsets(input);
+	    }
+
+	    return selection || { start: 0, end: 0 };
+	  },
+
+	  /**
+	   * @setSelection: Sets the selection bounds of a textarea or input and focuses
+	   * the input.
+	   * -@input     Set selection bounds of this input or textarea
+	   * -@offsets   Object of same form that is returned from get*
+	   */
+	  setSelection: function (input, offsets) {
+	    var start = offsets.start;
+	    var end = offsets.end;
+	    if (end === undefined) {
+	      end = start;
+	    }
+
+	    if ('selectionStart' in input) {
+	      input.selectionStart = start;
+	      input.selectionEnd = Math.min(end, input.value.length);
+	    } else if (document.selection && input.nodeName && input.nodeName.toLowerCase() === 'input') {
+	      var range = input.createTextRange();
+	      range.collapse(true);
+	      range.moveStart('character', start);
+	      range.moveEnd('character', end - start);
+	      range.select();
+	    } else {
+	      ReactDOMSelection.setOffsets(input, offsets);
+	    }
+	  }
+	};
+
+	module.exports = ReactInputSelection;
+
+/***/ },
+/* 152 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ExecutionEnvironment = __webpack_require__(51);
+
+	var getNodeForCharacterOffset = __webpack_require__(153);
+	var getTextContentAccessor = __webpack_require__(55);
+
+	/**
+	 * While `isCollapsed` is available on the Selection object and `collapsed`
+	 * is available on the Range object, IE11 sometimes gets them wrong.
+	 * If the anchor/focus nodes and offsets are the same, the range is collapsed.
+	 */
+	function isCollapsed(anchorNode, anchorOffset, focusNode, focusOffset) {
+	  return anchorNode === focusNode && anchorOffset === focusOffset;
+	}
+
+	/**
+	 * Get the appropriate anchor and focus node/offset pairs for IE.
+	 *
+	 * The catch here is that IE's selection API doesn't provide information
+	 * about whether the selection is forward or backward, so we have to
+	 * behave as though it's always forward.
+	 *
+	 * IE text differs from modern selection in that it behaves as though
+	 * block elements end with a new line. This means character offsets will
+	 * differ between the two APIs.
+	 *
+	 * @param {DOMElement} node
+	 * @return {object}
+	 */
+	function getIEOffsets(node) {
+	  var selection = document.selection;
+	  var selectedRange = selection.createRange();
+	  var selectedLength = selectedRange.text.length;
+
+	  // Duplicate selection so we can move range without breaking user selection.
+	  var fromStart = selectedRange.duplicate();
+	  fromStart.moveToElementText(node);
+	  fromStart.setEndPoint('EndToStart', selectedRange);
+
+	  var startOffset = fromStart.text.length;
+	  var endOffset = startOffset + selectedLength;
+
+	  return {
+	    start: startOffset,
+	    end: endOffset
+	  };
+	}
+
+	/**
+	 * @param {DOMElement} node
+	 * @return {?object}
+	 */
+	function getModernOffsets(node) {
+	  var selection = window.getSelection && window.getSelection();
+
+	  if (!selection || selection.rangeCount === 0) {
+	    return null;
+	  }
+
+	  var anchorNode = selection.anchorNode;
+	  var anchorOffset = selection.anchorOffset;
+	  var focusNode = selection.focusNode;
+	  var focusOffset = selection.focusOffset;
+
+	  var currentRange = selection.getRangeAt(0);
+
+	  // In Firefox, range.startContainer and range.endContainer can be "anonymous
+	  // divs", e.g. the up/down buttons on an <input type="number">. Anonymous
+	  // divs do not seem to expose properties, triggering a "Permission denied
+	  // error" if any of its properties are accessed. The only seemingly possible
+	  // way to avoid erroring is to access a property that typically works for
+	  // non-anonymous divs and catch any error that may otherwise arise. See
+	  // https://bugzilla.mozilla.org/show_bug.cgi?id=208427
+	  try {
+	    /* eslint-disable no-unused-expressions */
+	    currentRange.startContainer.nodeType;
+	    currentRange.endContainer.nodeType;
+	    /* eslint-enable no-unused-expressions */
+	  } catch (e) {
+	    return null;
+	  }
+
+	  // If the node and offset values are the same, the selection is collapsed.
+	  // `Selection.isCollapsed` is available natively, but IE sometimes gets
+	  // this value wrong.
+	  var isSelectionCollapsed = isCollapsed(selection.anchorNode, selection.anchorOffset, selection.focusNode, selection.focusOffset);
+
+	  var rangeLength = isSelectionCollapsed ? 0 : currentRange.toString().length;
+
+	  var tempRange = currentRange.cloneRange();
+	  tempRange.selectNodeContents(node);
+	  tempRange.setEnd(currentRange.startContainer, currentRange.startOffset);
+
+	  var isTempRangeCollapsed = isCollapsed(tempRange.startContainer, tempRange.startOffset, tempRange.endContainer, tempRange.endOffset);
+
+	  var start = isTempRangeCollapsed ? 0 : tempRange.toString().length;
+	  var end = start + rangeLength;
+
+	  // Detect whether the selection is backward.
+	  var detectionRange = document.createRange();
+	  detectionRange.setStart(anchorNode, anchorOffset);
+	  detectionRange.setEnd(focusNode, focusOffset);
+	  var isBackward = detectionRange.collapsed;
+
+	  return {
+	    start: isBackward ? end : start,
+	    end: isBackward ? start : end
+	  };
+	}
+
+	/**
+	 * @param {DOMElement|DOMTextNode} node
+	 * @param {object} offsets
+	 */
+	function setIEOffsets(node, offsets) {
+	  var range = document.selection.createRange().duplicate();
+	  var start, end;
+
+	  if (offsets.end === undefined) {
+	    start = offsets.start;
+	    end = start;
+	  } else if (offsets.start > offsets.end) {
+	    start = offsets.end;
+	    end = offsets.start;
+	  } else {
+	    start = offsets.start;
+	    end = offsets.end;
+	  }
+
+	  range.moveToElementText(node);
+	  range.moveStart('character', start);
+	  range.setEndPoint('EndToStart', range);
+	  range.moveEnd('character', end - start);
+	  range.select();
+	}
+
+	/**
+	 * In modern non-IE browsers, we can support both forward and backward
+	 * selections.
+	 *
+	 * Note: IE10+ supports the Selection object, but it does not support
+	 * the `extend` method, which means that even in modern IE, it's not possible
+	 * to programmatically create a backward selection. Thus, for all IE
+	 * versions, we use the old IE API to create our selections.
+	 *
+	 * @param {DOMElement|DOMTextNode} node
+	 * @param {object} offsets
+	 */
+	function setModernOffsets(node, offsets) {
+	  if (!window.getSelection) {
+	    return;
+	  }
+
+	  var selection = window.getSelection();
+	  var length = node[getTextContentAccessor()].length;
+	  var start = Math.min(offsets.start, length);
+	  var end = offsets.end === undefined ? start : Math.min(offsets.end, length);
+
+	  // IE 11 uses modern selection, but doesn't support the extend method.
+	  // Flip backward selections, so we can set with a single range.
+	  if (!selection.extend && start > end) {
+	    var temp = end;
+	    end = start;
+	    start = temp;
+	  }
+
+	  var startMarker = getNodeForCharacterOffset(node, start);
+	  var endMarker = getNodeForCharacterOffset(node, end);
+
+	  if (startMarker && endMarker) {
+	    var range = document.createRange();
+	    range.setStart(startMarker.node, startMarker.offset);
+	    selection.removeAllRanges();
+
+	    if (start > end) {
+	      selection.addRange(range);
+	      selection.extend(endMarker.node, endMarker.offset);
+	    } else {
+	      range.setEnd(endMarker.node, endMarker.offset);
+	      selection.addRange(range);
+	    }
+	  }
+	}
+
+	var useIEOffsets = ExecutionEnvironment.canUseDOM && 'selection' in document && !('getSelection' in window);
+
+	var ReactDOMSelection = {
+	  /**
+	   * @param {DOMElement} node
+	   */
+	  getOffsets: useIEOffsets ? getIEOffsets : getModernOffsets,
+
+	  /**
+	   * @param {DOMElement|DOMTextNode} node
+	   * @param {object} offsets
+	   */
+	  setOffsets: useIEOffsets ? setIEOffsets : setModernOffsets
+	};
+
+	module.exports = ReactDOMSelection;
+
+/***/ },
+/* 153 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	/**
+	 * Given any node return the first leaf node without children.
+	 *
+	 * @param {DOMElement|DOMTextNode} node
+	 * @return {DOMElement|DOMTextNode}
+	 */
+
+	function getLeafNode(node) {
+	  while (node && node.firstChild) {
+	    node = node.firstChild;
+	  }
+	  return node;
+	}
+
+	/**
+	 * Get the next sibling within a container. This will walk up the
+	 * DOM if a node's siblings have been exhausted.
+	 *
+	 * @param {DOMElement|DOMTextNode} node
+	 * @return {?DOMElement|DOMTextNode}
+	 */
+	function getSiblingNode(node) {
+	  while (node) {
+	    if (node.nextSibling) {
+	      return node.nextSibling;
+	    }
+	    node = node.parentNode;
+	  }
+	}
+
+	/**
+	 * Get object describing the nodes which contain characters at offset.
+	 *
+	 * @param {DOMElement|DOMTextNode} root
+	 * @param {number} offset
+	 * @return {?object}
+	 */
+	function getNodeForCharacterOffset(root, offset) {
+	  var node = getLeafNode(root);
+	  var nodeStart = 0;
+	  var nodeEnd = 0;
+
+	  while (node) {
+	    if (node.nodeType === 3) {
+	      nodeEnd = nodeStart + node.textContent.length;
+
+	      if (nodeStart <= offset && nodeEnd >= offset) {
+	        return {
+	          node: node,
+	          offset: offset - nodeStart
+	        };
+	      }
+
+	      nodeStart = nodeEnd;
+	    }
+
+	    node = getLeafNode(getSiblingNode(node));
+	  }
+	}
+
+	module.exports = getNodeForCharacterOffset;
+
+/***/ },
+/* 154 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	var isTextNode = __webpack_require__(155);
+
+	/*eslint-disable no-bitwise */
+
+	/**
+	 * Checks if a given DOM node contains or is another DOM node.
+	 */
+	function containsNode(outerNode, innerNode) {
+	  if (!outerNode || !innerNode) {
+	    return false;
+	  } else if (outerNode === innerNode) {
+	    return true;
+	  } else if (isTextNode(outerNode)) {
+	    return false;
+	  } else if (isTextNode(innerNode)) {
+	    return containsNode(outerNode, innerNode.parentNode);
+	  } else if ('contains' in outerNode) {
+	    return outerNode.contains(innerNode);
+	  } else if (outerNode.compareDocumentPosition) {
+	    return !!(outerNode.compareDocumentPosition(innerNode) & 16);
+	  } else {
+	    return false;
+	  }
+	}
+
+	module.exports = containsNode;
+
+/***/ },
+/* 155 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * @typechecks
+	 */
+
+	var isNode = __webpack_require__(156);
+
+	/**
+	 * @param {*} object The object to check.
+	 * @return {boolean} Whether or not the object is a DOM text node.
+	 */
+	function isTextNode(object) {
+	  return isNode(object) && object.nodeType == 3;
+	}
+
+	module.exports = isTextNode;
+
+/***/ },
+/* 156 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * @typechecks
+	 */
+
+	/**
+	 * @param {*} object The object to check.
+	 * @return {boolean} Whether or not the object is a DOM node.
+	 */
+	function isNode(object) {
+	  return !!(object && (typeof Node === 'function' ? object instanceof Node : typeof object === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string'));
+	}
+
+	module.exports = isNode;
+
+/***/ },
+/* 157 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	/**
+	 * Copyright (c) 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * @typechecks
+	 */
+
+	/* eslint-disable fb-www/typeof-undefined */
+
+	/**
+	 * Same as document.activeElement but wraps in a try-catch block. In IE it is
+	 * not safe to call document.activeElement if there is nothing focused.
+	 *
+	 * The activeElement will be null only if the document or document body is not
+	 * yet defined.
+	 */
+	function getActiveElement() /*?DOMElement*/{
+	  if (typeof document === 'undefined') {
+	    return null;
+	  }
+	  try {
+	    return document.activeElement || document.body;
+	  } catch (e) {
+	    return document.body;
+	  }
+	}
+
+	module.exports = getActiveElement;
+
+/***/ },
+/* 158 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var NS = {
+	  xlink: 'http://www.w3.org/1999/xlink',
+	  xml: 'http://www.w3.org/XML/1998/namespace'
+	};
+
+	// We use attributes for everything SVG so let's avoid some duplication and run
+	// code instead.
+	// The following are all specified in the HTML config already so we exclude here.
+	// - class (as className)
+	// - color
+	// - height
+	// - id
+	// - lang
+	// - max
+	// - media
+	// - method
+	// - min
+	// - name
+	// - style
+	// - target
+	// - type
+	// - width
+	var ATTRS = {
+	  accentHeight: 'accent-height',
+	  accumulate: 0,
+	  additive: 0,
+	  alignmentBaseline: 'alignment-baseline',
+	  allowReorder: 'allowReorder',
+	  alphabetic: 0,
+	  amplitude: 0,
+	  arabicForm: 'arabic-form',
+	  ascent: 0,
+	  attributeName: 'attributeName',
+	  attributeType: 'attributeType',
+	  autoReverse: 'autoReverse',
+	  azimuth: 0,
+	  baseFrequency: 'baseFrequency',
+	  baseProfile: 'baseProfile',
+	  baselineShift: 'baseline-shift',
+	  bbox: 0,
+	  begin: 0,
+	  bias: 0,
+	  by: 0,
+	  calcMode: 'calcMode',
+	  capHeight: 'cap-height',
+	  clip: 0,
+	  clipPath: 'clip-path',
+	  clipRule: 'clip-rule',
+	  clipPathUnits: 'clipPathUnits',
+	  colorInterpolation: 'color-interpolation',
+	  colorInterpolationFilters: 'color-interpolation-filters',
+	  colorProfile: 'color-profile',
+	  colorRendering: 'color-rendering',
+	  contentScriptType: 'contentScriptType',
+	  contentStyleType: 'contentStyleType',
+	  cursor: 0,
+	  cx: 0,
+	  cy: 0,
+	  d: 0,
+	  decelerate: 0,
+	  descent: 0,
+	  diffuseConstant: 'diffuseConstant',
+	  direction: 0,
+	  display: 0,
+	  divisor: 0,
+	  dominantBaseline: 'dominant-baseline',
+	  dur: 0,
+	  dx: 0,
+	  dy: 0,
+	  edgeMode: 'edgeMode',
+	  elevation: 0,
+	  enableBackground: 'enable-background',
+	  end: 0,
+	  exponent: 0,
+	  externalResourcesRequired: 'externalResourcesRequired',
+	  fill: 0,
+	  fillOpacity: 'fill-opacity',
+	  fillRule: 'fill-rule',
+	  filter: 0,
+	  filterRes: 'filterRes',
+	  filterUnits: 'filterUnits',
+	  floodColor: 'flood-color',
+	  floodOpacity: 'flood-opacity',
+	  focusable: 0,
+	  fontFamily: 'font-family',
+	  fontSize: 'font-size',
+	  fontSizeAdjust: 'font-size-adjust',
+	  fontStretch: 'font-stretch',
+	  fontStyle: 'font-style',
+	  fontVariant: 'font-variant',
+	  fontWeight: 'font-weight',
+	  format: 0,
+	  from: 0,
+	  fx: 0,
+	  fy: 0,
+	  g1: 0,
+	  g2: 0,
+	  glyphName: 'glyph-name',
+	  glyphOrientationHorizontal: 'glyph-orientation-horizontal',
+	  glyphOrientationVertical: 'glyph-orientation-vertical',
+	  glyphRef: 'glyphRef',
+	  gradientTransform: 'gradientTransform',
+	  gradientUnits: 'gradientUnits',
+	  hanging: 0,
+	  horizAdvX: 'horiz-adv-x',
+	  horizOriginX: 'horiz-origin-x',
+	  ideographic: 0,
+	  imageRendering: 'image-rendering',
+	  'in': 0,
+	  in2: 0,
+	  intercept: 0,
+	  k: 0,
+	  k1: 0,
+	  k2: 0,
+	  k3: 0,
+	  k4: 0,
+	  kernelMatrix: 'kernelMatrix',
+	  kernelUnitLength: 'kernelUnitLength',
+	  kerning: 0,
+	  keyPoints: 'keyPoints',
+	  keySplines: 'keySplines',
+	  keyTimes: 'keyTimes',
+	  lengthAdjust: 'lengthAdjust',
+	  letterSpacing: 'letter-spacing',
+	  lightingColor: 'lighting-color',
+	  limitingConeAngle: 'limitingConeAngle',
+	  local: 0,
+	  markerEnd: 'marker-end',
+	  markerMid: 'marker-mid',
+	  markerStart: 'marker-start',
+	  markerHeight: 'markerHeight',
+	  markerUnits: 'markerUnits',
+	  markerWidth: 'markerWidth',
+	  mask: 0,
+	  maskContentUnits: 'maskContentUnits',
+	  maskUnits: 'maskUnits',
+	  mathematical: 0,
+	  mode: 0,
+	  numOctaves: 'numOctaves',
+	  offset: 0,
+	  opacity: 0,
+	  operator: 0,
+	  order: 0,
+	  orient: 0,
+	  orientation: 0,
+	  origin: 0,
+	  overflow: 0,
+	  overlinePosition: 'overline-position',
+	  overlineThickness: 'overline-thickness',
+	  paintOrder: 'paint-order',
+	  panose1: 'panose-1',
+	  pathLength: 'pathLength',
+	  patternContentUnits: 'patternContentUnits',
+	  patternTransform: 'patternTransform',
+	  patternUnits: 'patternUnits',
+	  pointerEvents: 'pointer-events',
+	  points: 0,
+	  pointsAtX: 'pointsAtX',
+	  pointsAtY: 'pointsAtY',
+	  pointsAtZ: 'pointsAtZ',
+	  preserveAlpha: 'preserveAlpha',
+	  preserveAspectRatio: 'preserveAspectRatio',
+	  primitiveUnits: 'primitiveUnits',
+	  r: 0,
+	  radius: 0,
+	  refX: 'refX',
+	  refY: 'refY',
+	  renderingIntent: 'rendering-intent',
+	  repeatCount: 'repeatCount',
+	  repeatDur: 'repeatDur',
+	  requiredExtensions: 'requiredExtensions',
+	  requiredFeatures: 'requiredFeatures',
+	  restart: 0,
+	  result: 0,
+	  rotate: 0,
+	  rx: 0,
+	  ry: 0,
+	  scale: 0,
+	  seed: 0,
+	  shapeRendering: 'shape-rendering',
+	  slope: 0,
+	  spacing: 0,
+	  specularConstant: 'specularConstant',
+	  specularExponent: 'specularExponent',
+	  speed: 0,
+	  spreadMethod: 'spreadMethod',
+	  startOffset: 'startOffset',
+	  stdDeviation: 'stdDeviation',
+	  stemh: 0,
+	  stemv: 0,
+	  stitchTiles: 'stitchTiles',
+	  stopColor: 'stop-color',
+	  stopOpacity: 'stop-opacity',
+	  strikethroughPosition: 'strikethrough-position',
+	  strikethroughThickness: 'strikethrough-thickness',
+	  string: 0,
+	  stroke: 0,
+	  strokeDasharray: 'stroke-dasharray',
+	  strokeDashoffset: 'stroke-dashoffset',
+	  strokeLinecap: 'stroke-linecap',
+	  strokeLinejoin: 'stroke-linejoin',
+	  strokeMiterlimit: 'stroke-miterlimit',
+	  strokeOpacity: 'stroke-opacity',
+	  strokeWidth: 'stroke-width',
+	  surfaceScale: 'surfaceScale',
+	  systemLanguage: 'systemLanguage',
+	  tableValues: 'tableValues',
+	  targetX: 'targetX',
+	  targetY: 'targetY',
+	  textAnchor: 'text-anchor',
+	  textDecoration: 'text-decoration',
+	  textRendering: 'text-rendering',
+	  textLength: 'textLength',
+	  to: 0,
+	  transform: 0,
+	  u1: 0,
+	  u2: 0,
+	  underlinePosition: 'underline-position',
+	  underlineThickness: 'underline-thickness',
+	  unicode: 0,
+	  unicodeBidi: 'unicode-bidi',
+	  unicodeRange: 'unicode-range',
+	  unitsPerEm: 'units-per-em',
+	  vAlphabetic: 'v-alphabetic',
+	  vHanging: 'v-hanging',
+	  vIdeographic: 'v-ideographic',
+	  vMathematical: 'v-mathematical',
+	  values: 0,
+	  vectorEffect: 'vector-effect',
+	  version: 0,
+	  vertAdvY: 'vert-adv-y',
+	  vertOriginX: 'vert-origin-x',
+	  vertOriginY: 'vert-origin-y',
+	  viewBox: 'viewBox',
+	  viewTarget: 'viewTarget',
+	  visibility: 0,
+	  widths: 0,
+	  wordSpacing: 'word-spacing',
+	  writingMode: 'writing-mode',
+	  x: 0,
+	  xHeight: 'x-height',
+	  x1: 0,
+	  x2: 0,
+	  xChannelSelector: 'xChannelSelector',
+	  xlinkActuate: 'xlink:actuate',
+	  xlinkArcrole: 'xlink:arcrole',
+	  xlinkHref: 'xlink:href',
+	  xlinkRole: 'xlink:role',
+	  xlinkShow: 'xlink:show',
+	  xlinkTitle: 'xlink:title',
+	  xlinkType: 'xlink:type',
+	  xmlBase: 'xml:base',
+	  xmlns: 0,
+	  xmlnsXlink: 'xmlns:xlink',
+	  xmlLang: 'xml:lang',
+	  xmlSpace: 'xml:space',
+	  y: 0,
+	  y1: 0,
+	  y2: 0,
+	  yChannelSelector: 'yChannelSelector',
+	  z: 0,
+	  zoomAndPan: 'zoomAndPan'
+	};
+
+	var SVGDOMPropertyConfig = {
+	  Properties: {},
+	  DOMAttributeNamespaces: {
+	    xlinkActuate: NS.xlink,
+	    xlinkArcrole: NS.xlink,
+	    xlinkHref: NS.xlink,
+	    xlinkRole: NS.xlink,
+	    xlinkShow: NS.xlink,
+	    xlinkTitle: NS.xlink,
+	    xlinkType: NS.xlink,
+	    xmlBase: NS.xml,
+	    xmlLang: NS.xml,
+	    xmlSpace: NS.xml
+	  },
+	  DOMAttributeNames: {}
+	};
+
+	Object.keys(ATTRS).forEach(function (key) {
+	  SVGDOMPropertyConfig.Properties[key] = 0;
+	  if (ATTRS[key]) {
+	    SVGDOMPropertyConfig.DOMAttributeNames[key] = ATTRS[key];
+	  }
+	});
+
+	module.exports = SVGDOMPropertyConfig;
+
+/***/ },
+/* 159 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var EventPropagators = __webpack_require__(42);
+	var ExecutionEnvironment = __webpack_require__(51);
+	var ReactDOMComponentTree = __webpack_require__(34);
+	var ReactInputSelection = __webpack_require__(151);
+	var SyntheticEvent = __webpack_require__(57);
+
+	var getActiveElement = __webpack_require__(157);
+	var isTextInputElement = __webpack_require__(75);
+	var shallowEqual = __webpack_require__(128);
+
+	var skipSelectionChangeEvent = ExecutionEnvironment.canUseDOM && 'documentMode' in document && document.documentMode <= 11;
+
+	var eventTypes = {
+	  select: {
+	    phasedRegistrationNames: {
+	      bubbled: 'onSelect',
+	      captured: 'onSelectCapture'
+	    },
+	    dependencies: ['topBlur', 'topContextMenu', 'topFocus', 'topKeyDown', 'topKeyUp', 'topMouseDown', 'topMouseUp', 'topSelectionChange']
+	  }
+	};
+
+	var activeElement = null;
+	var activeElementInst = null;
+	var lastSelection = null;
+	var mouseDown = false;
+
+	// Track whether a listener exists for this plugin. If none exist, we do
+	// not extract events. See #3639.
+	var hasListener = false;
+
+	/**
+	 * Get an object which is a unique representation of the current selection.
+	 *
+	 * The return value will not be consistent across nodes or browsers, but
+	 * two identical selections on the same node will return identical objects.
+	 *
+	 * @param {DOMElement} node
+	 * @return {object}
+	 */
+	function getSelection(node) {
+	  if ('selectionStart' in node && ReactInputSelection.hasSelectionCapabilities(node)) {
+	    return {
+	      start: node.selectionStart,
+	      end: node.selectionEnd
+	    };
+	  } else if (window.getSelection) {
+	    var selection = window.getSelection();
+	    return {
+	      anchorNode: selection.anchorNode,
+	      anchorOffset: selection.anchorOffset,
+	      focusNode: selection.focusNode,
+	      focusOffset: selection.focusOffset
+	    };
+	  } else if (document.selection) {
+	    var range = document.selection.createRange();
+	    return {
+	      parentElement: range.parentElement(),
+	      text: range.text,
+	      top: range.boundingTop,
+	      left: range.boundingLeft
+	    };
+	  }
+	}
+
+	/**
+	 * Poll selection to see whether it's changed.
+	 *
+	 * @param {object} nativeEvent
+	 * @return {?SyntheticEvent}
+	 */
+	function constructSelectEvent(nativeEvent, nativeEventTarget) {
+	  // Ensure we have the right element, and that the user is not dragging a
+	  // selection (this matches native `select` event behavior). In HTML5, select
+	  // fires only on input and textarea thus if there's no focused element we
+	  // won't dispatch.
+	  if (mouseDown || activeElement == null || activeElement !== getActiveElement()) {
+	    return null;
+	  }
+
+	  // Only fire when selection has actually changed.
+	  var currentSelection = getSelection(activeElement);
+	  if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {
+	    lastSelection = currentSelection;
+
+	    var syntheticEvent = SyntheticEvent.getPooled(eventTypes.select, activeElementInst, nativeEvent, nativeEventTarget);
+
+	    syntheticEvent.type = 'select';
+	    syntheticEvent.target = activeElement;
+
+	    EventPropagators.accumulateTwoPhaseDispatches(syntheticEvent);
+
+	    return syntheticEvent;
+	  }
+
+	  return null;
+	}
+
+	/**
+	 * This plugin creates an `onSelect` event that normalizes select events
+	 * across form elements.
+	 *
+	 * Supported elements are:
+	 * - input (see `isTextInputElement`)
+	 * - textarea
+	 * - contentEditable
+	 *
+	 * This differs from native browser implementations in the following ways:
+	 * - Fires on contentEditable fields as well as inputs.
+	 * - Fires for collapsed selection.
+	 * - Fires after user input.
+	 */
+	var SelectEventPlugin = {
+
+	  eventTypes: eventTypes,
+
+	  extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+	    if (!hasListener) {
+	      return null;
+	    }
+
+	    var targetNode = targetInst ? ReactDOMComponentTree.getNodeFromInstance(targetInst) : window;
+
+	    switch (topLevelType) {
+	      // Track the input node that has focus.
+	      case 'topFocus':
+	        if (isTextInputElement(targetNode) || targetNode.contentEditable === 'true') {
+	          activeElement = targetNode;
+	          activeElementInst = targetInst;
+	          lastSelection = null;
+	        }
+	        break;
+	      case 'topBlur':
+	        activeElement = null;
+	        activeElementInst = null;
+	        lastSelection = null;
+	        break;
+
+	      // Don't fire the event while the user is dragging. This matches the
+	      // semantics of the native select event.
+	      case 'topMouseDown':
+	        mouseDown = true;
+	        break;
+	      case 'topContextMenu':
+	      case 'topMouseUp':
+	        mouseDown = false;
+	        return constructSelectEvent(nativeEvent, nativeEventTarget);
+
+	      // Chrome and IE fire non-standard event when selection is changed (and
+	      // sometimes when it hasn't). IE's event fires out of order with respect
+	      // to key and input events on deletion, so we discard it.
+	      //
+	      // Firefox doesn't support selectionchange, so check selection status
+	      // after each key entry. The selection changes after keydown and before
+	      // keyup, but we check on keydown as well in the case of holding down a
+	      // key, when multiple keydown events are fired but only one keyup is.
+	      // This is also our approach for IE handling, for the reason above.
+	      case 'topSelectionChange':
+	        if (skipSelectionChangeEvent) {
+	          break;
+	        }
+	      // falls through
+	      case 'topKeyDown':
+	      case 'topKeyUp':
+	        return constructSelectEvent(nativeEvent, nativeEventTarget);
+	    }
+
+	    return null;
+	  },
+
+	  didPutListener: function (inst, registrationName, listener) {
+	    if (registrationName === 'onSelect') {
+	      hasListener = true;
+	    }
+	  }
+	};
+
+	module.exports = SelectEventPlugin;
+
+/***/ },
+/* 160 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var EventListener = __webpack_require__(147);
+	var EventPropagators = __webpack_require__(42);
+	var ReactDOMComponentTree = __webpack_require__(34);
+	var SyntheticAnimationEvent = __webpack_require__(161);
+	var SyntheticClipboardEvent = __webpack_require__(162);
+	var SyntheticEvent = __webpack_require__(57);
+	var SyntheticFocusEvent = __webpack_require__(163);
+	var SyntheticKeyboardEvent = __webpack_require__(164);
+	var SyntheticMouseEvent = __webpack_require__(78);
+	var SyntheticDragEvent = __webpack_require__(167);
+	var SyntheticTouchEvent = __webpack_require__(168);
+	var SyntheticTransitionEvent = __webpack_require__(169);
+	var SyntheticUIEvent = __webpack_require__(79);
+	var SyntheticWheelEvent = __webpack_require__(170);
+
+	var emptyFunction = __webpack_require__(48);
+	var getEventCharCode = __webpack_require__(165);
+	var invariant = __webpack_require__(37);
+
+	/**
+	 * Turns
+	 * ['abort', ...]
+	 * into
+	 * eventTypes = {
+	 *   'abort': {
+	 *     phasedRegistrationNames: {
+	 *       bubbled: 'onAbort',
+	 *       captured: 'onAbortCapture',
+	 *     },
+	 *     dependencies: ['topAbort'],
+	 *   },
+	 *   ...
+	 * };
+	 * topLevelEventsToDispatchConfig = {
+	 *   'topAbort': { sameConfig }
+	 * };
+	 */
+	var eventTypes = {};
+	var topLevelEventsToDispatchConfig = {};
+	['abort', 'animationEnd', 'animationIteration', 'animationStart', 'blur', 'canPlay', 'canPlayThrough', 'click', 'contextMenu', 'copy', 'cut', 'doubleClick', 'drag', 'dragEnd', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'dragStart', 'drop', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'focus', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'mouseDown', 'mouseMove', 'mouseOut', 'mouseOver', 'mouseUp', 'paste', 'pause', 'play', 'playing', 'progress', 'rateChange', 'reset', 'scroll', 'seeked', 'seeking', 'stalled', 'submit', 'suspend', 'timeUpdate', 'touchCancel', 'touchEnd', 'touchMove', 'touchStart', 'transitionEnd', 'volumeChange', 'waiting', 'wheel'].forEach(function (event) {
+	  var capitalizedEvent = event[0].toUpperCase() + event.slice(1);
+	  var onEvent = 'on' + capitalizedEvent;
+	  var topEvent = 'top' + capitalizedEvent;
+
+	  var type = {
+	    phasedRegistrationNames: {
+	      bubbled: onEvent,
+	      captured: onEvent + 'Capture'
+	    },
+	    dependencies: [topEvent]
+	  };
+	  eventTypes[event] = type;
+	  topLevelEventsToDispatchConfig[topEvent] = type;
+	});
+
+	var onClickListeners = {};
+
+	function getDictionaryKey(inst) {
+	  // Prevents V8 performance issue:
+	  // https://github.com/facebook/react/pull/7232
+	  return '.' + inst._rootNodeID;
+	}
+
+	function isInteractive(tag) {
+	  return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea';
+	}
+
+	var SimpleEventPlugin = {
+
+	  eventTypes: eventTypes,
+
+	  extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+	    var dispatchConfig = topLevelEventsToDispatchConfig[topLevelType];
+	    if (!dispatchConfig) {
+	      return null;
+	    }
+	    var EventConstructor;
+	    switch (topLevelType) {
+	      case 'topAbort':
+	      case 'topCanPlay':
+	      case 'topCanPlayThrough':
+	      case 'topDurationChange':
+	      case 'topEmptied':
+	      case 'topEncrypted':
+	      case 'topEnded':
+	      case 'topError':
+	      case 'topInput':
+	      case 'topInvalid':
+	      case 'topLoad':
+	      case 'topLoadedData':
+	      case 'topLoadedMetadata':
+	      case 'topLoadStart':
+	      case 'topPause':
+	      case 'topPlay':
+	      case 'topPlaying':
+	      case 'topProgress':
+	      case 'topRateChange':
+	      case 'topReset':
+	      case 'topSeeked':
+	      case 'topSeeking':
+	      case 'topStalled':
+	      case 'topSubmit':
+	      case 'topSuspend':
+	      case 'topTimeUpdate':
+	      case 'topVolumeChange':
+	      case 'topWaiting':
+	        // HTML Events
+	        // @see http://www.w3.org/TR/html5/index.html#events-0
+	        EventConstructor = SyntheticEvent;
+	        break;
+	      case 'topKeyPress':
+	        // Firefox creates a keypress event for function keys too. This removes
+	        // the unwanted keypress events. Enter is however both printable and
+	        // non-printable. One would expect Tab to be as well (but it isn't).
+	        if (getEventCharCode(nativeEvent) === 0) {
+	          return null;
+	        }
+	      /* falls through */
+	      case 'topKeyDown':
+	      case 'topKeyUp':
+	        EventConstructor = SyntheticKeyboardEvent;
+	        break;
+	      case 'topBlur':
+	      case 'topFocus':
+	        EventConstructor = SyntheticFocusEvent;
+	        break;
+	      case 'topClick':
+	        // Firefox creates a click event on right mouse clicks. This removes the
+	        // unwanted click events.
+	        if (nativeEvent.button === 2) {
+	          return null;
+	        }
+	      /* falls through */
+	      case 'topDoubleClick':
+	      case 'topMouseDown':
+	      case 'topMouseMove':
+	      case 'topMouseUp':
+	      // TODO: Disabled elements should not respond to mouse events
+	      /* falls through */
+	      case 'topMouseOut':
+	      case 'topMouseOver':
+	      case 'topContextMenu':
+	        EventConstructor = SyntheticMouseEvent;
+	        break;
+	      case 'topDrag':
+	      case 'topDragEnd':
+	      case 'topDragEnter':
+	      case 'topDragExit':
+	      case 'topDragLeave':
+	      case 'topDragOver':
+	      case 'topDragStart':
+	      case 'topDrop':
+	        EventConstructor = SyntheticDragEvent;
+	        break;
+	      case 'topTouchCancel':
+	      case 'topTouchEnd':
+	      case 'topTouchMove':
+	      case 'topTouchStart':
+	        EventConstructor = SyntheticTouchEvent;
+	        break;
+	      case 'topAnimationEnd':
+	      case 'topAnimationIteration':
+	      case 'topAnimationStart':
+	        EventConstructor = SyntheticAnimationEvent;
+	        break;
+	      case 'topTransitionEnd':
+	        EventConstructor = SyntheticTransitionEvent;
+	        break;
+	      case 'topScroll':
+	        EventConstructor = SyntheticUIEvent;
+	        break;
+	      case 'topWheel':
+	        EventConstructor = SyntheticWheelEvent;
+	        break;
+	      case 'topCopy':
+	      case 'topCut':
+	      case 'topPaste':
+	        EventConstructor = SyntheticClipboardEvent;
+	        break;
+	    }
+	    !EventConstructor ? process.env.NODE_ENV !== 'production' ? invariant(false, 'SimpleEventPlugin: Unhandled event type, `%s`.', topLevelType) : _prodInvariant('86', topLevelType) : void 0;
+	    var event = EventConstructor.getPooled(dispatchConfig, targetInst, nativeEvent, nativeEventTarget);
+	    EventPropagators.accumulateTwoPhaseDispatches(event);
+	    return event;
+	  },
+
+	  didPutListener: function (inst, registrationName, listener) {
+	    // Mobile Safari does not fire properly bubble click events on
+	    // non-interactive elements, which means delegated click listeners do not
+	    // fire. The workaround for this bug involves attaching an empty click
+	    // listener on the target node.
+	    // http://www.quirksmode.org/blog/archives/2010/09/click_event_del.html
+	    if (registrationName === 'onClick' && !isInteractive(inst._tag)) {
+	      var key = getDictionaryKey(inst);
+	      var node = ReactDOMComponentTree.getNodeFromInstance(inst);
+	      if (!onClickListeners[key]) {
+	        onClickListeners[key] = EventListener.listen(node, 'click', emptyFunction);
+	      }
+	    }
+	  },
+
+	  willDeleteListener: function (inst, registrationName) {
+	    if (registrationName === 'onClick' && !isInteractive(inst._tag)) {
+	      var key = getDictionaryKey(inst);
+	      onClickListeners[key].remove();
+	      delete onClickListeners[key];
+	    }
+	  }
+
+	};
+
+	module.exports = SimpleEventPlugin;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 161 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var SyntheticEvent = __webpack_require__(57);
+
+	/**
+	 * @interface Event
+	 * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent
+	 */
+	var AnimationEventInterface = {
+	  animationName: null,
+	  elapsedTime: null,
+	  pseudoElement: null
+	};
+
+	/**
+	 * @param {object} dispatchConfig Configuration used to dispatch this event.
+	 * @param {string} dispatchMarker Marker identifying the event target.
+	 * @param {object} nativeEvent Native browser event.
+	 * @extends {SyntheticEvent}
+	 */
+	function SyntheticAnimationEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
+	  return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
+	}
+
+	SyntheticEvent.augmentClass(SyntheticAnimationEvent, AnimationEventInterface);
+
+	module.exports = SyntheticAnimationEvent;
+
+/***/ },
+/* 162 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var SyntheticEvent = __webpack_require__(57);
+
+	/**
+	 * @interface Event
+	 * @see http://www.w3.org/TR/clipboard-apis/
+	 */
+	var ClipboardEventInterface = {
+	  clipboardData: function (event) {
+	    return 'clipboardData' in event ? event.clipboardData : window.clipboardData;
+	  }
+	};
+
+	/**
+	 * @param {object} dispatchConfig Configuration used to dispatch this event.
+	 * @param {string} dispatchMarker Marker identifying the event target.
+	 * @param {object} nativeEvent Native browser event.
+	 * @extends {SyntheticUIEvent}
+	 */
+	function SyntheticClipboardEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
+	  return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
+	}
+
+	SyntheticEvent.augmentClass(SyntheticClipboardEvent, ClipboardEventInterface);
+
+	module.exports = SyntheticClipboardEvent;
+
+/***/ },
+/* 163 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var SyntheticUIEvent = __webpack_require__(79);
+
+	/**
+	 * @interface FocusEvent
+	 * @see http://www.w3.org/TR/DOM-Level-3-Events/
+	 */
+	var FocusEventInterface = {
+	  relatedTarget: null
+	};
+
+	/**
+	 * @param {object} dispatchConfig Configuration used to dispatch this event.
+	 * @param {string} dispatchMarker Marker identifying the event target.
+	 * @param {object} nativeEvent Native browser event.
+	 * @extends {SyntheticUIEvent}
+	 */
+	function SyntheticFocusEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
+	  return SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
+	}
+
+	SyntheticUIEvent.augmentClass(SyntheticFocusEvent, FocusEventInterface);
+
+	module.exports = SyntheticFocusEvent;
+
+/***/ },
+/* 164 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var SyntheticUIEvent = __webpack_require__(79);
+
+	var getEventCharCode = __webpack_require__(165);
+	var getEventKey = __webpack_require__(166);
+	var getEventModifierState = __webpack_require__(81);
+
+	/**
+	 * @interface KeyboardEvent
+	 * @see http://www.w3.org/TR/DOM-Level-3-Events/
+	 */
+	var KeyboardEventInterface = {
+	  key: getEventKey,
+	  location: null,
+	  ctrlKey: null,
+	  shiftKey: null,
+	  altKey: null,
+	  metaKey: null,
+	  repeat: null,
+	  locale: null,
+	  getModifierState: getEventModifierState,
+	  // Legacy Interface
+	  charCode: function (event) {
+	    // `charCode` is the result of a KeyPress event and represents the value of
+	    // the actual printable character.
+
+	    // KeyPress is deprecated, but its replacement is not yet final and not
+	    // implemented in any major browser. Only KeyPress has charCode.
+	    if (event.type === 'keypress') {
+	      return getEventCharCode(event);
+	    }
+	    return 0;
+	  },
+	  keyCode: function (event) {
+	    // `keyCode` is the result of a KeyDown/Up event and represents the value of
+	    // physical keyboard key.
+
+	    // The actual meaning of the value depends on the users' keyboard layout
+	    // which cannot be detected. Assuming that it is a US keyboard layout
+	    // provides a surprisingly accurate mapping for US and European users.
+	    // Due to this, it is left to the user to implement at this time.
+	    if (event.type === 'keydown' || event.type === 'keyup') {
+	      return event.keyCode;
+	    }
+	    return 0;
+	  },
+	  which: function (event) {
+	    // `which` is an alias for either `keyCode` or `charCode` depending on the
+	    // type of the event.
+	    if (event.type === 'keypress') {
+	      return getEventCharCode(event);
+	    }
+	    if (event.type === 'keydown' || event.type === 'keyup') {
+	      return event.keyCode;
+	    }
+	    return 0;
+	  }
+	};
+
+	/**
+	 * @param {object} dispatchConfig Configuration used to dispatch this event.
+	 * @param {string} dispatchMarker Marker identifying the event target.
+	 * @param {object} nativeEvent Native browser event.
+	 * @extends {SyntheticUIEvent}
+	 */
+	function SyntheticKeyboardEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
+	  return SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
+	}
+
+	SyntheticUIEvent.augmentClass(SyntheticKeyboardEvent, KeyboardEventInterface);
+
+	module.exports = SyntheticKeyboardEvent;
+
+/***/ },
+/* 165 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	/**
+	 * `charCode` represents the actual "character code" and is safe to use with
+	 * `String.fromCharCode`. As such, only keys that correspond to printable
+	 * characters produce a valid `charCode`, the only exception to this is Enter.
+	 * The Tab-key is considered non-printable and does not have a `charCode`,
+	 * presumably because it does not produce a tab-character in browsers.
+	 *
+	 * @param {object} nativeEvent Native browser event.
+	 * @return {number} Normalized `charCode` property.
+	 */
+
+	function getEventCharCode(nativeEvent) {
+	  var charCode;
+	  var keyCode = nativeEvent.keyCode;
+
+	  if ('charCode' in nativeEvent) {
+	    charCode = nativeEvent.charCode;
+
+	    // FF does not set `charCode` for the Enter-key, check against `keyCode`.
+	    if (charCode === 0 && keyCode === 13) {
+	      charCode = 13;
+	    }
+	  } else {
+	    // IE8 does not implement `charCode`, but `keyCode` has the correct value.
+	    charCode = keyCode;
+	  }
+
+	  // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
+	  // Must not discard the (non-)printable Enter-key.
+	  if (charCode >= 32 || charCode === 13) {
+	    return charCode;
+	  }
+
+	  return 0;
+	}
+
+	module.exports = getEventCharCode;
+
+/***/ },
+/* 166 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var getEventCharCode = __webpack_require__(165);
+
+	/**
+	 * Normalization of deprecated HTML5 `key` values
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+	 */
+	var normalizeKey = {
+	  'Esc': 'Escape',
+	  'Spacebar': ' ',
+	  'Left': 'ArrowLeft',
+	  'Up': 'ArrowUp',
+	  'Right': 'ArrowRight',
+	  'Down': 'ArrowDown',
+	  'Del': 'Delete',
+	  'Win': 'OS',
+	  'Menu': 'ContextMenu',
+	  'Apps': 'ContextMenu',
+	  'Scroll': 'ScrollLock',
+	  'MozPrintableKey': 'Unidentified'
+	};
+
+	/**
+	 * Translation from legacy `keyCode` to HTML5 `key`
+	 * Only special keys supported, all others depend on keyboard layout or browser
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
+	 */
+	var translateToKey = {
+	  8: 'Backspace',
+	  9: 'Tab',
+	  12: 'Clear',
+	  13: 'Enter',
+	  16: 'Shift',
+	  17: 'Control',
+	  18: 'Alt',
+	  19: 'Pause',
+	  20: 'CapsLock',
+	  27: 'Escape',
+	  32: ' ',
+	  33: 'PageUp',
+	  34: 'PageDown',
+	  35: 'End',
+	  36: 'Home',
+	  37: 'ArrowLeft',
+	  38: 'ArrowUp',
+	  39: 'ArrowRight',
+	  40: 'ArrowDown',
+	  45: 'Insert',
+	  46: 'Delete',
+	  112: 'F1', 113: 'F2', 114: 'F3', 115: 'F4', 116: 'F5', 117: 'F6',
+	  118: 'F7', 119: 'F8', 120: 'F9', 121: 'F10', 122: 'F11', 123: 'F12',
+	  144: 'NumLock',
+	  145: 'ScrollLock',
+	  224: 'Meta'
+	};
+
+	/**
+	 * @param {object} nativeEvent Native browser event.
+	 * @return {string} Normalized `key` property.
+	 */
+	function getEventKey(nativeEvent) {
+	  if (nativeEvent.key) {
+	    // Normalize inconsistent values reported by browsers due to
+	    // implementations of a working draft specification.
+
+	    // FireFox implements `key` but returns `MozPrintableKey` for all
+	    // printable characters (normalized to `Unidentified`), ignore it.
+	    var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
+	    if (key !== 'Unidentified') {
+	      return key;
+	    }
+	  }
+
+	  // Browser does not implement `key`, polyfill as much of it as we can.
+	  if (nativeEvent.type === 'keypress') {
+	    var charCode = getEventCharCode(nativeEvent);
+
+	    // The enter-key is technically both printable and non-printable and can
+	    // thus be captured by `keypress`, no other non-printable key should.
+	    return charCode === 13 ? 'Enter' : String.fromCharCode(charCode);
+	  }
+	  if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {
+	    // While user keyboard layout determines the actual meaning of each
+	    // `keyCode` value, almost all function keys have a universal value.
+	    return translateToKey[nativeEvent.keyCode] || 'Unidentified';
+	  }
+	  return '';
+	}
+
+	module.exports = getEventKey;
+
+/***/ },
+/* 167 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var SyntheticMouseEvent = __webpack_require__(78);
+
+	/**
+	 * @interface DragEvent
+	 * @see http://www.w3.org/TR/DOM-Level-3-Events/
+	 */
+	var DragEventInterface = {
+	  dataTransfer: null
+	};
+
+	/**
+	 * @param {object} dispatchConfig Configuration used to dispatch this event.
+	 * @param {string} dispatchMarker Marker identifying the event target.
+	 * @param {object} nativeEvent Native browser event.
+	 * @extends {SyntheticUIEvent}
+	 */
+	function SyntheticDragEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
+	  return SyntheticMouseEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
+	}
+
+	SyntheticMouseEvent.augmentClass(SyntheticDragEvent, DragEventInterface);
+
+	module.exports = SyntheticDragEvent;
+
+/***/ },
+/* 168 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var SyntheticUIEvent = __webpack_require__(79);
+
+	var getEventModifierState = __webpack_require__(81);
+
+	/**
+	 * @interface TouchEvent
+	 * @see http://www.w3.org/TR/touch-events/
+	 */
+	var TouchEventInterface = {
+	  touches: null,
+	  targetTouches: null,
+	  changedTouches: null,
+	  altKey: null,
+	  metaKey: null,
+	  ctrlKey: null,
+	  shiftKey: null,
+	  getModifierState: getEventModifierState
+	};
+
+	/**
+	 * @param {object} dispatchConfig Configuration used to dispatch this event.
+	 * @param {string} dispatchMarker Marker identifying the event target.
+	 * @param {object} nativeEvent Native browser event.
+	 * @extends {SyntheticUIEvent}
+	 */
+	function SyntheticTouchEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
+	  return SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
+	}
+
+	SyntheticUIEvent.augmentClass(SyntheticTouchEvent, TouchEventInterface);
+
+	module.exports = SyntheticTouchEvent;
+
+/***/ },
+/* 169 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var SyntheticEvent = __webpack_require__(57);
+
+	/**
+	 * @interface Event
+	 * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent
+	 */
+	var TransitionEventInterface = {
+	  propertyName: null,
+	  elapsedTime: null,
+	  pseudoElement: null
+	};
+
+	/**
+	 * @param {object} dispatchConfig Configuration used to dispatch this event.
+	 * @param {string} dispatchMarker Marker identifying the event target.
+	 * @param {object} nativeEvent Native browser event.
+	 * @extends {SyntheticEvent}
+	 */
+	function SyntheticTransitionEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
+	  return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
+	}
+
+	SyntheticEvent.augmentClass(SyntheticTransitionEvent, TransitionEventInterface);
+
+	module.exports = SyntheticTransitionEvent;
+
+/***/ },
+/* 170 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var SyntheticMouseEvent = __webpack_require__(78);
+
+	/**
+	 * @interface WheelEvent
+	 * @see http://www.w3.org/TR/DOM-Level-3-Events/
+	 */
+	var WheelEventInterface = {
+	  deltaX: function (event) {
+	    return 'deltaX' in event ? event.deltaX :
+	    // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
+	    'wheelDeltaX' in event ? -event.wheelDeltaX : 0;
+	  },
+	  deltaY: function (event) {
+	    return 'deltaY' in event ? event.deltaY :
+	    // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
+	    'wheelDeltaY' in event ? -event.wheelDeltaY :
+	    // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
+	    'wheelDelta' in event ? -event.wheelDelta : 0;
+	  },
+	  deltaZ: null,
+
+	  // Browsers without "deltaMode" is reporting in raw wheel delta where one
+	  // notch on the scroll is always +/- 120, roughly equivalent to pixels.
+	  // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
+	  // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
+	  deltaMode: null
+	};
+
+	/**
+	 * @param {object} dispatchConfig Configuration used to dispatch this event.
+	 * @param {string} dispatchMarker Marker identifying the event target.
+	 * @param {object} nativeEvent Native browser event.
+	 * @extends {SyntheticMouseEvent}
+	 */
+	function SyntheticWheelEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
+	  return SyntheticMouseEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
+	}
+
+	SyntheticMouseEvent.augmentClass(SyntheticWheelEvent, WheelEventInterface);
+
+	module.exports = SyntheticWheelEvent;
+
+/***/ },
+/* 171 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var DOMLazyTree = __webpack_require__(85);
+	var DOMProperty = __webpack_require__(36);
+	var React = __webpack_require__(2);
+	var ReactBrowserEventEmitter = __webpack_require__(109);
+	var ReactCurrentOwner = __webpack_require__(10);
+	var ReactDOMComponentTree = __webpack_require__(34);
+	var ReactDOMContainerInfo = __webpack_require__(172);
+	var ReactDOMFeatureFlags = __webpack_require__(173);
+	var ReactFeatureFlags = __webpack_require__(62);
+	var ReactInstanceMap = __webpack_require__(120);
+	var ReactInstrumentation = __webpack_require__(66);
+	var ReactMarkupChecksum = __webpack_require__(174);
+	var ReactReconciler = __webpack_require__(63);
+	var ReactUpdateQueue = __webpack_require__(140);
+	var ReactUpdates = __webpack_require__(60);
+
+	var emptyObject = __webpack_require__(127);
+	var instantiateReactComponent = __webpack_require__(122);
+	var invariant = __webpack_require__(37);
+	var setInnerHTML = __webpack_require__(87);
+	var shouldUpdateReactComponent = __webpack_require__(129);
+	var warning = __webpack_require__(47);
+
+	var ATTR_NAME = DOMProperty.ID_ATTRIBUTE_NAME;
+	var ROOT_ATTR_NAME = DOMProperty.ROOT_ATTRIBUTE_NAME;
+
+	var ELEMENT_NODE_TYPE = 1;
+	var DOC_NODE_TYPE = 9;
+	var DOCUMENT_FRAGMENT_NODE_TYPE = 11;
+
+	var instancesByReactRootID = {};
+
+	/**
+	 * Finds the index of the first character
+	 * that's not common between the two given strings.
+	 *
+	 * @return {number} the index of the character where the strings diverge
+	 */
+	function firstDifferenceIndex(string1, string2) {
+	  var minLen = Math.min(string1.length, string2.length);
+	  for (var i = 0; i < minLen; i++) {
+	    if (string1.charAt(i) !== string2.charAt(i)) {
+	      return i;
+	    }
+	  }
+	  return string1.length === string2.length ? -1 : minLen;
+	}
+
+	/**
+	 * @param {DOMElement|DOMDocument} container DOM element that may contain
+	 * a React component
+	 * @return {?*} DOM element that may have the reactRoot ID, or null.
+	 */
+	function getReactRootElementInContainer(container) {
+	  if (!container) {
+	    return null;
+	  }
+
+	  if (container.nodeType === DOC_NODE_TYPE) {
+	    return container.documentElement;
+	  } else {
+	    return container.firstChild;
+	  }
+	}
+
+	function internalGetID(node) {
+	  // If node is something like a window, document, or text node, none of
+	  // which support attributes or a .getAttribute method, gracefully return
+	  // the empty string, as if the attribute were missing.
+	  return node.getAttribute && node.getAttribute(ATTR_NAME) || '';
+	}
+
+	/**
+	 * Mounts this component and inserts it into the DOM.
+	 *
+	 * @param {ReactComponent} componentInstance The instance to mount.
+	 * @param {DOMElement} container DOM element to mount into.
+	 * @param {ReactReconcileTransaction} transaction
+	 * @param {boolean} shouldReuseMarkup If true, do not insert markup
+	 */
+	function mountComponentIntoNode(wrapperInstance, container, transaction, shouldReuseMarkup, context) {
+	  var markerName;
+	  if (ReactFeatureFlags.logTopLevelRenders) {
+	    var wrappedElement = wrapperInstance._currentElement.props.child;
+	    var type = wrappedElement.type;
+	    markerName = 'React mount: ' + (typeof type === 'string' ? type : type.displayName || type.name);
+	    console.time(markerName);
+	  }
+
+	  var markup = ReactReconciler.mountComponent(wrapperInstance, transaction, null, ReactDOMContainerInfo(wrapperInstance, container), context, 0 /* parentDebugID */
+	  );
+
+	  if (markerName) {
+	    console.timeEnd(markerName);
+	  }
+
+	  wrapperInstance._renderedComponent._topLevelWrapper = wrapperInstance;
+	  ReactMount._mountImageIntoNode(markup, container, wrapperInstance, shouldReuseMarkup, transaction);
+	}
+
+	/**
+	 * Batched mount.
+	 *
+	 * @param {ReactComponent} componentInstance The instance to mount.
+	 * @param {DOMElement} container DOM element to mount into.
+	 * @param {boolean} shouldReuseMarkup If true, do not insert markup
+	 */
+	function batchedMountComponentIntoNode(componentInstance, container, shouldReuseMarkup, context) {
+	  var transaction = ReactUpdates.ReactReconcileTransaction.getPooled(
+	  /* useCreateElement */
+	  !shouldReuseMarkup && ReactDOMFeatureFlags.useCreateElement);
+	  transaction.perform(mountComponentIntoNode, null, componentInstance, container, transaction, shouldReuseMarkup, context);
+	  ReactUpdates.ReactReconcileTransaction.release(transaction);
+	}
+
+	/**
+	 * Unmounts a component and removes it from the DOM.
+	 *
+	 * @param {ReactComponent} instance React component instance.
+	 * @param {DOMElement} container DOM element to unmount from.
+	 * @final
+	 * @internal
+	 * @see {ReactMount.unmountComponentAtNode}
+	 */
+	function unmountComponentFromNode(instance, container, safely) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    ReactInstrumentation.debugTool.onBeginFlush();
+	  }
+	  ReactReconciler.unmountComponent(instance, safely);
+	  if (process.env.NODE_ENV !== 'production') {
+	    ReactInstrumentation.debugTool.onEndFlush();
+	  }
+
+	  if (container.nodeType === DOC_NODE_TYPE) {
+	    container = container.documentElement;
+	  }
+
+	  // http://jsperf.com/emptying-a-node
+	  while (container.lastChild) {
+	    container.removeChild(container.lastChild);
+	  }
+	}
+
+	/**
+	 * True if the supplied DOM node has a direct React-rendered child that is
+	 * not a React root element. Useful for warning in `render`,
+	 * `unmountComponentAtNode`, etc.
+	 *
+	 * @param {?DOMElement} node The candidate DOM node.
+	 * @return {boolean} True if the DOM element contains a direct child that was
+	 * rendered by React but is not a root element.
+	 * @internal
+	 */
+	function hasNonRootReactChild(container) {
+	  var rootEl = getReactRootElementInContainer(container);
+	  if (rootEl) {
+	    var inst = ReactDOMComponentTree.getInstanceFromNode(rootEl);
+	    return !!(inst && inst._hostParent);
+	  }
+	}
+
+	/**
+	 * True if the supplied DOM node is a React DOM element and
+	 * it has been rendered by another copy of React.
+	 *
+	 * @param {?DOMElement} node The candidate DOM node.
+	 * @return {boolean} True if the DOM has been rendered by another copy of React
+	 * @internal
+	 */
+	function nodeIsRenderedByOtherInstance(container) {
+	  var rootEl = getReactRootElementInContainer(container);
+	  return !!(rootEl && isReactNode(rootEl) && !ReactDOMComponentTree.getInstanceFromNode(rootEl));
+	}
+
+	/**
+	 * True if the supplied DOM node is a valid node element.
+	 *
+	 * @param {?DOMElement} node The candidate DOM node.
+	 * @return {boolean} True if the DOM is a valid DOM node.
+	 * @internal
+	 */
+	function isValidContainer(node) {
+	  return !!(node && (node.nodeType === ELEMENT_NODE_TYPE || node.nodeType === DOC_NODE_TYPE || node.nodeType === DOCUMENT_FRAGMENT_NODE_TYPE));
+	}
+
+	/**
+	 * True if the supplied DOM node is a valid React node element.
+	 *
+	 * @param {?DOMElement} node The candidate DOM node.
+	 * @return {boolean} True if the DOM is a valid React DOM node.
+	 * @internal
+	 */
+	function isReactNode(node) {
+	  return isValidContainer(node) && (node.hasAttribute(ROOT_ATTR_NAME) || node.hasAttribute(ATTR_NAME));
+	}
+
+	function getHostRootInstanceInContainer(container) {
+	  var rootEl = getReactRootElementInContainer(container);
+	  var prevHostInstance = rootEl && ReactDOMComponentTree.getInstanceFromNode(rootEl);
+	  return prevHostInstance && !prevHostInstance._hostParent ? prevHostInstance : null;
+	}
+
+	function getTopLevelWrapperInContainer(container) {
+	  var root = getHostRootInstanceInContainer(container);
+	  return root ? root._hostContainerInfo._topLevelWrapper : null;
+	}
+
+	/**
+	 * Temporary (?) hack so that we can store all top-level pending updates on
+	 * composites instead of having to worry about different types of components
+	 * here.
+	 */
+	var topLevelRootCounter = 1;
+	var TopLevelWrapper = function () {
+	  this.rootID = topLevelRootCounter++;
+	};
+	TopLevelWrapper.prototype.isReactComponent = {};
+	if (process.env.NODE_ENV !== 'production') {
+	  TopLevelWrapper.displayName = 'TopLevelWrapper';
+	}
+	TopLevelWrapper.prototype.render = function () {
+	  return this.props.child;
+	};
+	TopLevelWrapper.isReactTopLevelWrapper = true;
+
+	/**
+	 * Mounting is the process of initializing a React component by creating its
+	 * representative DOM elements and inserting them into a supplied `container`.
+	 * Any prior content inside `container` is destroyed in the process.
+	 *
+	 *   ReactMount.render(
+	 *     component,
+	 *     document.getElementById('container')
+	 *   );
+	 *
+	 *   <div id="container">                   <-- Supplied `container`.
+	 *     <div data-reactid=".3">              <-- Rendered reactRoot of React
+	 *       // ...                                 component.
+	 *     </div>
+	 *   </div>
+	 *
+	 * Inside of `container`, the first element rendered is the "reactRoot".
+	 */
+	var ReactMount = {
+
+	  TopLevelWrapper: TopLevelWrapper,
+
+	  /**
+	   * Used by devtools. The keys are not important.
+	   */
+	  _instancesByReactRootID: instancesByReactRootID,
+
+	  /**
+	   * 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();
+	  },
+
+	  /**
+	   * Take a component that's already mounted into the DOM and replace its props
+	   * @param {ReactComponent} prevComponent component instance already in the DOM
+	   * @param {ReactElement} nextElement component instance to render
+	   * @param {DOMElement} container container to render into
+	   * @param {?function} callback function triggered on completion
+	   */
+	  _updateRootComponent: function (prevComponent, nextElement, nextContext, container, callback) {
+	    ReactMount.scrollMonitor(container, function () {
+	      ReactUpdateQueue.enqueueElementInternal(prevComponent, nextElement, nextContext);
+	      if (callback) {
+	        ReactUpdateQueue.enqueueCallbackInternal(prevComponent, callback);
+	      }
+	    });
+
+	    return prevComponent;
+	  },
+
+	  /**
+	   * Render a new component into the DOM. Hooked by hooks!
+	   *
+	   * @param {ReactElement} nextElement element to render
+	   * @param {DOMElement} container container to render into
+	   * @param {boolean} shouldReuseMarkup if we should skip the markup insertion
+	   * @return {ReactComponent} nextComponent
+	   */
+	  _renderNewRootComponent: function (nextElement, container, shouldReuseMarkup, context) {
+	    // Various parts of our code (such as ReactCompositeComponent's
+	    // _renderValidatedComponent) assume that calls to render aren't nested;
+	    // verify that that's the case.
+	    process.env.NODE_ENV !== 'production' ? warning(ReactCurrentOwner.current == null, '_renderNewRootComponent(): Render methods should be a pure function ' + 'of props and state; triggering nested component updates from ' + 'render is not allowed. If necessary, trigger nested updates in ' + 'componentDidUpdate. Check the render method of %s.', ReactCurrentOwner.current && ReactCurrentOwner.current.getName() || 'ReactCompositeComponent') : void 0;
+
+	    !isValidContainer(container) ? process.env.NODE_ENV !== 'production' ? invariant(false, '_registerComponent(...): Target container is not a DOM element.') : _prodInvariant('37') : void 0;
+
+	    ReactBrowserEventEmitter.ensureScrollValueMonitoring();
+	    var componentInstance = instantiateReactComponent(nextElement, false);
+
+	    // The initial render is synchronous but any updates that happen during
+	    // rendering, in componentWillMount or componentDidMount, will be batched
+	    // according to the current batching strategy.
+
+	    ReactUpdates.batchedUpdates(batchedMountComponentIntoNode, componentInstance, container, shouldReuseMarkup, context);
+
+	    var wrapperID = componentInstance._instance.rootID;
+	    instancesByReactRootID[wrapperID] = componentInstance;
+
+	    return componentInstance;
+	  },
+
+	  /**
+	   * 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} parentComponent The conceptual parent of this render tree.
+	   * @param {ReactElement} nextElement Component element to render.
+	   * @param {DOMElement} container DOM element to render into.
+	   * @param {?function} callback function triggered on completion
+	   * @return {ReactComponent} Component instance rendered in `container`.
+	   */
+	  renderSubtreeIntoContainer: function (parentComponent, nextElement, container, callback) {
+	    !(parentComponent != null && ReactInstanceMap.has(parentComponent)) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'parentComponent must be a valid React Component') : _prodInvariant('38') : void 0;
+	    return ReactMount._renderSubtreeIntoContainer(parentComponent, nextElement, container, callback);
+	  },
+
+	  _renderSubtreeIntoContainer: function (parentComponent, nextElement, container, callback) {
+	    ReactUpdateQueue.validateCallback(callback, 'ReactDOM.render');
+	    !React.isValidElement(nextElement) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactDOM.render(): Invalid component element.%s', typeof nextElement === 'string' ? ' Instead of passing a string like \'div\', pass ' + 'React.createElement(\'div\') or <div />.' : typeof nextElement === 'function' ? ' Instead of passing a class like Foo, pass ' + 'React.createElement(Foo) or <Foo />.' :
+	    // Check if it quacks like an element
+	    nextElement != null && nextElement.props !== undefined ? ' This may be caused by unintentionally loading two independent ' + 'copies of React.' : '') : _prodInvariant('39', typeof nextElement === 'string' ? ' Instead of passing a string like \'div\', pass ' + 'React.createElement(\'div\') or <div />.' : typeof nextElement === 'function' ? ' Instead of passing a class like Foo, pass ' + 'React.createElement(Foo) or <Foo />.' : nextElement != null && nextElement.props !== undefined ? ' This may be caused by unintentionally loading two independent ' + 'copies of React.' : '') : void 0;
+
+	    process.env.NODE_ENV !== 'production' ? warning(!container || !container.tagName || container.tagName.toUpperCase() !== 'BODY', 'render(): Rendering components directly into document.body is ' + 'discouraged, since its children are often manipulated by third-party ' + 'scripts and browser extensions. This may lead to subtle ' + 'reconciliation issues. Try rendering into a container element created ' + 'for your app.') : void 0;
+
+	    var nextWrappedElement = React.createElement(TopLevelWrapper, { child: nextElement });
+
+	    var nextContext;
+	    if (parentComponent) {
+	      var parentInst = ReactInstanceMap.get(parentComponent);
+	      nextContext = parentInst._processChildContext(parentInst._context);
+	    } else {
+	      nextContext = emptyObject;
+	    }
+
+	    var prevComponent = getTopLevelWrapperInContainer(container);
+
+	    if (prevComponent) {
+	      var prevWrappedElement = prevComponent._currentElement;
+	      var prevElement = prevWrappedElement.props.child;
+	      if (shouldUpdateReactComponent(prevElement, nextElement)) {
+	        var publicInst = prevComponent._renderedComponent.getPublicInstance();
+	        var updatedCallback = callback && function () {
+	          callback.call(publicInst);
+	        };
+	        ReactMount._updateRootComponent(prevComponent, nextWrappedElement, nextContext, container, updatedCallback);
+	        return publicInst;
+	      } else {
+	        ReactMount.unmountComponentAtNode(container);
+	      }
+	    }
+
+	    var reactRootElement = getReactRootElementInContainer(container);
+	    var containerHasReactMarkup = reactRootElement && !!internalGetID(reactRootElement);
+	    var containerHasNonRootReactChild = hasNonRootReactChild(container);
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      process.env.NODE_ENV !== 'production' ? warning(!containerHasNonRootReactChild, 'render(...): Replacing React-rendered children with a new root ' + 'component. If you intended to update the children of this node, ' + 'you should instead have the existing children update their state ' + 'and render the new components instead of calling ReactDOM.render.') : void 0;
+
+	      if (!containerHasReactMarkup || reactRootElement.nextSibling) {
+	        var rootElementSibling = reactRootElement;
+	        while (rootElementSibling) {
+	          if (internalGetID(rootElementSibling)) {
+	            process.env.NODE_ENV !== 'production' ? warning(false, 'render(): Target node has markup rendered by React, but there ' + 'are unrelated nodes as well. This is most commonly caused by ' + 'white-space inserted around server-rendered markup.') : void 0;
+	            break;
+	          }
+	          rootElementSibling = rootElementSibling.nextSibling;
+	        }
+	      }
+	    }
+
+	    var shouldReuseMarkup = containerHasReactMarkup && !prevComponent && !containerHasNonRootReactChild;
+	    var component = ReactMount._renderNewRootComponent(nextWrappedElement, container, shouldReuseMarkup, nextContext)._renderedComponent.getPublicInstance();
+	    if (callback) {
+	      callback.call(component);
+	    }
+	    return component;
+	  },
+
+	  /**
+	   * Renders a React component into the DOM in the supplied `container`.
+	   * See https://facebook.github.io/react/docs/top-level-api.html#reactdom.render
+	   *
+	   * 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 {ReactElement} nextElement Component element to render.
+	   * @param {DOMElement} container DOM element to render into.
+	   * @param {?function} callback function triggered on completion
+	   * @return {ReactComponent} Component instance rendered in `container`.
+	   */
+	  render: function (nextElement, container, callback) {
+	    return ReactMount._renderSubtreeIntoContainer(null, nextElement, container, callback);
+	  },
+
+	  /**
+	   * Unmounts and destroys the React component rendered in the `container`.
+	   * See https://facebook.github.io/react/docs/top-level-api.html#reactdom.unmountcomponentatnode
+	   *
+	   * @param {DOMElement} container DOM element containing a React component.
+	   * @return {boolean} True if a component was found in and unmounted from
+	   *                   `container`
+	   */
+	  unmountComponentAtNode: function (container) {
+	    // Various parts of our code (such as ReactCompositeComponent's
+	    // _renderValidatedComponent) assume that calls to render aren't nested;
+	    // verify that that's the case. (Strictly speaking, unmounting won't cause a
+	    // render but we still don't expect to be in a render call here.)
+	    process.env.NODE_ENV !== 'production' ? warning(ReactCurrentOwner.current == null, 'unmountComponentAtNode(): Render methods should be a pure function ' + 'of props and state; triggering nested component updates from render ' + 'is not allowed. If necessary, trigger nested updates in ' + 'componentDidUpdate. Check the render method of %s.', ReactCurrentOwner.current && ReactCurrentOwner.current.getName() || 'ReactCompositeComponent') : void 0;
+
+	    !isValidContainer(container) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'unmountComponentAtNode(...): Target container is not a DOM element.') : _prodInvariant('40') : void 0;
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      process.env.NODE_ENV !== 'production' ? warning(!nodeIsRenderedByOtherInstance(container), 'unmountComponentAtNode(): The node you\'re attempting to unmount ' + 'was rendered by another copy of React.') : void 0;
+	    }
+
+	    var prevComponent = getTopLevelWrapperInContainer(container);
+	    if (!prevComponent) {
+	      // Check if the node being unmounted was rendered by React, but isn't a
+	      // root node.
+	      var containerHasNonRootReactChild = hasNonRootReactChild(container);
+
+	      // Check if the container itself is a React root node.
+	      var isContainerReactRoot = container.nodeType === 1 && container.hasAttribute(ROOT_ATTR_NAME);
+
+	      if (process.env.NODE_ENV !== 'production') {
+	        process.env.NODE_ENV !== 'production' ? warning(!containerHasNonRootReactChild, 'unmountComponentAtNode(): The node you\'re attempting to unmount ' + 'was rendered by React and is not a top-level container. %s', isContainerReactRoot ? 'You may have accidentally passed in a React root node instead ' + 'of its container.' : 'Instead, have the parent component update its state and ' + 'rerender in order to remove this component.') : void 0;
+	      }
+
+	      return false;
+	    }
+	    delete instancesByReactRootID[prevComponent._instance.rootID];
+	    ReactUpdates.batchedUpdates(unmountComponentFromNode, prevComponent, container, false);
+	    return true;
+	  },
+
+	  _mountImageIntoNode: function (markup, container, instance, shouldReuseMarkup, transaction) {
+	    !isValidContainer(container) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'mountComponentIntoNode(...): Target container is not valid.') : _prodInvariant('41') : void 0;
+
+	    if (shouldReuseMarkup) {
+	      var rootElement = getReactRootElementInContainer(container);
+	      if (ReactMarkupChecksum.canReuseMarkup(markup, rootElement)) {
+	        ReactDOMComponentTree.precacheNode(instance, rootElement);
+	        return;
+	      } else {
+	        var checksum = rootElement.getAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);
+	        rootElement.removeAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);
+
+	        var rootMarkup = rootElement.outerHTML;
+	        rootElement.setAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME, checksum);
+
+	        var normalizedMarkup = markup;
+	        if (process.env.NODE_ENV !== 'production') {
+	          // because rootMarkup is retrieved from the DOM, various normalizations
+	          // will have occurred which will not be present in `markup`. Here,
+	          // insert markup into a <div> or <iframe> depending on the container
+	          // type to perform the same normalizations before comparing.
+	          var normalizer;
+	          if (container.nodeType === ELEMENT_NODE_TYPE) {
+	            normalizer = document.createElement('div');
+	            normalizer.innerHTML = markup;
+	            normalizedMarkup = normalizer.innerHTML;
+	          } else {
+	            normalizer = document.createElement('iframe');
+	            document.body.appendChild(normalizer);
+	            normalizer.contentDocument.write(markup);
+	            normalizedMarkup = normalizer.contentDocument.documentElement.outerHTML;
+	            document.body.removeChild(normalizer);
+	          }
+	        }
+
+	        var diffIndex = firstDifferenceIndex(normalizedMarkup, rootMarkup);
+	        var difference = ' (client) ' + normalizedMarkup.substring(diffIndex - 20, diffIndex + 20) + '\n (server) ' + rootMarkup.substring(diffIndex - 20, diffIndex + 20);
+
+	        !(container.nodeType !== DOC_NODE_TYPE) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'You\'re trying to render a component to the document using server rendering but the checksum was invalid. This usually means you rendered a different component type or props on the client from the one on the server, or your render() methods are impure. React cannot handle this case due to cross-browser quirks by rendering at the document root. You should look for environment dependent code in your components and ensure the props are the same client and server side:\n%s', difference) : _prodInvariant('42', difference) : void 0;
+
+	        if (process.env.NODE_ENV !== 'production') {
+	          process.env.NODE_ENV !== 'production' ? warning(false, 'React attempted to reuse markup in a container but the ' + 'checksum was invalid. This generally means that you are ' + 'using server rendering and the markup generated on the ' + 'server was not what the client was expecting. React injected ' + 'new markup to compensate which works but you have lost many ' + 'of the benefits of server rendering. Instead, figure out ' + 'why the markup being generated is different on the client ' + 'or server:\n%s', difference) : void 0;
+	        }
+	      }
+	    }
+
+	    !(container.nodeType !== DOC_NODE_TYPE) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'You\'re trying to render a component to the document but you didn\'t use server rendering. We can\'t do this without using server rendering due to cross-browser quirks. See ReactDOMServer.renderToString() for server rendering.') : _prodInvariant('43') : void 0;
+
+	    if (transaction.useCreateElement) {
+	      while (container.lastChild) {
+	        container.removeChild(container.lastChild);
+	      }
+	      DOMLazyTree.insertTreeBefore(container, markup, null);
+	    } else {
+	      setInnerHTML(container, markup);
+	      ReactDOMComponentTree.precacheNode(instance, container.firstChild);
+	    }
+
+	    if (process.env.NODE_ENV !== 'production') {
+	      var hostNode = ReactDOMComponentTree.getInstanceFromNode(container.firstChild);
+	      if (hostNode._debugID !== 0) {
+	        ReactInstrumentation.debugTool.onHostOperation({
+	          instanceID: hostNode._debugID,
+	          type: 'mount',
+	          payload: markup.toString()
+	        });
+	      }
+	    }
+	  }
+	};
+
+	module.exports = ReactMount;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 172 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var validateDOMNesting = __webpack_require__(141);
+
+	var DOC_NODE_TYPE = 9;
+
+	function ReactDOMContainerInfo(topLevelWrapper, node) {
+	  var info = {
+	    _topLevelWrapper: topLevelWrapper,
+	    _idCounter: 1,
+	    _ownerDocument: node ? node.nodeType === DOC_NODE_TYPE ? node : node.ownerDocument : null,
+	    _node: node,
+	    _tag: node ? node.nodeName.toLowerCase() : null,
+	    _namespaceURI: node ? node.namespaceURI : null
+	  };
+	  if (process.env.NODE_ENV !== 'production') {
+	    info._ancestorInfo = node ? validateDOMNesting.updatedAncestorInfo(null, info._tag, null) : null;
+	  }
+	  return info;
+	}
+
+	module.exports = ReactDOMContainerInfo;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 173 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ReactDOMFeatureFlags = {
+	  useCreateElement: true,
+	  useFiber: false
+	};
+
+	module.exports = ReactDOMFeatureFlags;
+
+/***/ },
+/* 174 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var adler32 = __webpack_require__(175);
+
+	var TAG_END = /\/?>/;
+	var COMMENT_START = /^<\!\-\-/;
+
+	var ReactMarkupChecksum = {
+	  CHECKSUM_ATTR_NAME: 'data-react-checksum',
+
+	  /**
+	   * @param {string} markup Markup string
+	   * @return {string} Markup string with checksum attribute attached
+	   */
+	  addChecksumToMarkup: function (markup) {
+	    var checksum = adler32(markup);
+
+	    // Add checksum (handle both parent tags, comments and self-closing tags)
+	    if (COMMENT_START.test(markup)) {
+	      return markup;
+	    } else {
+	      return markup.replace(TAG_END, ' ' + ReactMarkupChecksum.CHECKSUM_ATTR_NAME + '="' + checksum + '"$&');
+	    }
+	  },
+
+	  /**
+	   * @param {string} markup to use
+	   * @param {DOMElement} element root React element
+	   * @returns {boolean} whether or not the markup is the same
+	   */
+	  canReuseMarkup: function (markup, element) {
+	    var existingChecksum = element.getAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);
+	    existingChecksum = existingChecksum && parseInt(existingChecksum, 10);
+	    var markupChecksum = adler32(markup);
+	    return markupChecksum === existingChecksum;
+	  }
+	};
+
+	module.exports = ReactMarkupChecksum;
+
+/***/ },
+/* 175 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 * 
+	 */
+
+	'use strict';
+
+	var MOD = 65521;
+
+	// adler32 is not cryptographically strong, and is only used to sanity check that
+	// markup generated on the server matches the markup generated on the client.
+	// This implementation (a modified version of the SheetJS version) has been optimized
+	// for our use case, at the expense of conforming to the adler32 specification
+	// for non-ascii inputs.
+	function adler32(data) {
+	  var a = 1;
+	  var b = 0;
+	  var i = 0;
+	  var l = data.length;
+	  var m = l & ~0x3;
+	  while (i < m) {
+	    var n = Math.min(i + 4096, m);
+	    for (; i < n; i += 4) {
+	      b += (a += data.charCodeAt(i)) + (a += data.charCodeAt(i + 1)) + (a += data.charCodeAt(i + 2)) + (a += data.charCodeAt(i + 3));
+	    }
+	    a %= MOD;
+	    b %= MOD;
+	  }
+	  for (; i < l; i++) {
+	    b += a += data.charCodeAt(i);
+	  }
+	  a %= MOD;
+	  b %= MOD;
+	  return a | b << 16;
+	}
+
+	module.exports = adler32;
+
+/***/ },
+/* 176 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	module.exports = '15.4.1';
+
+/***/ },
+/* 177 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var _prodInvariant = __webpack_require__(35);
+
+	var ReactCurrentOwner = __webpack_require__(10);
+	var ReactDOMComponentTree = __webpack_require__(34);
+	var ReactInstanceMap = __webpack_require__(120);
+
+	var getHostComponentFromComposite = __webpack_require__(178);
+	var invariant = __webpack_require__(37);
+	var warning = __webpack_require__(47);
+
+	/**
+	 * Returns the DOM node rendered by this element.
+	 *
+	 * See https://facebook.github.io/react/docs/top-level-api.html#reactdom.finddomnode
+	 *
+	 * @param {ReactComponent|DOMElement} componentOrElement
+	 * @return {?DOMElement} The root node of this element.
+	 */
+	function findDOMNode(componentOrElement) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    var owner = ReactCurrentOwner.current;
+	    if (owner !== null) {
+	      process.env.NODE_ENV !== 'production' ? warning(owner._warnedAboutRefsInRender, '%s is accessing findDOMNode inside its render(). ' + 'render() should be a pure function of props and state. It should ' + 'never access something that requires stale data from the previous ' + 'render, such as refs. Move this logic to componentDidMount and ' + 'componentDidUpdate instead.', owner.getName() || 'A component') : void 0;
+	      owner._warnedAboutRefsInRender = true;
+	    }
+	  }
+	  if (componentOrElement == null) {
+	    return null;
+	  }
+	  if (componentOrElement.nodeType === 1) {
+	    return componentOrElement;
+	  }
+
+	  var inst = ReactInstanceMap.get(componentOrElement);
+	  if (inst) {
+	    inst = getHostComponentFromComposite(inst);
+	    return inst ? ReactDOMComponentTree.getNodeFromInstance(inst) : null;
+	  }
+
+	  if (typeof componentOrElement.render === 'function') {
+	     true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'findDOMNode was called on an unmounted component.') : _prodInvariant('44') : void 0;
+	  } else {
+	     true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Element appears to be neither ReactComponent nor DOMNode (keys: %s)', Object.keys(componentOrElement)) : _prodInvariant('45', Object.keys(componentOrElement)) : void 0;
+	  }
+	}
+
+	module.exports = findDOMNode;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 178 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ReactNodeTypes = __webpack_require__(124);
+
+	function getHostComponentFromComposite(inst) {
+	  var type;
+
+	  while ((type = inst._renderedNodeType) === ReactNodeTypes.COMPOSITE) {
+	    inst = inst._renderedComponent;
+	  }
+
+	  if (type === ReactNodeTypes.HOST) {
+	    return inst._renderedComponent;
+	  } else if (type === ReactNodeTypes.EMPTY) {
+	    return null;
+	  }
+	}
+
+	module.exports = getHostComponentFromComposite;
+
+/***/ },
+/* 179 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ReactMount = __webpack_require__(171);
+
+	module.exports = ReactMount.renderSubtreeIntoContainer;
+
+/***/ },
+/* 180 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var DOMProperty = __webpack_require__(36);
+	var EventPluginRegistry = __webpack_require__(44);
+	var ReactComponentTreeHook = __webpack_require__(26);
+
+	var warning = __webpack_require__(47);
+
+	if (process.env.NODE_ENV !== 'production') {
+	  var reactProps = {
+	    children: true,
+	    dangerouslySetInnerHTML: true,
+	    key: true,
+	    ref: true,
+
+	    autoFocus: true,
+	    defaultValue: true,
+	    valueLink: true,
+	    defaultChecked: true,
+	    checkedLink: true,
+	    innerHTML: true,
+	    suppressContentEditableWarning: true,
+	    onFocusIn: true,
+	    onFocusOut: true
+	  };
+	  var warnedProperties = {};
+
+	  var validateProperty = function (tagName, name, debugID) {
+	    if (DOMProperty.properties.hasOwnProperty(name) || DOMProperty.isCustomAttribute(name)) {
+	      return true;
+	    }
+	    if (reactProps.hasOwnProperty(name) && reactProps[name] || warnedProperties.hasOwnProperty(name) && warnedProperties[name]) {
+	      return true;
+	    }
+	    if (EventPluginRegistry.registrationNameModules.hasOwnProperty(name)) {
+	      return true;
+	    }
+	    warnedProperties[name] = true;
+	    var lowerCasedName = name.toLowerCase();
+
+	    // data-* attributes should be lowercase; suggest the lowercase version
+	    var standardName = DOMProperty.isCustomAttribute(lowerCasedName) ? lowerCasedName : DOMProperty.getPossibleStandardName.hasOwnProperty(lowerCasedName) ? DOMProperty.getPossibleStandardName[lowerCasedName] : null;
+
+	    var registrationName = EventPluginRegistry.possibleRegistrationNames.hasOwnProperty(lowerCasedName) ? EventPluginRegistry.possibleRegistrationNames[lowerCasedName] : null;
+
+	    if (standardName != null) {
+	      process.env.NODE_ENV !== 'production' ? warning(false, 'Unknown DOM property %s. Did you mean %s?%s', name, standardName, ReactComponentTreeHook.getStackAddendumByID(debugID)) : void 0;
+	      return true;
+	    } else if (registrationName != null) {
+	      process.env.NODE_ENV !== 'production' ? warning(false, 'Unknown event handler property %s. Did you mean `%s`?%s', name, registrationName, ReactComponentTreeHook.getStackAddendumByID(debugID)) : void 0;
+	      return true;
+	    } else {
+	      // We were unable to guess which prop the user intended.
+	      // It is likely that the user was just blindly spreading/forwarding props
+	      // Components should be careful to only render valid props/attributes.
+	      // Warning will be invoked in warnUnknownProperties to allow grouping.
+	      return false;
+	    }
+	  };
+	}
+
+	var warnUnknownProperties = function (debugID, element) {
+	  var unknownProps = [];
+	  for (var key in element.props) {
+	    var isValid = validateProperty(element.type, key, debugID);
+	    if (!isValid) {
+	      unknownProps.push(key);
+	    }
+	  }
+
+	  var unknownPropString = unknownProps.map(function (prop) {
+	    return '`' + prop + '`';
+	  }).join(', ');
+
+	  if (unknownProps.length === 1) {
+	    process.env.NODE_ENV !== 'production' ? warning(false, 'Unknown prop %s on <%s> tag. Remove this prop from the element. ' + 'For details, see https://fb.me/react-unknown-prop%s', unknownPropString, element.type, ReactComponentTreeHook.getStackAddendumByID(debugID)) : void 0;
+	  } else if (unknownProps.length > 1) {
+	    process.env.NODE_ENV !== 'production' ? warning(false, 'Unknown props %s on <%s> tag. Remove these props from the element. ' + 'For details, see https://fb.me/react-unknown-prop%s', unknownPropString, element.type, ReactComponentTreeHook.getStackAddendumByID(debugID)) : void 0;
+	  }
+	};
+
+	function handleElement(debugID, element) {
+	  if (element == null || typeof element.type !== 'string') {
+	    return;
+	  }
+	  if (element.type.indexOf('-') >= 0 || element.props.is) {
+	    return;
+	  }
+	  warnUnknownProperties(debugID, element);
+	}
+
+	var ReactDOMUnknownPropertyHook = {
+	  onBeforeMountComponent: function (debugID, element) {
+	    handleElement(debugID, element);
+	  },
+	  onBeforeUpdateComponent: function (debugID, element) {
+	    handleElement(debugID, element);
+	  }
+	};
+
+	module.exports = ReactDOMUnknownPropertyHook;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 181 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var ReactComponentTreeHook = __webpack_require__(26);
+
+	var warning = __webpack_require__(47);
+
+	var didWarnValueNull = false;
+
+	function handleElement(debugID, element) {
+	  if (element == null) {
+	    return;
+	  }
+	  if (element.type !== 'input' && element.type !== 'textarea' && element.type !== 'select') {
+	    return;
+	  }
+	  if (element.props != null && element.props.value === null && !didWarnValueNull) {
+	    process.env.NODE_ENV !== 'production' ? warning(false, '`value` prop on `%s` should not be null. ' + 'Consider using the empty string to clear the component or `undefined` ' + 'for uncontrolled components.%s', element.type, ReactComponentTreeHook.getStackAddendumByID(debugID)) : void 0;
+
+	    didWarnValueNull = true;
+	  }
+	}
+
+	var ReactDOMNullInputValuePropHook = {
+	  onBeforeMountComponent: function (debugID, element) {
+	    handleElement(debugID, element);
+	  },
+	  onBeforeUpdateComponent: function (debugID, element) {
+	    handleElement(debugID, element);
+	  }
+	};
+
+	module.exports = ReactDOMNullInputValuePropHook;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 182 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(process) {/**
+	 * Copyright 2013-present, Facebook, Inc.
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the BSD-style license found in the
+	 * LICENSE file in the root directory of this source tree. An additional grant
+	 * of patent rights can be found in the PATENTS file in the same directory.
+	 *
+	 */
+
+	'use strict';
+
+	var DOMProperty = __webpack_require__(36);
+	var ReactComponentTreeHook = __webpack_require__(26);
+
+	var warning = __webpack_require__(47);
+
+	var warnedProperties = {};
+	var rARIA = new RegExp('^(aria)-[' + DOMProperty.ATTRIBUTE_NAME_CHAR + ']*$');
+
+	function validateProperty(tagName, name, debugID) {
+	  if (warnedProperties.hasOwnProperty(name) && warnedProperties[name]) {
+	    return true;
+	  }
+
+	  if (rARIA.test(name)) {
+	    var lowerCasedName = name.toLowerCase();
+	    var standardName = DOMProperty.getPossibleStandardName.hasOwnProperty(lowerCasedName) ? DOMProperty.getPossibleStandardName[lowerCasedName] : null;
+
+	    // If this is an aria-* attribute, but is not listed in the known DOM
+	    // DOM properties, then it is an invalid aria-* attribute.
+	    if (standardName == null) {
+	      warnedProperties[name] = true;
+	      return false;
+	    }
+	    // aria-* attributes should be lowercase; suggest the lowercase version.
+	    if (name !== standardName) {
+	      process.env.NODE_ENV !== 'production' ? warning(false, 'Unknown ARIA attribute %s. Did you mean %s?%s', name, standardName, ReactComponentTreeHook.getStackAddendumByID(debugID)) : void 0;
+	      warnedProperties[name] = true;
+	      return true;
+	    }
+	  }
+
+	  return true;
+	}
+
+	function warnInvalidARIAProps(debugID, element) {
+	  var invalidProps = [];
+
+	  for (var key in element.props) {
+	    var isValid = validateProperty(element.type, key, debugID);
+	    if (!isValid) {
+	      invalidProps.push(key);
+	    }
+	  }
+
+	  var unknownPropString = invalidProps.map(function (prop) {
+	    return '`' + prop + '`';
+	  }).join(', ');
+
+	  if (invalidProps.length === 1) {
+	    process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid aria prop %s on <%s> tag. ' + 'For details, see https://fb.me/invalid-aria-prop%s', unknownPropString, element.type, ReactComponentTreeHook.getStackAddendumByID(debugID)) : void 0;
+	  } else if (invalidProps.length > 1) {
+	    process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid aria props %s on <%s> tag. ' + 'For details, see https://fb.me/invalid-aria-prop%s', unknownPropString, element.type, ReactComponentTreeHook.getStackAddendumByID(debugID)) : void 0;
+	  }
+	}
+
+	function handleElement(debugID, element) {
+	  if (element == null || typeof element.type !== 'string') {
+	    return;
+	  }
+	  if (element.type.indexOf('-') >= 0 || element.props.is) {
+	    return;
+	  }
+
+	  warnInvalidARIAProps(debugID, element);
+	}
+
+	var ReactDOMInvalidARIAHook = {
+	  onBeforeMountComponent: function (debugID, element) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      handleElement(debugID, element);
+	    }
+	  },
+	  onBeforeUpdateComponent: function (debugID, element) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      handleElement(debugID, element);
+	    }
+	  }
+	};
+
+	module.exports = ReactDOMInvalidARIAHook;
+	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
+
+/***/ },
+/* 183 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the license found in the
+	 *  LICENSE-examples file in the root directory of this source tree.
+	 */
+
+	// The primary React component to use.
+	module.exports = __webpack_require__(184).GraphiQL;
+
+/***/ },
+/* 184 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.GraphiQL = undefined;
+
+	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _react = __webpack_require__(1);
+
+	var _react2 = _interopRequireDefault(_react);
+
+	var _reactDom = __webpack_require__(32);
+
+	var _reactDom2 = _interopRequireDefault(_reactDom);
+
+	var _graphql = __webpack_require__(185);
+
+	var _ExecuteButton = __webpack_require__(262);
+
+	var _ToolbarButton = __webpack_require__(263);
+
+	var _QueryEditor = __webpack_require__(264);
+
+	var _VariableEditor = __webpack_require__(290);
+
+	var _ResultViewer = __webpack_require__(295);
+
+	var _DocExplorer = __webpack_require__(299);
+
+	var _CodeMirrorSizer = __webpack_require__(301);
+
+	var _CodeMirrorSizer2 = _interopRequireDefault(_CodeMirrorSizer);
+
+	var _getQueryFacts = __webpack_require__(302);
+
+	var _getQueryFacts2 = _interopRequireDefault(_getQueryFacts);
+
+	var _getSelectedOperationName = __webpack_require__(303);
+
+	var _getSelectedOperationName2 = _interopRequireDefault(_getSelectedOperationName);
+
+	var _debounce = __webpack_require__(300);
+
+	var _debounce2 = _interopRequireDefault(_debounce);
+
+	var _find = __webpack_require__(304);
+
+	var _find2 = _interopRequireDefault(_find);
+
+	var _fillLeafs2 = __webpack_require__(305);
+
+	var _elementPosition = __webpack_require__(306);
+
+	var _introspectionQueries = __webpack_require__(307);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /**
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  Copyright (c) 2015, Facebook, Inc.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  All rights reserved.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  This source code is licensed under the license found in the
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  LICENSE-examples file in the root directory of this source tree.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
+
+	/**
+	 * GraphiQL
+	 *
+	 * This React component is responsible for rendering the GraphiQL editor.
+	 *
+	 * Props:
+	 *
+	 *   - fetcher: a function which accepts GraphQL-HTTP parameters and returns
+	 *     a Promise or Observable which resolves to the GraphQL parsed
+	 *     JSON response.
+	 *
+	 *   - schema: a GraphQLSchema instance or `null` if one is not to be used.
+	 *     If `undefined` is provided, GraphiQL will send an introspection query
+	 *     using the fetcher to produce a schema.
+	 *
+	 *   - query: an optional GraphQL string to use as the initial displayed query,
+	 *     if `undefined` is provided, the stored query or defaultQuery will
+	 *     be used.
+	 *
+	 *   - variables: an optional GraphQL string to use as the initial displayed
+	 *     query variables, if `undefined` is provided, the stored variables will
+	 *     be used.
+	 *
+	 *   - operationName: an optional name of which GraphQL operation should be
+	 *     executed.
+	 *
+	 *   - response: an optional JSON string to use as the initial displayed
+	 *     response. If not provided, no response will be initialy shown. You might
+	 *     provide this if illustrating the result of the initial query.
+	 *
+	 *   - storage: an instance of [Storage][] GraphiQL will use to persist state.
+	 *     Only `getItem` and `setItem` are called. Default: window.localStorage
+	 *
+	 *   - defaultQuery: an optional GraphQL string to use when no query is provided
+	 *     and no stored query exists from a previous session. If `undefined` is
+	 *     provided, GraphiQL will use its own default query.
+	 *
+	 *   - onEditQuery: an optional function which will be called when the Query
+	 *     editor changes. The argument to the function will be the query string.
+	 *
+	 *   - onEditVariables: an optional function which will be called when the Query
+	 *     varible editor changes. The argument to the function will be the
+	 *     variables string.
+	 *
+	 *   - onEditOperationName: an optional function which will be called when the
+	 *     operation name to be executed changes.
+	 *
+	 *   - onToggleDocs: an optional function which will be called when the
+	 *     docs will be toggled. The argument to the function will be a boolean
+	 *     whether the docs are now open or closed.
+	 *
+	 *   - getDefaultFieldNames: an optional function used to provide default fields
+	 *     to non-leaf fields which invalidly lack a selection set.
+	 *     Accepts a GraphQLType instance and returns an array of field names.
+	 *     If not provided, a default behavior will be used.
+	 *
+	 * Children:
+	 *
+	 *   - <GraphiQL.Logo> Replace the GraphiQL logo with your own.
+	 *
+	 *   - <GraphiQL.Toolbar> Add a custom toolbar above GraphiQL.
+	 *
+	 *   - <GraphiQL.ToolbarButton> Add a button to the toolbar above GraphiQL.
+	 *
+	 *   - <GraphiQL.Footer> Add a custom footer below GraphiQL Results.
+	 *
+	 *
+	 * [Storage]: https://developer.mozilla.org/en-US/docs/Web/API/Storage
+	 */
+	var GraphiQL = exports.GraphiQL = function (_React$Component) {
+	  _inherits(GraphiQL, _React$Component);
+
+	  function GraphiQL(props) {
+	    _classCallCheck(this, GraphiQL);
+
+	    // Ensure props are correct
+	    var _this = _possibleConstructorReturn(this, (GraphiQL.__proto__ || Object.getPrototypeOf(GraphiQL)).call(this, props));
+
+	    _initialiseProps.call(_this);
+
+	    if (typeof props.fetcher !== 'function') {
+	      throw new TypeError('GraphiQL requires a fetcher function.');
+	    }
+
+	    // Cache the storage instance
+	    _this._storage = props.storage || window.localStorage;
+
+	    // Determine the initial query to display.
+	    var query = props.query !== undefined ? props.query : _this._storageGet('query') !== null ? _this._storageGet('query') : props.defaultQuery !== undefined ? props.defaultQuery : defaultQuery;
+
+	    // Get the initial query facts.
+	    var queryFacts = (0, _getQueryFacts2.default)(props.schema, query);
+
+	    // Determine the initial variables to display.
+	    var variables = props.variables !== undefined ? props.variables : _this._storageGet('variables');
+
+	    // Determine the initial operationName to use.
+	    var operationName = props.operationName !== undefined ? props.operationName : (0, _getSelectedOperationName2.default)(null, _this._storageGet('operationName'), queryFacts && queryFacts.operations);
+
+	    // Initialize state
+	    _this.state = _extends({
+	      schema: props.schema,
+	      query: query,
+	      variables: variables,
+	      operationName: operationName,
+	      response: props.response,
+	      editorFlex: Number(_this._storageGet('editorFlex')) || 1,
+	      variableEditorOpen: Boolean(variables),
+	      variableEditorHeight: Number(_this._storageGet('variableEditorHeight')) || 200,
+	      docExplorerOpen: _this._storageGet('docExplorerOpen') === 'true' || false,
+	      docExplorerWidth: Number(_this._storageGet('docExplorerWidth')) || 350,
+	      isWaitingForResponse: false,
+	      subscription: null
+	    }, queryFacts);
+
+	    // Ensure only the last executed editor query is rendered.
+	    _this._editorQueryID = 0;
+
+	    // Subscribe to the browser window closing, treating it as an unmount.
+	    if ((typeof window === 'undefined' ? 'undefined' : _typeof(window)) === 'object') {
+	      window.addEventListener('beforeunload', function () {
+	        return _this.componentWillUnmount();
+	      });
+	    }
+	    return _this;
+	  }
+
+	  _createClass(GraphiQL, [{
+	    key: 'componentDidMount',
+	    value: function componentDidMount() {
+	      // Ensure a form of a schema exists (including `null`) and
+	      // if not, fetch one using an introspection query.
+	      this._ensureOfSchema();
+
+	      // Utility for keeping CodeMirror correctly sized.
+	      this.codeMirrorSizer = new _CodeMirrorSizer2.default();
+	    }
+	  }, {
+	    key: 'componentWillReceiveProps',
+	    value: function componentWillReceiveProps(nextProps) {
+	      var nextSchema = this.state.schema;
+	      var nextQuery = this.state.query;
+	      var nextVariables = this.state.variables;
+	      var nextOperationName = this.state.operationName;
+	      var nextResponse = this.state.response;
+
+	      if (nextProps.schema !== undefined) {
+	        nextSchema = nextProps.schema;
+	      }
+	      if (nextProps.query !== undefined) {
+	        nextQuery = nextProps.query;
+	      }
+	      if (nextProps.variables !== undefined) {
+	        nextVariables = nextProps.variables;
+	      }
+	      if (nextProps.operationName !== undefined) {
+	        nextOperationName = nextProps.operationName;
+	      }
+	      if (nextProps.response !== undefined) {
+	        nextResponse = nextProps.response;
+	      }
+	      if (nextSchema !== this.state.schema || nextQuery !== this.state.query || nextOperationName !== this.state.operationName) {
+	        this._updateQueryFacts(nextQuery);
+	      }
+
+	      this.setState({
+	        schema: nextSchema,
+	        query: nextQuery,
+	        variables: nextVariables,
+	        operationName: nextOperationName,
+	        response: nextResponse
+	      });
+	    }
+	  }, {
+	    key: 'componentDidUpdate',
+	    value: function componentDidUpdate() {
+	      // If this update caused DOM nodes to have changed sizes, update the
+	      // corresponding CodeMirror instance sizes to match.
+	      this.codeMirrorSizer.updateSizes([this.queryEditorComponent, this.variableEditorComponent, this.resultComponent]);
+	    }
+
+	    // When the component is about to unmount, store any persistable state, such
+	    // that when the component is remounted, it will use the last used values.
+
+	  }, {
+	    key: 'componentWillUnmount',
+	    value: function componentWillUnmount() {
+	      this._storageSet('query', this.state.query);
+	      this._storageSet('variables', this.state.variables || '');
+	      this._storageSet('operationName', this.state.operationName);
+	      this._storageSet('editorFlex', this.state.editorFlex);
+	      this._storageSet('variableEditorHeight', this.state.variableEditorHeight);
+	      this._storageSet('docExplorerWidth', this.state.docExplorerWidth);
+	      this._storageSet('docExplorerOpen', this.state.docExplorerOpen);
+	    }
+	  }, {
+	    key: 'render',
+	    value: function render() {
+	      var _this2 = this;
+
+	      var children = _react2.default.Children.toArray(this.props.children);
+
+	      var logo = (0, _find2.default)(children, function (child) {
+	        return child.type === GraphiQL.Logo;
+	      }) || _react2.default.createElement(GraphiQL.Logo, null);
+
+	      var toolbar = (0, _find2.default)(children, function (child) {
+	        return child.type === GraphiQL.Toolbar;
+	      }) || _react2.default.createElement(GraphiQL.Toolbar, null);
+
+	      var footer = (0, _find2.default)(children, function (child) {
+	        return child.type === GraphiQL.Footer;
+	      });
+
+	      var queryWrapStyle = {
+	        WebkitFlex: this.state.editorFlex,
+	        flex: this.state.editorFlex
+	      };
+
+	      var docWrapStyle = {
+	        display: this.state.docExplorerOpen ? 'block' : 'none',
+	        width: this.state.docExplorerWidth
+	      };
+
+	      var variableOpen = this.state.variableEditorOpen;
+	      var variableStyle = {
+	        height: variableOpen ? this.state.variableEditorHeight : null
+	      };
+
+	      return _react2.default.createElement(
+	        'div',
+	        { className: 'graphiql-container' },
+	        _react2.default.createElement(
+	          'div',
+	          { className: 'editorWrap' },
+	          _react2.default.createElement(
+	            'div',
+	            { className: 'topBarWrap' },
+	            _react2.default.createElement(
+	              'div',
+	              { className: 'topBar' },
+	              logo,
+	              _react2.default.createElement(_ExecuteButton.ExecuteButton, {
+	                isRunning: Boolean(this.state.subscription),
+	                onRun: this.handleRunQuery,
+	                onStop: this.handleStopQuery,
+	                operations: this.state.operations
+	              }),
+	              _react2.default.createElement(GraphiQL.ToolbarButton, {
+	                onClick: this.handlePrettifyQuery,
+	                title: 'Prettify Query',
+	                label: 'Prettify'
+	              }),
+	              toolbar
+	            ),
+	            !this.state.docExplorerOpen && _react2.default.createElement(
+	              'button',
+	              {
+	                className: 'docExplorerShow',
+	                onClick: this.handleToggleDocs },
+	              'Docs'
+	            )
+	          ),
+	          _react2.default.createElement(
+	            'div',
+	            {
+	              ref: function ref(n) {
+	                _this2.editorBarComponent = n;
+	              },
+	              className: 'editorBar',
+	              onMouseDown: this.handleResizeStart },
+	            _react2.default.createElement(
+	              'div',
+	              { className: 'queryWrap', style: queryWrapStyle },
+	              _react2.default.createElement(_QueryEditor.QueryEditor, {
+	                ref: function ref(n) {
+	                  _this2.queryEditorComponent = n;
+	                },
+	                schema: this.state.schema,
+	                value: this.state.query,
+	                onEdit: this.handleEditQuery,
+	                onHintInformationRender: this.handleHintInformationRender,
+	                onRunQuery: this.handleEditorRunQuery
+	              }),
+	              _react2.default.createElement(
+	                'div',
+	                { className: 'variable-editor', style: variableStyle },
+	                _react2.default.createElement(
+	                  'div',
+	                  {
+	                    className: 'variable-editor-title',
+	                    style: { cursor: variableOpen ? 'row-resize' : 'n-resize' },
+	                    onMouseDown: this.handleVariableResizeStart },
+	                  'Query Variables'
+	                ),
+	                _react2.default.createElement(_VariableEditor.VariableEditor, {
+	                  ref: function ref(n) {
+	                    _this2.variableEditorComponent = n;
+	                  },
+	                  value: this.state.variables,
+	                  variableToType: this.state.variableToType,
+	                  onEdit: this.handleEditVariables,
+	                  onHintInformationRender: this.handleHintInformationRender,
+	                  onRunQuery: this.handleEditorRunQuery
+	                })
+	              )
+	            ),
+	            _react2.default.createElement(
+	              'div',
+	              { className: 'resultWrap' },
+	              this.state.isWaitingForResponse && _react2.default.createElement(
+	                'div',
+	                { className: 'spinner-container' },
+	                _react2.default.createElement('div', { className: 'spinner' })
+	              ),
+	              _react2.default.createElement(_ResultViewer.ResultViewer, {
+	                ref: function ref(c) {
+	                  _this2.resultComponent = c;
+	                },
+	                value: this.state.response
+	              }),
+	              footer
+	            )
+	          )
+	        ),
+	        _react2.default.createElement(
+	          'div',
+	          { className: 'docExplorerWrap', style: docWrapStyle },
+	          _react2.default.createElement('div', {
+	            className: 'docExplorerResizer',
+	            onMouseDown: this.handleDocsResizeStart
+	          }),
+	          _react2.default.createElement(
+	            _DocExplorer.DocExplorer,
+	            {
+	              ref: function ref(c) {
+	                _this2.docExplorerComponent = c;
+	              },
+	              schema: this.state.schema },
+	            _react2.default.createElement(
+	              'div',
+	              { className: 'docExplorerHide', onClick: this.handleToggleDocs },
+	              '\u2715'
+	            )
+	          )
+	        )
+	      );
+	    }
+
+	    /**
+	     * Inspect the query, automatically filling in selection sets for non-leaf
+	     * fields which do not yet have them.
+	     *
+	     * @public
+	     */
+
+	  }, {
+	    key: 'autoCompleteLeafs',
+	    value: function autoCompleteLeafs() {
+	      var _this3 = this;
+
+	      var _fillLeafs = (0, _fillLeafs2.fillLeafs)(this.state.schema, this.state.query, this.props.getDefaultFieldNames),
+	          insertions = _fillLeafs.insertions,
+	          result = _fillLeafs.result;
+
+	      if (insertions && insertions.length > 0) {
+	        (function () {
+	          var editor = _this3.queryEditorComponent.getCodeMirror();
+	          editor.operation(function () {
+	            var cursor = editor.getCursor();
+	            var cursorIndex = editor.indexFromPos(cursor);
+	            editor.setValue(result);
+	            var added = 0;
+	            var markers = insertions.map(function (_ref) {
+	              var index = _ref.index,
+	                  string = _ref.string;
+	              return editor.markText(editor.posFromIndex(index + added), editor.posFromIndex(index + (added += string.length)), {
+	                className: 'autoInsertedLeaf',
+	                clearOnEnter: true,
+	                title: 'Automatically added leaf fields'
+	              });
+	            });
+	            setTimeout(function () {
+	              return markers.forEach(function (marker) {
+	                return marker.clear();
+	              });
+	            }, 7000);
+	            var newCursorIndex = cursorIndex;
+	            insertions.forEach(function (_ref2) {
+	              var index = _ref2.index,
+	                  string = _ref2.string;
+
+	              if (index < cursorIndex) {
+	                newCursorIndex += string.length;
+	              }
+	            });
+	            editor.setCursor(editor.posFromIndex(newCursorIndex));
+	          });
+	        })();
+	      }
+
+	      return result;
+	    }
+
+	    // Private methods
+
+	  }, {
+	    key: '_ensureOfSchema',
+	    value: function _ensureOfSchema() {
+	      var _this4 = this;
+
+	      // Only perform introspection if a schema is not provided (undefined)
+	      if (this.state.schema !== undefined) {
+	        return;
+	      }
+
+	      var fetcher = this.props.fetcher;
+
+	      var fetch = observableToPromise(fetcher({ query: _introspectionQueries.introspectionQuery }));
+	      if (!isPromise(fetch)) {
+	        this.setState({
+	          response: 'Fetcher did not return a Promise for introspection.'
+	        });
+	        return;
+	      }
+
+	      fetch.then(function (result) {
+	        if (result.data) {
+	          return result;
+	        }
+
+	        // Try the stock introspection query first, falling back on the
+	        // sans-subscriptions query for services which do not yet support it.
+	        var fetch2 = observableToPromise(fetcher({
+	          query: _introspectionQueries.introspectionQuerySansSubscriptions
+	        }));
+	        if (!isPromise(fetch)) {
+	          throw new Error('Fetcher did not return a Promise for introspection.');
+	        }
+	        return fetch2;
+	      }).then(function (result) {
+	        // If a schema was provided while this fetch was underway, then
+	        // satisfy the race condition by respecting the already
+	        // provided schema.
+	        if (_this4.state.schema !== undefined) {
+	          return;
+	        }
+
+	        if (result && result.data) {
+	          var schema = (0, _graphql.buildClientSchema)(result.data);
+	          var queryFacts = (0, _getQueryFacts2.default)(schema, _this4.state.query);
+	          _this4.setState(_extends({ schema: schema }, queryFacts));
+	        } else {
+	          var responseString = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+	          _this4.setState({ response: responseString });
+	        }
+	      }).catch(function (error) {
+	        _this4.setState({ response: error && String(error.stack || error) });
+	      });
+	    }
+	  }, {
+	    key: '_storageGet',
+	    value: function _storageGet(name) {
+	      return this._storage && this._storage.getItem('graphiql:' + name);
+	    }
+	  }, {
+	    key: '_storageSet',
+	    value: function _storageSet(name, value) {
+	      if (this._storage) {
+	        this._storage.setItem('graphiql:' + name, value);
+	      }
+	    }
+	  }, {
+	    key: '_fetchQuery',
+	    value: function _fetchQuery(query, variables, operationName, cb) {
+	      var _this5 = this;
+
+	      var fetcher = this.props.fetcher;
+	      var jsonVariables = null;
+
+	      try {
+	        jsonVariables = variables && variables.trim() !== '' ? JSON.parse(variables) : null;
+	      } catch (error) {
+	        throw new Error('Variables are invalid JSON: ' + error.message + '.');
+	      }
+
+	      if ((typeof jsonVariables === 'undefined' ? 'undefined' : _typeof(jsonVariables)) !== 'object') {
+	        throw new Error('Variables are not a JSON object.');
+	      }
+
+	      var fetch = fetcher({
+	        query: query,
+	        variables: jsonVariables,
+	        operationName: operationName
+	      });
+
+	      if (isPromise(fetch)) {
+	        // If fetcher returned a Promise, then call the callback when the promise
+	        // resolves, otherwise handle the error.
+	        fetch.then(cb).catch(function (error) {
+	          _this5.setState({
+	            isWaitingForResponse: false,
+	            response: error && String(error.stack || error)
+	          });
+	        });
+	      } else if (isObservable(fetch)) {
+	        // If the fetcher returned an Observable, then subscribe to it, calling
+	        // the callback on each next value, and handling both errors and the
+	        // completion of the Observable. Returns a Subscription object.
+	        var subscription = fetch.subscribe({
+	          next: cb,
+	          error: function error(_error) {
+	            _this5.setState({
+	              isWaitingForResponse: false,
+	              response: _error && String(_error.stack || _error),
+	              subscription: null
+	            });
+	          },
+	          complete: function complete() {
+	            _this5.setState({
+	              isWaitingForResponse: false,
+	              subscription: null
+	            });
+	          }
+	        });
+
+	        return subscription;
+	      } else {
+	        throw new Error('Fetcher did not return Promise or Observable.');
+	      }
+	    }
+	  }, {
+	    key: '_runQueryAtCursor',
+	    value: function _runQueryAtCursor() {
+	      if (this.state.subscription) {
+	        this.handleStopQuery();
+	        return;
+	      }
+
+	      var operationName = void 0;
+	      var operations = this.state.operations;
+	      if (operations) {
+	        var editor = this.queryEditorComponent.getCodeMirror();
+	        if (editor.hasFocus()) {
+	          var cursor = editor.getCursor();
+	          var cursorIndex = editor.indexFromPos(cursor);
+
+	          // Loop through all operations to see if one contains the cursor.
+	          for (var i = 0; i < operations.length; i++) {
+	            var operation = operations[i];
+	            if (operation.loc.start <= cursorIndex && operation.loc.end >= cursorIndex) {
+	              operationName = operation.name && operation.name.value;
+	              break;
+	            }
+	          }
+	        }
+	      }
+
+	      this.handleRunQuery(operationName);
+	    }
+	  }, {
+	    key: '_didClickDragBar',
+	    value: function _didClickDragBar(event) {
+	      // Only for primary unmodified clicks
+	      if (event.button !== 0 || event.ctrlKey) {
+	        return false;
+	      }
+	      var target = event.target;
+	      // We use codemirror's gutter as the drag bar.
+	      if (target.className.indexOf('CodeMirror-gutter') !== 0) {
+	        return false;
+	      }
+	      // Specifically the result window's drag bar.
+	      var resultWindow = _reactDom2.default.findDOMNode(this.resultComponent);
+	      while (target) {
+	        if (target === resultWindow) {
+	          return true;
+	        }
+	        target = target.parentNode;
+	      }
+	      return false;
+	    }
+	  }]);
+
+	  return GraphiQL;
+	}(_react2.default.Component);
+
+	// Configure the UI by providing this Component as a child of GraphiQL.
+
+
+	GraphiQL.propTypes = {
+	  fetcher: _react.PropTypes.func.isRequired,
+	  schema: _react.PropTypes.instanceOf(_graphql.GraphQLSchema),
+	  query: _react.PropTypes.string,
+	  variables: _react.PropTypes.string,
+	  operationName: _react.PropTypes.string,
+	  response: _react.PropTypes.string,
+	  storage: _react.PropTypes.shape({
+	    getItem: _react.PropTypes.func,
+	    setItem: _react.PropTypes.func
+	  }),
+	  defaultQuery: _react.PropTypes.string,
+	  onEditQuery: _react.PropTypes.func,
+	  onEditVariables: _react.PropTypes.func,
+	  onEditOperationName: _react.PropTypes.func,
+	  onToggleDocs: _react.PropTypes.func,
+	  getDefaultFieldNames: _react.PropTypes.func
+	};
+
+	var _initialiseProps = function _initialiseProps() {
+	  var _this6 = this;
+
+	  this.handleRunQuery = function (selectedOperationName) {
+	    _this6._editorQueryID++;
+	    var queryID = _this6._editorQueryID;
+
+	    // Use the edited query after autoCompleteLeafs() runs or,
+	    // in case autoCompletion fails (the function returns undefined),
+	    // the current query from the editor.
+	    var editedQuery = _this6.autoCompleteLeafs() || _this6.state.query;
+	    var variables = _this6.state.variables;
+	    var operationName = _this6.state.operationName;
+
+	    // If an operation was explicitly provided, different from the current
+	    // operation name, then report that it changed.
+	    if (selectedOperationName && selectedOperationName !== operationName) {
+	      operationName = selectedOperationName;
+	      var onEditOperationName = _this6.props.onEditOperationName;
+	      if (onEditOperationName) {
+	        onEditOperationName(operationName);
+	      }
+	    }
+
+	    try {
+	      _this6.setState({
+	        isWaitingForResponse: true,
+	        response: null,
+	        operationName: operationName
+	      });
+
+	      // _fetchQuery may return a subscription.
+	      var subscription = _this6._fetchQuery(editedQuery, variables, operationName, function (result) {
+	        if (queryID === _this6._editorQueryID) {
+	          _this6.setState({
+	            isWaitingForResponse: false,
+	            response: JSON.stringify(result, null, 2)
+	          });
+	        }
+	      });
+
+	      _this6.setState({ subscription: subscription });
+	    } catch (error) {
+	      _this6.setState({
+	        isWaitingForResponse: false,
+	        response: error.message
+	      });
+	    }
+	  };
+
+	  this.handleStopQuery = function () {
+	    var subscription = _this6.state.subscription;
+	    _this6.setState({
+	      isWaitingForResponse: false,
+	      subscription: null
+	    });
+	    if (subscription) {
+	      subscription.unsubscribe();
+	    }
+	  };
+
+	  this.handlePrettifyQuery = function () {
+	    var query = (0, _graphql.print)((0, _graphql.parse)(_this6.state.query));
+	    var editor = _this6.queryEditorComponent.getCodeMirror();
+	    editor.setValue(query);
+	  };
+
+	  this.handleEditQuery = function (value) {
+	    if (_this6.state.schema) {
+	      _this6._updateQueryFacts(value);
+	    }
+	    _this6.setState({ query: value });
+	    if (_this6.props.onEditQuery) {
+	      return _this6.props.onEditQuery(value);
+	    }
+	  };
+
+	  this._updateQueryFacts = (0, _debounce2.default)(150, function (query) {
+	    var queryFacts = (0, _getQueryFacts2.default)(_this6.state.schema, query);
+	    if (queryFacts) {
+	      // Update operation name should any query names change.
+	      var operationName = (0, _getSelectedOperationName2.default)(_this6.state.operations, _this6.state.operationName, queryFacts.operations);
+
+	      // Report changing of operationName if it changed.
+	      var onEditOperationName = _this6.props.onEditOperationName;
+	      if (onEditOperationName && operationName !== _this6.state.operationName) {
+	        onEditOperationName(operationName);
+	      }
+
+	      _this6.setState(_extends({
+	        operationName: operationName
+	      }, queryFacts));
+	    }
+	  });
+
+	  this.handleEditVariables = function (value) {
+	    _this6.setState({ variables: value });
+	    if (_this6.props.onEditVariables) {
+	      _this6.props.onEditVariables(value);
+	    }
+	  };
+
+	  this.handleHintInformationRender = function (elem) {
+	    elem.addEventListener('click', _this6._onClickHintInformation);
+
+	    var _onRemoveFn = void 0;
+	    elem.addEventListener('DOMNodeRemoved', _onRemoveFn = function onRemoveFn() {
+	      elem.removeEventListener('DOMNodeRemoved', _onRemoveFn);
+	      elem.removeEventListener('click', _this6._onClickHintInformation);
+	    });
+	  };
+
+	  this.handleEditorRunQuery = function () {
+	    _this6._runQueryAtCursor();
+	  };
+
+	  this._onClickHintInformation = function (event) {
+	    if (event.target.className === 'typeName') {
+	      var typeName = event.target.innerHTML;
+	      var schema = _this6.state.schema;
+	      if (schema) {
+	        (function () {
+	          var type = schema.getType(typeName);
+	          if (type) {
+	            _this6.setState({ docExplorerOpen: true }, function () {
+	              _this6.docExplorerComponent.showDoc(type);
+	            });
+	          }
+	        })();
+	      }
+	    }
+	  };
+
+	  this.handleToggleDocs = function () {
+	    if (typeof _this6.props.onToggleDocs === 'function') {
+	      _this6.props.onToggleDocs(!_this6.state.docExplorerOpen);
+	    }
+	    _this6.setState({ docExplorerOpen: !_this6.state.docExplorerOpen });
+	  };
+
+	  this.handleResizeStart = function (downEvent) {
+	    if (!_this6._didClickDragBar(downEvent)) {
+	      return;
+	    }
+
+	    downEvent.preventDefault();
+
+	    var offset = downEvent.clientX - (0, _elementPosition.getLeft)(downEvent.target);
+
+	    var onMouseMove = function onMouseMove(moveEvent) {
+	      if (moveEvent.buttons === 0) {
+	        return onMouseUp();
+	      }
+
+	      var editorBar = _reactDom2.default.findDOMNode(_this6.editorBarComponent);
+	      var leftSize = moveEvent.clientX - (0, _elementPosition.getLeft)(editorBar) - offset;
+	      var rightSize = editorBar.clientWidth - leftSize;
+	      _this6.setState({ editorFlex: leftSize / rightSize });
+	    };
+
+	    var onMouseUp = function (_onMouseUp) {
+	      function onMouseUp() {
+	        return _onMouseUp.apply(this, arguments);
+	      }
+
+	      onMouseUp.toString = function () {
+	        return _onMouseUp.toString();
+	      };
+
+	      return onMouseUp;
+	    }(function () {
+	      document.removeEventListener('mousemove', onMouseMove);
+	      document.removeEventListener('mouseup', onMouseUp);
+	      onMouseMove = null;
+	      onMouseUp = null;
+	    });
+
+	    document.addEventListener('mousemove', onMouseMove);
+	    document.addEventListener('mouseup', onMouseUp);
+	  };
+
+	  this.handleDocsResizeStart = function (downEvent) {
+	    downEvent.preventDefault();
+
+	    var hadWidth = _this6.state.docExplorerWidth;
+	    var offset = downEvent.clientX - (0, _elementPosition.getLeft)(downEvent.target);
+
+	    var onMouseMove = function onMouseMove(moveEvent) {
+	      if (moveEvent.buttons === 0) {
+	        return onMouseUp();
+	      }
+
+	      var app = _reactDom2.default.findDOMNode(_this6);
+	      var cursorPos = moveEvent.clientX - (0, _elementPosition.getLeft)(app) - offset;
+	      var docsSize = app.clientWidth - cursorPos;
+
+	      if (docsSize < 100) {
+	        _this6.setState({ docExplorerOpen: false });
+	      } else {
+	        _this6.setState({
+	          docExplorerOpen: true,
+	          docExplorerWidth: Math.min(docsSize, 650)
+	        });
+	      }
+	    };
+
+	    var onMouseUp = function (_onMouseUp2) {
+	      function onMouseUp() {
+	        return _onMouseUp2.apply(this, arguments);
+	      }
+
+	      onMouseUp.toString = function () {
+	        return _onMouseUp2.toString();
+	      };
+
+	      return onMouseUp;
+	    }(function () {
+	      if (!_this6.state.docExplorerOpen) {
+	        _this6.setState({ docExplorerWidth: hadWidth });
+	      }
+
+	      document.removeEventListener('mousemove', onMouseMove);
+	      document.removeEventListener('mouseup', onMouseUp);
+	      onMouseMove = null;
+	      onMouseUp = null;
+	    });
+
+	    document.addEventListener('mousemove', onMouseMove);
+	    document.addEventListener('mouseup', onMouseUp);
+	  };
+
+	  this.handleVariableResizeStart = function (downEvent) {
+	    downEvent.preventDefault();
+
+	    var didMove = false;
+	    var wasOpen = _this6.state.variableEditorOpen;
+	    var hadHeight = _this6.state.variableEditorHeight;
+	    var offset = downEvent.clientY - (0, _elementPosition.getTop)(downEvent.target);
+
+	    var onMouseMove = function onMouseMove(moveEvent) {
+	      if (moveEvent.buttons === 0) {
+	        return onMouseUp();
+	      }
+
+	      didMove = true;
+
+	      var editorBar = _reactDom2.default.findDOMNode(_this6.editorBarComponent);
+	      var topSize = moveEvent.clientY - (0, _elementPosition.getTop)(editorBar) - offset;
+	      var bottomSize = editorBar.clientHeight - topSize;
+	      if (bottomSize < 60) {
+	        _this6.setState({
+	          variableEditorOpen: false,
+	          variableEditorHeight: hadHeight
+	        });
+	      } else {
+	        _this6.setState({
+	          variableEditorOpen: true,
+	          variableEditorHeight: bottomSize
+	        });
+	      }
+	    };
+
+	    var onMouseUp = function (_onMouseUp3) {
+	      function onMouseUp() {
+	        return _onMouseUp3.apply(this, arguments);
+	      }
+
+	      onMouseUp.toString = function () {
+	        return _onMouseUp3.toString();
+	      };
+
+	      return onMouseUp;
+	    }(function () {
+	      if (!didMove) {
+	        _this6.setState({ variableEditorOpen: !wasOpen });
+	      }
+
+	      document.removeEventListener('mousemove', onMouseMove);
+	      document.removeEventListener('mouseup', onMouseUp);
+	      onMouseMove = null;
+	      onMouseUp = null;
+	    });
+
+	    document.addEventListener('mousemove', onMouseMove);
+	    document.addEventListener('mouseup', onMouseUp);
+	  };
+	};
+
+	GraphiQL.Logo = function GraphiQLLogo(props) {
+	  return _react2.default.createElement(
+	    'div',
+	    { className: 'title' },
+	    props.children || _react2.default.createElement(
+	      'span',
+	      null,
+	      'Graph',
+	      _react2.default.createElement(
+	        'em',
+	        null,
+	        'i'
+	      ),
+	      'QL'
+	    )
+	  );
+	};
+
+	// Configure the UI by providing this Component as a child of GraphiQL.
+	GraphiQL.Toolbar = function GraphiQLToolbar(props) {
+	  return _react2.default.createElement(
+	    'div',
+	    { className: 'toolbar' },
+	    props.children
+	  );
+	};
+
+	// Add a button to the Toolbar.
+	GraphiQL.ToolbarButton = _ToolbarButton.ToolbarButton;
+
+	// Configure the UI by providing this Component as a child of GraphiQL.
+	GraphiQL.Footer = function GraphiQLFooter(props) {
+	  return _react2.default.createElement(
+	    'div',
+	    { className: 'footer' },
+	    props.children
+	  );
+	};
+
+	var defaultQuery = '# Welcome to GraphiQL\n#\n# GraphiQL is an in-browser IDE for writing, validating, and\n# testing GraphQL queries.\n#\n# Type queries into this side of the screen, and you will\n# see intelligent typeaheads aware of the current GraphQL type schema and\n# live syntax and validation errors highlighted within the text.\n#\n# To bring up the auto-complete at any point, just press Ctrl-Space.\n#\n# Press the run button above, or Cmd-Enter to execute the query, and the result\n# will appear in the pane to the right.\n\n';
+
+	// Duck-type promise detection.
+	function isPromise(value) {
+	  return (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && typeof value.then === 'function';
+	}
+
+	// Duck-type Observable.take(1).toPromise()
+	function observableToPromise(observable) {
+	  if (!isObservable(observable)) {
+	    return observable;
+	  }
+	  return new Promise(function (resolve, reject) {
+	    var subscription = observable.subscribe(function (v) {
+	      resolve(v);
+	      subscription.unsubscribe();
+	    }, reject, function () {
+	      reject(new Error('no value resolved'));
+	    });
+	  });
+	}
+
+	// Duck-type observable detection.
+	function isObservable(value) {
+	  return (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && typeof value.subscribe === 'function';
+	}
+
+/***/ },
+/* 185 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _graphql = __webpack_require__(186);
+
+	Object.defineProperty(exports, 'graphql', {
+	  enumerable: true,
+	  get: function get() {
+	    return _graphql.graphql;
+	  }
+	});
+
+	var _type = __webpack_require__(248);
+
+	Object.defineProperty(exports, 'GraphQLSchema', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.GraphQLSchema;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLScalarType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.GraphQLScalarType;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLObjectType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.GraphQLObjectType;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLInterfaceType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.GraphQLInterfaceType;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLUnionType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.GraphQLUnionType;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLEnumType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.GraphQLEnumType;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLInputObjectType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.GraphQLInputObjectType;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLList', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.GraphQLList;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLNonNull', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.GraphQLNonNull;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLDirective', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.GraphQLDirective;
+	  }
+	});
+	Object.defineProperty(exports, 'TypeKind', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.TypeKind;
+	  }
+	});
+	Object.defineProperty(exports, 'DirectiveLocation', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.DirectiveLocation;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLInt', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.GraphQLInt;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLFloat', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.GraphQLFloat;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLString', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.GraphQLString;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLBoolean', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.GraphQLBoolean;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLID', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.GraphQLID;
+	  }
+	});
+	Object.defineProperty(exports, 'specifiedDirectives', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.specifiedDirectives;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLIncludeDirective', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.GraphQLIncludeDirective;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLSkipDirective', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.GraphQLSkipDirective;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLDeprecatedDirective', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.GraphQLDeprecatedDirective;
+	  }
+	});
+	Object.defineProperty(exports, 'DEFAULT_DEPRECATION_REASON', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.DEFAULT_DEPRECATION_REASON;
+	  }
+	});
+	Object.defineProperty(exports, 'SchemaMetaFieldDef', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.SchemaMetaFieldDef;
+	  }
+	});
+	Object.defineProperty(exports, 'TypeMetaFieldDef', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.TypeMetaFieldDef;
+	  }
+	});
+	Object.defineProperty(exports, 'TypeNameMetaFieldDef', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.TypeNameMetaFieldDef;
+	  }
+	});
+	Object.defineProperty(exports, '__Schema', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.__Schema;
+	  }
+	});
+	Object.defineProperty(exports, '__Directive', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.__Directive;
+	  }
+	});
+	Object.defineProperty(exports, '__DirectiveLocation', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.__DirectiveLocation;
+	  }
+	});
+	Object.defineProperty(exports, '__Type', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.__Type;
+	  }
+	});
+	Object.defineProperty(exports, '__Field', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.__Field;
+	  }
+	});
+	Object.defineProperty(exports, '__InputValue', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.__InputValue;
+	  }
+	});
+	Object.defineProperty(exports, '__EnumValue', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.__EnumValue;
+	  }
+	});
+	Object.defineProperty(exports, '__TypeKind', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.__TypeKind;
+	  }
+	});
+	Object.defineProperty(exports, 'isType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.isType;
+	  }
+	});
+	Object.defineProperty(exports, 'isInputType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.isInputType;
+	  }
+	});
+	Object.defineProperty(exports, 'isOutputType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.isOutputType;
+	  }
+	});
+	Object.defineProperty(exports, 'isLeafType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.isLeafType;
+	  }
+	});
+	Object.defineProperty(exports, 'isCompositeType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.isCompositeType;
+	  }
+	});
+	Object.defineProperty(exports, 'isAbstractType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.isAbstractType;
+	  }
+	});
+	Object.defineProperty(exports, 'getNullableType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.getNullableType;
+	  }
+	});
+	Object.defineProperty(exports, 'getNamedType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _type.getNamedType;
+	  }
+	});
+
+	var _language = __webpack_require__(191);
+
+	Object.defineProperty(exports, 'Source', {
+	  enumerable: true,
+	  get: function get() {
+	    return _language.Source;
+	  }
+	});
+	Object.defineProperty(exports, 'getLocation', {
+	  enumerable: true,
+	  get: function get() {
+	    return _language.getLocation;
+	  }
+	});
+	Object.defineProperty(exports, 'parse', {
+	  enumerable: true,
+	  get: function get() {
+	    return _language.parse;
+	  }
+	});
+	Object.defineProperty(exports, 'parseValue', {
+	  enumerable: true,
+	  get: function get() {
+	    return _language.parseValue;
+	  }
+	});
+	Object.defineProperty(exports, 'parseType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _language.parseType;
+	  }
+	});
+	Object.defineProperty(exports, 'print', {
+	  enumerable: true,
+	  get: function get() {
+	    return _language.print;
+	  }
+	});
+	Object.defineProperty(exports, 'visit', {
+	  enumerable: true,
+	  get: function get() {
+	    return _language.visit;
+	  }
+	});
+	Object.defineProperty(exports, 'visitInParallel', {
+	  enumerable: true,
+	  get: function get() {
+	    return _language.visitInParallel;
+	  }
+	});
+	Object.defineProperty(exports, 'visitWithTypeInfo', {
+	  enumerable: true,
+	  get: function get() {
+	    return _language.visitWithTypeInfo;
+	  }
+	});
+	Object.defineProperty(exports, 'Kind', {
+	  enumerable: true,
+	  get: function get() {
+	    return _language.Kind;
+	  }
+	});
+	Object.defineProperty(exports, 'TokenKind', {
+	  enumerable: true,
+	  get: function get() {
+	    return _language.TokenKind;
+	  }
+	});
+	Object.defineProperty(exports, 'BREAK', {
+	  enumerable: true,
+	  get: function get() {
+	    return _language.BREAK;
+	  }
+	});
+
+	var _execution = __webpack_require__(249);
+
+	Object.defineProperty(exports, 'execute', {
+	  enumerable: true,
+	  get: function get() {
+	    return _execution.execute;
+	  }
+	});
+
+	var _validation = __webpack_require__(250);
+
+	Object.defineProperty(exports, 'validate', {
+	  enumerable: true,
+	  get: function get() {
+	    return _validation.validate;
+	  }
+	});
+	Object.defineProperty(exports, 'specifiedRules', {
+	  enumerable: true,
+	  get: function get() {
+	    return _validation.specifiedRules;
+	  }
+	});
+
+	var _error = __webpack_require__(189);
+
+	Object.defineProperty(exports, 'GraphQLError', {
+	  enumerable: true,
+	  get: function get() {
+	    return _error.GraphQLError;
+	  }
+	});
+	Object.defineProperty(exports, 'formatError', {
+	  enumerable: true,
+	  get: function get() {
+	    return _error.formatError;
+	  }
+	});
+
+	var _utilities = __webpack_require__(251);
+
+	Object.defineProperty(exports, 'introspectionQuery', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.introspectionQuery;
+	  }
+	});
+	Object.defineProperty(exports, 'getOperationAST', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.getOperationAST;
+	  }
+	});
+	Object.defineProperty(exports, 'buildClientSchema', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.buildClientSchema;
+	  }
+	});
+	Object.defineProperty(exports, 'buildASTSchema', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.buildASTSchema;
+	  }
+	});
+	Object.defineProperty(exports, 'buildSchema', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.buildSchema;
+	  }
+	});
+	Object.defineProperty(exports, 'extendSchema', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.extendSchema;
+	  }
+	});
+	Object.defineProperty(exports, 'printSchema', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.printSchema;
+	  }
+	});
+	Object.defineProperty(exports, 'typeFromAST', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.typeFromAST;
+	  }
+	});
+	Object.defineProperty(exports, 'valueFromAST', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.valueFromAST;
+	  }
+	});
+	Object.defineProperty(exports, 'astFromValue', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.astFromValue;
+	  }
+	});
+	Object.defineProperty(exports, 'TypeInfo', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.TypeInfo;
+	  }
+	});
+	Object.defineProperty(exports, 'isValidJSValue', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.isValidJSValue;
+	  }
+	});
+	Object.defineProperty(exports, 'isValidLiteralValue', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.isValidLiteralValue;
+	  }
+	});
+	Object.defineProperty(exports, 'concatAST', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.concatAST;
+	  }
+	});
+	Object.defineProperty(exports, 'separateOperations', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.separateOperations;
+	  }
+	});
+	Object.defineProperty(exports, 'isEqualType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.isEqualType;
+	  }
+	});
+	Object.defineProperty(exports, 'isTypeSubTypeOf', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.isTypeSubTypeOf;
+	  }
+	});
+	Object.defineProperty(exports, 'doTypesOverlap', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.doTypesOverlap;
+	  }
+	});
+	Object.defineProperty(exports, 'assertValidName', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.assertValidName;
+	  }
+	});
+	Object.defineProperty(exports, 'findBreakingChanges', {
+	  enumerable: true,
+	  get: function get() {
+	    return _utilities.findBreakingChanges;
+	  }
+	});
+
+/***/ },
+/* 186 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.graphql = graphql;
+
+	var _source = __webpack_require__(187);
+
+	var _parser = __webpack_require__(188);
+
+	var _validate = __webpack_require__(201);
+
+	var _execute = __webpack_require__(244);
+
+	/**
+	 * This is the primary entry point function for fulfilling GraphQL operations
+	 * by parsing, validating, and executing a GraphQL document along side a
+	 * GraphQL schema.
+	 *
+	 * More sophisticated GraphQL servers, such as those which persist queries,
+	 * may wish to separate the validation and execution phases to a static time
+	 * tooling step, and a server runtime step.
+	 *
+	 * schema:
+	 *    The GraphQL type system to use when validating and executing a query.
+	 * requestString:
+	 *    A GraphQL language formatted string representing the requested operation.
+	 * rootValue:
+	 *    The value provided as the first argument to resolver functions on the top
+	 *    level type (e.g. the query object type).
+	 * variableValues:
+	 *    A mapping of variable name to runtime value to use for all variables
+	 *    defined in the requestString.
+	 * operationName:
+	 *    The name of the operation to use if requestString contains multiple
+	 *    possible operations. Can be omitted if requestString contains only
+	 *    one operation.
+	 */
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function graphql(schema, requestString, rootValue, contextValue, variableValues, operationName) {
+	  return new Promise(function (resolve) {
+	    var source = new _source.Source(requestString || '', 'GraphQL request');
+	    var documentAST = (0, _parser.parse)(source);
+	    var validationErrors = (0, _validate.validate)(schema, documentAST);
+	    if (validationErrors.length > 0) {
+	      resolve({ errors: validationErrors });
+	    } else {
+	      resolve((0, _execute.execute)(schema, documentAST, rootValue, contextValue, variableValues, operationName));
+	    }
+	  }).then(undefined, function (error) {
+	    return { errors: [error] };
+	  });
+	}
+
+	/**
+	 * The result of a GraphQL parse, validation and execution.
+	 *
+	 * `data` is the result of a successful execution of the query.
+	 * `errors` is included when any errors occurred as a non-empty array.
+	 */
+
+/***/ },
+/* 187 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	/**
+	 * A representation of source input to GraphQL. The name is optional,
+	 * but is mostly useful for clients who store GraphQL documents in
+	 * source files; for example, if the GraphQL input is in a file Foo.graphql,
+	 * it might be useful for name to be "Foo.graphql".
+	 */
+	var Source = exports.Source = function Source(body, name) {
+	  _classCallCheck(this, Source);
+
+	  this.body = body;
+	  this.name = name || 'GraphQL';
+	};
+
+/***/ },
+/* 188 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.parse = parse;
+	exports.parseValue = parseValue;
+	exports.parseType = parseType;
+	exports.parseConstValue = parseConstValue;
+	exports.parseTypeReference = parseTypeReference;
+	exports.parseNamedType = parseNamedType;
+
+	var _source = __webpack_require__(187);
+
+	var _error = __webpack_require__(189);
+
+	var _lexer = __webpack_require__(193);
+
+	var _kinds = __webpack_require__(196);
+
+	/**
+	 * Given a GraphQL source, parses it into a Document.
+	 * Throws GraphQLError if a syntax error is encountered.
+	 */
+
+
+	/**
+	 * Configuration options to control parser behavior
+	 */
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function parse(source, options) {
+	  var sourceObj = typeof source === 'string' ? new _source.Source(source) : source;
+	  var lexer = (0, _lexer.createLexer)(sourceObj, options || {});
+	  return parseDocument(lexer);
+	}
+
+	/**
+	 * Given a string containing a GraphQL value (ex. `[42]`), parse the AST for
+	 * that value.
+	 * Throws GraphQLError if a syntax error is encountered.
+	 *
+	 * This is useful within tools that operate upon GraphQL Values directly and
+	 * in isolation of complete GraphQL documents.
+	 *
+	 * Consider providing the results to the utility function: valueFromAST().
+	 */
+	function parseValue(source, options) {
+	  var sourceObj = typeof source === 'string' ? new _source.Source(source) : source;
+	  var lexer = (0, _lexer.createLexer)(sourceObj, options || {});
+	  expect(lexer, _lexer.TokenKind.SOF);
+	  var value = parseValueLiteral(lexer, false);
+	  expect(lexer, _lexer.TokenKind.EOF);
+	  return value;
+	}
+
+	/**
+	 * Given a string containing a GraphQL Type (ex. `[Int!]`), parse the AST for
+	 * that type.
+	 * Throws GraphQLError if a syntax error is encountered.
+	 *
+	 * This is useful within tools that operate upon GraphQL Types directly and
+	 * in isolation of complete GraphQL documents.
+	 *
+	 * Consider providing the results to the utility function: typeFromAST().
+	 */
+	function parseType(source, options) {
+	  var sourceObj = typeof source === 'string' ? new _source.Source(source) : source;
+	  var lexer = (0, _lexer.createLexer)(sourceObj, options || {});
+	  expect(lexer, _lexer.TokenKind.SOF);
+	  var type = parseTypeReference(lexer);
+	  expect(lexer, _lexer.TokenKind.EOF);
+	  return type;
+	}
+
+	/**
+	 * Converts a name lex token into a name parse node.
+	 */
+	function parseName(lexer) {
+	  var token = expect(lexer, _lexer.TokenKind.NAME);
+	  return {
+	    kind: _kinds.NAME,
+	    value: token.value,
+	    loc: loc(lexer, token)
+	  };
+	}
+
+	// Implements the parsing rules in the Document section.
+
+	/**
+	 * Document : Definition+
+	 */
+	function parseDocument(lexer) {
+	  var start = lexer.token;
+	  expect(lexer, _lexer.TokenKind.SOF);
+	  var definitions = [];
+	  do {
+	    definitions.push(parseDefinition(lexer));
+	  } while (!skip(lexer, _lexer.TokenKind.EOF));
+
+	  return {
+	    kind: _kinds.DOCUMENT,
+	    definitions: definitions,
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * Definition :
+	 *   - OperationDefinition
+	 *   - FragmentDefinition
+	 *   - TypeSystemDefinition
+	 */
+	function parseDefinition(lexer) {
+	  if (peek(lexer, _lexer.TokenKind.BRACE_L)) {
+	    return parseOperationDefinition(lexer);
+	  }
+
+	  if (peek(lexer, _lexer.TokenKind.NAME)) {
+	    switch (lexer.token.value) {
+	      // Note: subscription is an experimental non-spec addition.
+	      case 'query':
+	      case 'mutation':
+	      case 'subscription':
+	        return parseOperationDefinition(lexer);
+
+	      case 'fragment':
+	        return parseFragmentDefinition(lexer);
+
+	      // Note: the Type System IDL is an experimental non-spec addition.
+	      case 'schema':
+	      case 'scalar':
+	      case 'type':
+	      case 'interface':
+	      case 'union':
+	      case 'enum':
+	      case 'input':
+	      case 'extend':
+	      case 'directive':
+	        return parseTypeSystemDefinition(lexer);
+	    }
+	  }
+
+	  throw unexpected(lexer);
+	}
+
+	// Implements the parsing rules in the Operations section.
+
+	/**
+	 * OperationDefinition :
+	 *  - SelectionSet
+	 *  - OperationType Name? VariableDefinitions? Directives? SelectionSet
+	 */
+	function parseOperationDefinition(lexer) {
+	  var start = lexer.token;
+	  if (peek(lexer, _lexer.TokenKind.BRACE_L)) {
+	    return {
+	      kind: _kinds.OPERATION_DEFINITION,
+	      operation: 'query',
+	      name: null,
+	      variableDefinitions: null,
+	      directives: [],
+	      selectionSet: parseSelectionSet(lexer),
+	      loc: loc(lexer, start)
+	    };
+	  }
+	  var operation = parseOperationType(lexer);
+	  var name = void 0;
+	  if (peek(lexer, _lexer.TokenKind.NAME)) {
+	    name = parseName(lexer);
+	  }
+	  return {
+	    kind: _kinds.OPERATION_DEFINITION,
+	    operation: operation,
+	    name: name,
+	    variableDefinitions: parseVariableDefinitions(lexer),
+	    directives: parseDirectives(lexer),
+	    selectionSet: parseSelectionSet(lexer),
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * OperationType : one of query mutation subscription
+	 */
+	function parseOperationType(lexer) {
+	  var operationToken = expect(lexer, _lexer.TokenKind.NAME);
+	  switch (operationToken.value) {
+	    case 'query':
+	      return 'query';
+	    case 'mutation':
+	      return 'mutation';
+	    // Note: subscription is an experimental non-spec addition.
+	    case 'subscription':
+	      return 'subscription';
+	  }
+
+	  throw unexpected(lexer, operationToken);
+	}
+
+	/**
+	 * VariableDefinitions : ( VariableDefinition+ )
+	 */
+	function parseVariableDefinitions(lexer) {
+	  return peek(lexer, _lexer.TokenKind.PAREN_L) ? many(lexer, _lexer.TokenKind.PAREN_L, parseVariableDefinition, _lexer.TokenKind.PAREN_R) : [];
+	}
+
+	/**
+	 * VariableDefinition : Variable : Type DefaultValue?
+	 */
+	function parseVariableDefinition(lexer) {
+	  var start = lexer.token;
+	  return {
+	    kind: _kinds.VARIABLE_DEFINITION,
+	    variable: parseVariable(lexer),
+	    type: (expect(lexer, _lexer.TokenKind.COLON), parseTypeReference(lexer)),
+	    defaultValue: skip(lexer, _lexer.TokenKind.EQUALS) ? parseValueLiteral(lexer, true) : null,
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * Variable : $ Name
+	 */
+	function parseVariable(lexer) {
+	  var start = lexer.token;
+	  expect(lexer, _lexer.TokenKind.DOLLAR);
+	  return {
+	    kind: _kinds.VARIABLE,
+	    name: parseName(lexer),
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * SelectionSet : { Selection+ }
+	 */
+	function parseSelectionSet(lexer) {
+	  var start = lexer.token;
+	  return {
+	    kind: _kinds.SELECTION_SET,
+	    selections: many(lexer, _lexer.TokenKind.BRACE_L, parseSelection, _lexer.TokenKind.BRACE_R),
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * Selection :
+	 *   - Field
+	 *   - FragmentSpread
+	 *   - InlineFragment
+	 */
+	function parseSelection(lexer) {
+	  return peek(lexer, _lexer.TokenKind.SPREAD) ? parseFragment(lexer) : parseField(lexer);
+	}
+
+	/**
+	 * Field : Alias? Name Arguments? Directives? SelectionSet?
+	 *
+	 * Alias : Name :
+	 */
+	function parseField(lexer) {
+	  var start = lexer.token;
+
+	  var nameOrAlias = parseName(lexer);
+	  var alias = void 0;
+	  var name = void 0;
+	  if (skip(lexer, _lexer.TokenKind.COLON)) {
+	    alias = nameOrAlias;
+	    name = parseName(lexer);
+	  } else {
+	    alias = null;
+	    name = nameOrAlias;
+	  }
+
+	  return {
+	    kind: _kinds.FIELD,
+	    alias: alias,
+	    name: name,
+	    arguments: parseArguments(lexer),
+	    directives: parseDirectives(lexer),
+	    selectionSet: peek(lexer, _lexer.TokenKind.BRACE_L) ? parseSelectionSet(lexer) : null,
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * Arguments : ( Argument+ )
+	 */
+	function parseArguments(lexer) {
+	  return peek(lexer, _lexer.TokenKind.PAREN_L) ? many(lexer, _lexer.TokenKind.PAREN_L, parseArgument, _lexer.TokenKind.PAREN_R) : [];
+	}
+
+	/**
+	 * Argument : Name : Value
+	 */
+	function parseArgument(lexer) {
+	  var start = lexer.token;
+	  return {
+	    kind: _kinds.ARGUMENT,
+	    name: parseName(lexer),
+	    value: (expect(lexer, _lexer.TokenKind.COLON), parseValueLiteral(lexer, false)),
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	// Implements the parsing rules in the Fragments section.
+
+	/**
+	 * Corresponds to both FragmentSpread and InlineFragment in the spec.
+	 *
+	 * FragmentSpread : ... FragmentName Directives?
+	 *
+	 * InlineFragment : ... TypeCondition? Directives? SelectionSet
+	 */
+	function parseFragment(lexer) {
+	  var start = lexer.token;
+	  expect(lexer, _lexer.TokenKind.SPREAD);
+	  if (peek(lexer, _lexer.TokenKind.NAME) && lexer.token.value !== 'on') {
+	    return {
+	      kind: _kinds.FRAGMENT_SPREAD,
+	      name: parseFragmentName(lexer),
+	      directives: parseDirectives(lexer),
+	      loc: loc(lexer, start)
+	    };
+	  }
+	  var typeCondition = null;
+	  if (lexer.token.value === 'on') {
+	    lexer.advance();
+	    typeCondition = parseNamedType(lexer);
+	  }
+	  return {
+	    kind: _kinds.INLINE_FRAGMENT,
+	    typeCondition: typeCondition,
+	    directives: parseDirectives(lexer),
+	    selectionSet: parseSelectionSet(lexer),
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * FragmentDefinition :
+	 *   - fragment FragmentName on TypeCondition Directives? SelectionSet
+	 *
+	 * TypeCondition : NamedType
+	 */
+	function parseFragmentDefinition(lexer) {
+	  var start = lexer.token;
+	  expectKeyword(lexer, 'fragment');
+	  return {
+	    kind: _kinds.FRAGMENT_DEFINITION,
+	    name: parseFragmentName(lexer),
+	    typeCondition: (expectKeyword(lexer, 'on'), parseNamedType(lexer)),
+	    directives: parseDirectives(lexer),
+	    selectionSet: parseSelectionSet(lexer),
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * FragmentName : Name but not `on`
+	 */
+	function parseFragmentName(lexer) {
+	  if (lexer.token.value === 'on') {
+	    throw unexpected(lexer);
+	  }
+	  return parseName(lexer);
+	}
+
+	// Implements the parsing rules in the Values section.
+
+	/**
+	 * Value[Const] :
+	 *   - [~Const] Variable
+	 *   - IntValue
+	 *   - FloatValue
+	 *   - StringValue
+	 *   - BooleanValue
+	 *   - EnumValue
+	 *   - ListValue[?Const]
+	 *   - ObjectValue[?Const]
+	 *
+	 * BooleanValue : one of `true` `false`
+	 *
+	 * EnumValue : Name but not `true`, `false` or `null`
+	 */
+	function parseValueLiteral(lexer, isConst) {
+	  var token = lexer.token;
+	  switch (token.kind) {
+	    case _lexer.TokenKind.BRACKET_L:
+	      return parseList(lexer, isConst);
+	    case _lexer.TokenKind.BRACE_L:
+	      return parseObject(lexer, isConst);
+	    case _lexer.TokenKind.INT:
+	      lexer.advance();
+	      return {
+	        kind: _kinds.INT,
+	        value: token.value,
+	        loc: loc(lexer, token)
+	      };
+	    case _lexer.TokenKind.FLOAT:
+	      lexer.advance();
+	      return {
+	        kind: _kinds.FLOAT,
+	        value: token.value,
+	        loc: loc(lexer, token)
+	      };
+	    case _lexer.TokenKind.STRING:
+	      lexer.advance();
+	      return {
+	        kind: _kinds.STRING,
+	        value: token.value,
+	        loc: loc(lexer, token)
+	      };
+	    case _lexer.TokenKind.NAME:
+	      if (token.value === 'true' || token.value === 'false') {
+	        lexer.advance();
+	        return {
+	          kind: _kinds.BOOLEAN,
+	          value: token.value === 'true',
+	          loc: loc(lexer, token)
+	        };
+	      } else if (token.value !== 'null') {
+	        lexer.advance();
+	        return {
+	          kind: _kinds.ENUM,
+	          value: token.value,
+	          loc: loc(lexer, token)
+	        };
+	      }
+	      break;
+	    case _lexer.TokenKind.DOLLAR:
+	      if (!isConst) {
+	        return parseVariable(lexer);
+	      }
+	      break;
+	  }
+	  throw unexpected(lexer);
+	}
+
+	function parseConstValue(lexer) {
+	  return parseValueLiteral(lexer, true);
+	}
+
+	function parseValueValue(lexer) {
+	  return parseValueLiteral(lexer, false);
+	}
+
+	/**
+	 * ListValue[Const] :
+	 *   - [ ]
+	 *   - [ Value[?Const]+ ]
+	 */
+	function parseList(lexer, isConst) {
+	  var start = lexer.token;
+	  var item = isConst ? parseConstValue : parseValueValue;
+	  return {
+	    kind: _kinds.LIST,
+	    values: any(lexer, _lexer.TokenKind.BRACKET_L, item, _lexer.TokenKind.BRACKET_R),
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * ObjectValue[Const] :
+	 *   - { }
+	 *   - { ObjectField[?Const]+ }
+	 */
+	function parseObject(lexer, isConst) {
+	  var start = lexer.token;
+	  expect(lexer, _lexer.TokenKind.BRACE_L);
+	  var fields = [];
+	  while (!skip(lexer, _lexer.TokenKind.BRACE_R)) {
+	    fields.push(parseObjectField(lexer, isConst));
+	  }
+	  return {
+	    kind: _kinds.OBJECT,
+	    fields: fields,
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * ObjectField[Const] : Name : Value[?Const]
+	 */
+	function parseObjectField(lexer, isConst) {
+	  var start = lexer.token;
+	  return {
+	    kind: _kinds.OBJECT_FIELD,
+	    name: parseName(lexer),
+	    value: (expect(lexer, _lexer.TokenKind.COLON), parseValueLiteral(lexer, isConst)),
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	// Implements the parsing rules in the Directives section.
+
+	/**
+	 * Directives : Directive+
+	 */
+	function parseDirectives(lexer) {
+	  var directives = [];
+	  while (peek(lexer, _lexer.TokenKind.AT)) {
+	    directives.push(parseDirective(lexer));
+	  }
+	  return directives;
+	}
+
+	/**
+	 * Directive : @ Name Arguments?
+	 */
+	function parseDirective(lexer) {
+	  var start = lexer.token;
+	  expect(lexer, _lexer.TokenKind.AT);
+	  return {
+	    kind: _kinds.DIRECTIVE,
+	    name: parseName(lexer),
+	    arguments: parseArguments(lexer),
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	// Implements the parsing rules in the Types section.
+
+	/**
+	 * Type :
+	 *   - NamedType
+	 *   - ListType
+	 *   - NonNullType
+	 */
+	function parseTypeReference(lexer) {
+	  var start = lexer.token;
+	  var type = void 0;
+	  if (skip(lexer, _lexer.TokenKind.BRACKET_L)) {
+	    type = parseTypeReference(lexer);
+	    expect(lexer, _lexer.TokenKind.BRACKET_R);
+	    type = {
+	      kind: _kinds.LIST_TYPE,
+	      type: type,
+	      loc: loc(lexer, start)
+	    };
+	  } else {
+	    type = parseNamedType(lexer);
+	  }
+	  if (skip(lexer, _lexer.TokenKind.BANG)) {
+	    return {
+	      kind: _kinds.NON_NULL_TYPE,
+	      type: type,
+	      loc: loc(lexer, start)
+	    };
+	  }
+	  return type;
+	}
+
+	/**
+	 * NamedType : Name
+	 */
+	function parseNamedType(lexer) {
+	  var start = lexer.token;
+	  return {
+	    kind: _kinds.NAMED_TYPE,
+	    name: parseName(lexer),
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	// Implements the parsing rules in the Type Definition section.
+
+	/**
+	 * TypeSystemDefinition :
+	 *   - SchemaDefinition
+	 *   - TypeDefinition
+	 *   - TypeExtensionDefinition
+	 *   - DirectiveDefinition
+	 *
+	 * TypeDefinition :
+	 *   - ScalarTypeDefinition
+	 *   - ObjectTypeDefinition
+	 *   - InterfaceTypeDefinition
+	 *   - UnionTypeDefinition
+	 *   - EnumTypeDefinition
+	 *   - InputObjectTypeDefinition
+	 */
+	function parseTypeSystemDefinition(lexer) {
+	  if (peek(lexer, _lexer.TokenKind.NAME)) {
+	    switch (lexer.token.value) {
+	      case 'schema':
+	        return parseSchemaDefinition(lexer);
+	      case 'scalar':
+	        return parseScalarTypeDefinition(lexer);
+	      case 'type':
+	        return parseObjectTypeDefinition(lexer);
+	      case 'interface':
+	        return parseInterfaceTypeDefinition(lexer);
+	      case 'union':
+	        return parseUnionTypeDefinition(lexer);
+	      case 'enum':
+	        return parseEnumTypeDefinition(lexer);
+	      case 'input':
+	        return parseInputObjectTypeDefinition(lexer);
+	      case 'extend':
+	        return parseTypeExtensionDefinition(lexer);
+	      case 'directive':
+	        return parseDirectiveDefinition(lexer);
+	    }
+	  }
+
+	  throw unexpected(lexer);
+	}
+
+	/**
+	 * SchemaDefinition : schema Directives? { OperationTypeDefinition+ }
+	 *
+	 * OperationTypeDefinition : OperationType : NamedType
+	 */
+	function parseSchemaDefinition(lexer) {
+	  var start = lexer.token;
+	  expectKeyword(lexer, 'schema');
+	  var directives = parseDirectives(lexer);
+	  var operationTypes = many(lexer, _lexer.TokenKind.BRACE_L, parseOperationTypeDefinition, _lexer.TokenKind.BRACE_R);
+	  return {
+	    kind: _kinds.SCHEMA_DEFINITION,
+	    directives: directives,
+	    operationTypes: operationTypes,
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	function parseOperationTypeDefinition(lexer) {
+	  var start = lexer.token;
+	  var operation = parseOperationType(lexer);
+	  expect(lexer, _lexer.TokenKind.COLON);
+	  var type = parseNamedType(lexer);
+	  return {
+	    kind: _kinds.OPERATION_TYPE_DEFINITION,
+	    operation: operation,
+	    type: type,
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * ScalarTypeDefinition : scalar Name Directives?
+	 */
+	function parseScalarTypeDefinition(lexer) {
+	  var start = lexer.token;
+	  expectKeyword(lexer, 'scalar');
+	  var name = parseName(lexer);
+	  var directives = parseDirectives(lexer);
+	  return {
+	    kind: _kinds.SCALAR_TYPE_DEFINITION,
+	    name: name,
+	    directives: directives,
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * ObjectTypeDefinition :
+	 *   - type Name ImplementsInterfaces? Directives? { FieldDefinition+ }
+	 */
+	function parseObjectTypeDefinition(lexer) {
+	  var start = lexer.token;
+	  expectKeyword(lexer, 'type');
+	  var name = parseName(lexer);
+	  var interfaces = parseImplementsInterfaces(lexer);
+	  var directives = parseDirectives(lexer);
+	  var fields = any(lexer, _lexer.TokenKind.BRACE_L, parseFieldDefinition, _lexer.TokenKind.BRACE_R);
+	  return {
+	    kind: _kinds.OBJECT_TYPE_DEFINITION,
+	    name: name,
+	    interfaces: interfaces,
+	    directives: directives,
+	    fields: fields,
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * ImplementsInterfaces : implements NamedType+
+	 */
+	function parseImplementsInterfaces(lexer) {
+	  var types = [];
+	  if (lexer.token.value === 'implements') {
+	    lexer.advance();
+	    do {
+	      types.push(parseNamedType(lexer));
+	    } while (peek(lexer, _lexer.TokenKind.NAME));
+	  }
+	  return types;
+	}
+
+	/**
+	 * FieldDefinition : Name ArgumentsDefinition? : Type Directives?
+	 */
+	function parseFieldDefinition(lexer) {
+	  var start = lexer.token;
+	  var name = parseName(lexer);
+	  var args = parseArgumentDefs(lexer);
+	  expect(lexer, _lexer.TokenKind.COLON);
+	  var type = parseTypeReference(lexer);
+	  var directives = parseDirectives(lexer);
+	  return {
+	    kind: _kinds.FIELD_DEFINITION,
+	    name: name,
+	    arguments: args,
+	    type: type,
+	    directives: directives,
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * ArgumentsDefinition : ( InputValueDefinition+ )
+	 */
+	function parseArgumentDefs(lexer) {
+	  if (!peek(lexer, _lexer.TokenKind.PAREN_L)) {
+	    return [];
+	  }
+	  return many(lexer, _lexer.TokenKind.PAREN_L, parseInputValueDef, _lexer.TokenKind.PAREN_R);
+	}
+
+	/**
+	 * InputValueDefinition : Name : Type DefaultValue? Directives?
+	 */
+	function parseInputValueDef(lexer) {
+	  var start = lexer.token;
+	  var name = parseName(lexer);
+	  expect(lexer, _lexer.TokenKind.COLON);
+	  var type = parseTypeReference(lexer);
+	  var defaultValue = null;
+	  if (skip(lexer, _lexer.TokenKind.EQUALS)) {
+	    defaultValue = parseConstValue(lexer);
+	  }
+	  var directives = parseDirectives(lexer);
+	  return {
+	    kind: _kinds.INPUT_VALUE_DEFINITION,
+	    name: name,
+	    type: type,
+	    defaultValue: defaultValue,
+	    directives: directives,
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * InterfaceTypeDefinition : interface Name Directives? { FieldDefinition+ }
+	 */
+	function parseInterfaceTypeDefinition(lexer) {
+	  var start = lexer.token;
+	  expectKeyword(lexer, 'interface');
+	  var name = parseName(lexer);
+	  var directives = parseDirectives(lexer);
+	  var fields = any(lexer, _lexer.TokenKind.BRACE_L, parseFieldDefinition, _lexer.TokenKind.BRACE_R);
+	  return {
+	    kind: _kinds.INTERFACE_TYPE_DEFINITION,
+	    name: name,
+	    directives: directives,
+	    fields: fields,
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * UnionTypeDefinition : union Name Directives? = UnionMembers
+	 */
+	function parseUnionTypeDefinition(lexer) {
+	  var start = lexer.token;
+	  expectKeyword(lexer, 'union');
+	  var name = parseName(lexer);
+	  var directives = parseDirectives(lexer);
+	  expect(lexer, _lexer.TokenKind.EQUALS);
+	  var types = parseUnionMembers(lexer);
+	  return {
+	    kind: _kinds.UNION_TYPE_DEFINITION,
+	    name: name,
+	    directives: directives,
+	    types: types,
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * UnionMembers :
+	 *   - NamedType
+	 *   - UnionMembers | NamedType
+	 */
+	function parseUnionMembers(lexer) {
+	  var members = [];
+	  do {
+	    members.push(parseNamedType(lexer));
+	  } while (skip(lexer, _lexer.TokenKind.PIPE));
+	  return members;
+	}
+
+	/**
+	 * EnumTypeDefinition : enum Name Directives? { EnumValueDefinition+ }
+	 */
+	function parseEnumTypeDefinition(lexer) {
+	  var start = lexer.token;
+	  expectKeyword(lexer, 'enum');
+	  var name = parseName(lexer);
+	  var directives = parseDirectives(lexer);
+	  var values = many(lexer, _lexer.TokenKind.BRACE_L, parseEnumValueDefinition, _lexer.TokenKind.BRACE_R);
+	  return {
+	    kind: _kinds.ENUM_TYPE_DEFINITION,
+	    name: name,
+	    directives: directives,
+	    values: values,
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * EnumValueDefinition : EnumValue Directives?
+	 *
+	 * EnumValue : Name
+	 */
+	function parseEnumValueDefinition(lexer) {
+	  var start = lexer.token;
+	  var name = parseName(lexer);
+	  var directives = parseDirectives(lexer);
+	  return {
+	    kind: _kinds.ENUM_VALUE_DEFINITION,
+	    name: name,
+	    directives: directives,
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * InputObjectTypeDefinition : input Name Directives? { InputValueDefinition+ }
+	 */
+	function parseInputObjectTypeDefinition(lexer) {
+	  var start = lexer.token;
+	  expectKeyword(lexer, 'input');
+	  var name = parseName(lexer);
+	  var directives = parseDirectives(lexer);
+	  var fields = any(lexer, _lexer.TokenKind.BRACE_L, parseInputValueDef, _lexer.TokenKind.BRACE_R);
+	  return {
+	    kind: _kinds.INPUT_OBJECT_TYPE_DEFINITION,
+	    name: name,
+	    directives: directives,
+	    fields: fields,
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * TypeExtensionDefinition : extend ObjectTypeDefinition
+	 */
+	function parseTypeExtensionDefinition(lexer) {
+	  var start = lexer.token;
+	  expectKeyword(lexer, 'extend');
+	  var definition = parseObjectTypeDefinition(lexer);
+	  return {
+	    kind: _kinds.TYPE_EXTENSION_DEFINITION,
+	    definition: definition,
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * DirectiveDefinition :
+	 *   - directive @ Name ArgumentsDefinition? on DirectiveLocations
+	 */
+	function parseDirectiveDefinition(lexer) {
+	  var start = lexer.token;
+	  expectKeyword(lexer, 'directive');
+	  expect(lexer, _lexer.TokenKind.AT);
+	  var name = parseName(lexer);
+	  var args = parseArgumentDefs(lexer);
+	  expectKeyword(lexer, 'on');
+	  var locations = parseDirectiveLocations(lexer);
+	  return {
+	    kind: _kinds.DIRECTIVE_DEFINITION,
+	    name: name,
+	    arguments: args,
+	    locations: locations,
+	    loc: loc(lexer, start)
+	  };
+	}
+
+	/**
+	 * DirectiveLocations :
+	 *   - Name
+	 *   - DirectiveLocations | Name
+	 */
+	function parseDirectiveLocations(lexer) {
+	  var locations = [];
+	  do {
+	    locations.push(parseName(lexer));
+	  } while (skip(lexer, _lexer.TokenKind.PIPE));
+	  return locations;
+	}
+
+	// Core parsing utility functions
+
+	/**
+	 * Returns a location object, used to identify the place in
+	 * the source that created a given parsed object.
+	 */
+	function loc(lexer, startToken) {
+	  if (!lexer.options.noLocation) {
+	    return new Loc(startToken, lexer.lastToken, lexer.source);
+	  }
+	}
+
+	function Loc(startToken, endToken, source) {
+	  this.start = startToken.start;
+	  this.end = endToken.end;
+	  this.startToken = startToken;
+	  this.endToken = endToken;
+	  this.source = source;
+	}
+
+	// Print a simplified form when appearing in JSON/util.inspect.
+	Loc.prototype.toJSON = Loc.prototype.inspect = function toJSON() {
+	  return { start: this.start, end: this.end };
+	};
+
+	/**
+	 * Determines if the next token is of a given kind
+	 */
+	function peek(lexer, kind) {
+	  return lexer.token.kind === kind;
+	}
+
+	/**
+	 * If the next token is of the given kind, return true after advancing
+	 * the lexer. Otherwise, do not change the parser state and return false.
+	 */
+	function skip(lexer, kind) {
+	  var match = lexer.token.kind === kind;
+	  if (match) {
+	    lexer.advance();
+	  }
+	  return match;
+	}
+
+	/**
+	 * If the next token is of the given kind, return that token after advancing
+	 * the lexer. Otherwise, do not change the parser state and throw an error.
+	 */
+	function expect(lexer, kind) {
+	  var token = lexer.token;
+	  if (token.kind === kind) {
+	    lexer.advance();
+	    return token;
+	  }
+	  throw (0, _error.syntaxError)(lexer.source, token.start, 'Expected ' + kind + ', found ' + (0, _lexer.getTokenDesc)(token));
+	}
+
+	/**
+	 * If the next token is a keyword with the given value, return that token after
+	 * advancing the lexer. Otherwise, do not change the parser state and return
+	 * false.
+	 */
+	function expectKeyword(lexer, value) {
+	  var token = lexer.token;
+	  if (token.kind === _lexer.TokenKind.NAME && token.value === value) {
+	    lexer.advance();
+	    return token;
+	  }
+	  throw (0, _error.syntaxError)(lexer.source, token.start, 'Expected "' + value + '", found ' + (0, _lexer.getTokenDesc)(token));
+	}
+
+	/**
+	 * Helper function for creating an error when an unexpected lexed token
+	 * is encountered.
+	 */
+	function unexpected(lexer, atToken) {
+	  var token = atToken || lexer.token;
+	  return (0, _error.syntaxError)(lexer.source, token.start, 'Unexpected ' + (0, _lexer.getTokenDesc)(token));
+	}
+
+	/**
+	 * Returns a possibly empty list of parse nodes, determined by
+	 * the parseFn. This list begins with a lex token of openKind
+	 * and ends with a lex token of closeKind. Advances the parser
+	 * to the next lex token after the closing token.
+	 */
+	function any(lexer, openKind, parseFn, closeKind) {
+	  expect(lexer, openKind);
+	  var nodes = [];
+	  while (!skip(lexer, closeKind)) {
+	    nodes.push(parseFn(lexer));
+	  }
+	  return nodes;
+	}
+
+	/**
+	 * Returns a non-empty list of parse nodes, determined by
+	 * the parseFn. This list begins with a lex token of openKind
+	 * and ends with a lex token of closeKind. Advances the parser
+	 * to the next lex token after the closing token.
+	 */
+	function many(lexer, openKind, parseFn, closeKind) {
+	  expect(lexer, openKind);
+	  var nodes = [parseFn(lexer)];
+	  while (!skip(lexer, closeKind)) {
+	    nodes.push(parseFn(lexer));
+	  }
+	  return nodes;
+	}
+
+/***/ },
+/* 189 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _GraphQLError = __webpack_require__(190);
+
+	Object.defineProperty(exports, 'GraphQLError', {
+	  enumerable: true,
+	  get: function get() {
+	    return _GraphQLError.GraphQLError;
+	  }
+	});
+
+	var _syntaxError = __webpack_require__(197);
+
+	Object.defineProperty(exports, 'syntaxError', {
+	  enumerable: true,
+	  get: function get() {
+	    return _syntaxError.syntaxError;
+	  }
+	});
+
+	var _locatedError = __webpack_require__(198);
+
+	Object.defineProperty(exports, 'locatedError', {
+	  enumerable: true,
+	  get: function get() {
+	    return _locatedError.locatedError;
+	  }
+	});
+
+	var _formatError = __webpack_require__(199);
+
+	Object.defineProperty(exports, 'formatError', {
+	  enumerable: true,
+	  get: function get() {
+	    return _formatError.formatError;
+	  }
+	});
+
+/***/ },
+/* 190 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.GraphQLError = GraphQLError;
+
+	var _language = __webpack_require__(191);
+
+	/**
+	 * A GraphQLError describes an Error found during the parse, validate, or
+	 * execute phases of performing a GraphQL operation. In addition to a message
+	 * and stack trace, it also includes information about the locations in a
+	 * GraphQL document and/or execution result that correspond to the Error.
+	 */
+	function GraphQLError( // eslint-disable-line no-redeclare
+	message, nodes, source, positions, path, originalError) {
+	  // Include (non-enumerable) stack trace.
+	  if (originalError && originalError.stack) {
+	    Object.defineProperty(this, 'stack', {
+	      value: originalError.stack,
+	      writable: true,
+	      configurable: true
+	    });
+	  } else if (Error.captureStackTrace) {
+	    Error.captureStackTrace(this, GraphQLError);
+	  } else {
+	    Object.defineProperty(this, 'stack', {
+	      value: Error().stack,
+	      writable: true,
+	      configurable: true
+	    });
+	  }
+
+	  // Compute locations in the source for the given nodes/positions.
+	  var _source = source;
+	  if (!_source && nodes && nodes.length > 0) {
+	    var node = nodes[0];
+	    _source = node && node.loc && node.loc.source;
+	  }
+
+	  var _positions = positions;
+	  if (!_positions && nodes) {
+	    _positions = nodes.filter(function (node) {
+	      return Boolean(node.loc);
+	    }).map(function (node) {
+	      return node.loc.start;
+	    });
+	  }
+	  if (_positions && _positions.length === 0) {
+	    _positions = undefined;
+	  }
+
+	  var _locations = void 0;
+	  var _source2 = _source; // seems here Flow need a const to resolve type.
+	  if (_source2 && _positions) {
+	    _locations = _positions.map(function (pos) {
+	      return (0, _language.getLocation)(_source2, pos);
+	    });
+	  }
+
+	  Object.defineProperties(this, {
+	    message: {
+	      value: message,
+	      // By being enumerable, JSON.stringify will include `message` in the
+	      // resulting output. This ensures that the simplist possible GraphQL
+	      // service adheres to the spec.
+	      enumerable: true,
+	      writable: true
+	    },
+	    locations: {
+	      // Coercing falsey values to undefined ensures they will not be included
+	      // in JSON.stringify() when not provided.
+	      value: _locations || undefined,
+	      // By being enumerable, JSON.stringify will include `locations` in the
+	      // resulting output. This ensures that the simplist possible GraphQL
+	      // service adheres to the spec.
+	      enumerable: true
+	    },
+	    path: {
+	      // Coercing falsey values to undefined ensures they will not be included
+	      // in JSON.stringify() when not provided.
+	      value: path || undefined,
+	      // By being enumerable, JSON.stringify will include `path` in the
+	      // resulting output. This ensures that the simplist possible GraphQL
+	      // service adheres to the spec.
+	      enumerable: true
+	    },
+	    nodes: {
+	      value: nodes || undefined
+	    },
+	    source: {
+	      value: _source || undefined
+	    },
+	    positions: {
+	      value: _positions || undefined
+	    },
+	    originalError: {
+	      value: originalError
+	    }
+	  });
+	}
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	GraphQLError.prototype = Object.create(Error.prototype, {
+	  constructor: { value: GraphQLError },
+	  name: { value: 'GraphQLError' }
+	});
+
+/***/ },
+/* 191 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.BREAK = exports.visitWithTypeInfo = exports.visitInParallel = exports.visit = exports.Source = exports.print = exports.parseType = exports.parseValue = exports.parse = exports.TokenKind = exports.createLexer = exports.Kind = exports.getLocation = undefined;
+
+	var _location = __webpack_require__(192);
+
+	Object.defineProperty(exports, 'getLocation', {
+	  enumerable: true,
+	  get: function get() {
+	    return _location.getLocation;
+	  }
+	});
+
+	var _lexer = __webpack_require__(193);
+
+	Object.defineProperty(exports, 'createLexer', {
+	  enumerable: true,
+	  get: function get() {
+	    return _lexer.createLexer;
+	  }
+	});
+	Object.defineProperty(exports, 'TokenKind', {
+	  enumerable: true,
+	  get: function get() {
+	    return _lexer.TokenKind;
+	  }
+	});
+
+	var _parser = __webpack_require__(188);
+
+	Object.defineProperty(exports, 'parse', {
+	  enumerable: true,
+	  get: function get() {
+	    return _parser.parse;
+	  }
+	});
+	Object.defineProperty(exports, 'parseValue', {
+	  enumerable: true,
+	  get: function get() {
+	    return _parser.parseValue;
+	  }
+	});
+	Object.defineProperty(exports, 'parseType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _parser.parseType;
+	  }
+	});
+
+	var _printer = __webpack_require__(194);
+
+	Object.defineProperty(exports, 'print', {
+	  enumerable: true,
+	  get: function get() {
+	    return _printer.print;
+	  }
+	});
+
+	var _source = __webpack_require__(187);
+
+	Object.defineProperty(exports, 'Source', {
+	  enumerable: true,
+	  get: function get() {
+	    return _source.Source;
+	  }
+	});
+
+	var _visitor = __webpack_require__(195);
+
+	Object.defineProperty(exports, 'visit', {
+	  enumerable: true,
+	  get: function get() {
+	    return _visitor.visit;
+	  }
+	});
+	Object.defineProperty(exports, 'visitInParallel', {
+	  enumerable: true,
+	  get: function get() {
+	    return _visitor.visitInParallel;
+	  }
+	});
+	Object.defineProperty(exports, 'visitWithTypeInfo', {
+	  enumerable: true,
+	  get: function get() {
+	    return _visitor.visitWithTypeInfo;
+	  }
+	});
+	Object.defineProperty(exports, 'BREAK', {
+	  enumerable: true,
+	  get: function get() {
+	    return _visitor.BREAK;
+	  }
+	});
+
+	var _kinds = __webpack_require__(196);
+
+	var Kind = _interopRequireWildcard(_kinds);
+
+	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+	exports.Kind = Kind;
+
+/***/ },
+/* 192 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.getLocation = getLocation;
+
+
+	/**
+	 * Takes a Source and a UTF-8 character offset, and returns the corresponding
+	 * line and column as a SourceLocation.
+	 */
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function getLocation(source, position) {
+	  var lineRegexp = /\r\n|[\n\r]/g;
+	  var line = 1;
+	  var column = position + 1;
+	  var match = void 0;
+	  while ((match = lineRegexp.exec(source.body)) && match.index < position) {
+	    line += 1;
+	    column = position + 1 - (match.index + match[0].length);
+	  }
+	  return { line: line, column: column };
+	}
+
+	/**
+	 * Represents a location in a Source.
+	 */
+
+/***/ },
+/* 193 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.TokenKind = undefined;
+	exports.createLexer = createLexer;
+	exports.getTokenDesc = getTokenDesc;
+
+	var _error = __webpack_require__(189);
+
+	/**
+	 * Given a Source object, this returns a Lexer for that source.
+	 * A Lexer is a stateful stream generator in that every time
+	 * it is advanced, it returns the next token in the Source. Assuming the
+	 * source lexes, the final Token emitted by the lexer will be of kind
+	 * EOF, after which the lexer will repeatedly return the same EOF token
+	 * whenever called.
+	 */
+	function createLexer(source, options) {
+	  var startOfFileToken = new Tok(SOF, 0, 0, 0, 0, null);
+	  var lexer = {
+	    source: source,
+	    options: options,
+	    lastToken: startOfFileToken,
+	    token: startOfFileToken,
+	    line: 1,
+	    lineStart: 0,
+	    advance: advanceLexer
+	  };
+	  return lexer;
+	} /*  /
+	  /**
+	   *  Copyright (c) 2015, Facebook, Inc.
+	   *  All rights reserved.
+	   *
+	   *  This source code is licensed under the BSD-style license found in the
+	   *  LICENSE file in the root directory of this source tree. An additional grant
+	   *  of patent rights can be found in the PATENTS file in the same directory.
+	   */
+
+	function advanceLexer() {
+	  var token = this.lastToken = this.token;
+	  if (token.kind !== EOF) {
+	    do {
+	      token = token.next = readToken(this, token);
+	    } while (token.kind === COMMENT);
+	    this.token = token;
+	  }
+	  return token;
+	}
+
+	/**
+	 * The return type of createLexer.
+	 */
+
+
+	// Each kind of token.
+	var SOF = '<SOF>';
+	var EOF = '<EOF>';
+	var BANG = '!';
+	var DOLLAR = '$';
+	var PAREN_L = '(';
+	var PAREN_R = ')';
+	var SPREAD = '...';
+	var COLON = ':';
+	var EQUALS = '=';
+	var AT = '@';
+	var BRACKET_L = '[';
+	var BRACKET_R = ']';
+	var BRACE_L = '{';
+	var PIPE = '|';
+	var BRACE_R = '}';
+	var NAME = 'Name';
+	var INT = 'Int';
+	var FLOAT = 'Float';
+	var STRING = 'String';
+	var COMMENT = 'Comment';
+
+	/**
+	 * An exported enum describing the different kinds of tokens that the
+	 * lexer emits.
+	 */
+	var TokenKind = exports.TokenKind = {
+	  SOF: SOF,
+	  EOF: EOF,
+	  BANG: BANG,
+	  DOLLAR: DOLLAR,
+	  PAREN_L: PAREN_L,
+	  PAREN_R: PAREN_R,
+	  SPREAD: SPREAD,
+	  COLON: COLON,
+	  EQUALS: EQUALS,
+	  AT: AT,
+	  BRACKET_L: BRACKET_L,
+	  BRACKET_R: BRACKET_R,
+	  BRACE_L: BRACE_L,
+	  PIPE: PIPE,
+	  BRACE_R: BRACE_R,
+	  NAME: NAME,
+	  INT: INT,
+	  FLOAT: FLOAT,
+	  STRING: STRING,
+	  COMMENT: COMMENT
+	};
+
+	/**
+	 * A helper function to describe a token as a string for debugging
+	 */
+	function getTokenDesc(token) {
+	  var value = token.value;
+	  return value ? token.kind + ' "' + value + '"' : token.kind;
+	}
+
+	var charCodeAt = String.prototype.charCodeAt;
+	var slice = String.prototype.slice;
+
+	/**
+	 * Helper function for constructing the Token object.
+	 */
+	function Tok(kind, start, end, line, column, prev, value) {
+	  this.kind = kind;
+	  this.start = start;
+	  this.end = end;
+	  this.line = line;
+	  this.column = column;
+	  this.value = value;
+	  this.prev = prev;
+	  this.next = null;
+	}
+
+	// Print a simplified form when appearing in JSON/util.inspect.
+	Tok.prototype.toJSON = Tok.prototype.inspect = function toJSON() {
+	  return {
+	    kind: this.kind,
+	    value: this.value,
+	    line: this.line,
+	    column: this.column
+	  };
+	};
+
+	function printCharCode(code) {
+	  return (
+	    // NaN/undefined represents access beyond the end of the file.
+	    isNaN(code) ? EOF :
+	    // Trust JSON for ASCII.
+	    code < 0x007F ? JSON.stringify(String.fromCharCode(code)) :
+	    // Otherwise print the escaped form.
+	    '"\\u' + ('00' + code.toString(16).toUpperCase()).slice(-4) + '"'
+	  );
+	}
+
+	/**
+	 * Gets the next token from the source starting at the given position.
+	 *
+	 * This skips over whitespace and comments until it finds the next lexable
+	 * token, then lexes punctuators immediately or calls the appropriate helper
+	 * function for more complicated tokens.
+	 */
+	function readToken(lexer, prev) {
+	  var source = lexer.source;
+	  var body = source.body;
+	  var bodyLength = body.length;
+
+	  var position = positionAfterWhitespace(body, prev.end, lexer);
+	  var line = lexer.line;
+	  var col = 1 + position - lexer.lineStart;
+
+	  if (position >= bodyLength) {
+	    return new Tok(EOF, bodyLength, bodyLength, line, col, prev);
+	  }
+
+	  var code = charCodeAt.call(body, position);
+
+	  // SourceCharacter
+	  if (code < 0x0020 && code !== 0x0009 && code !== 0x000A && code !== 0x000D) {
+	    throw (0, _error.syntaxError)(source, position, 'Invalid character ' + printCharCode(code) + '.');
+	  }
+
+	  switch (code) {
+	    // !
+	    case 33:
+	      return new Tok(BANG, position, position + 1, line, col, prev);
+	    // #
+	    case 35:
+	      return readComment(source, position, line, col, prev);
+	    // $
+	    case 36:
+	      return new Tok(DOLLAR, position, position + 1, line, col, prev);
+	    // (
+	    case 40:
+	      return new Tok(PAREN_L, position, position + 1, line, col, prev);
+	    // )
+	    case 41:
+	      return new Tok(PAREN_R, position, position + 1, line, col, prev);
+	    // .
+	    case 46:
+	      if (charCodeAt.call(body, position + 1) === 46 && charCodeAt.call(body, position + 2) === 46) {
+	        return new Tok(SPREAD, position, position + 3, line, col, prev);
+	      }
+	      break;
+	    // :
+	    case 58:
+	      return new Tok(COLON, position, position + 1, line, col, prev);
+	    // =
+	    case 61:
+	      return new Tok(EQUALS, position, position + 1, line, col, prev);
+	    // @
+	    case 64:
+	      return new Tok(AT, position, position + 1, line, col, prev);
+	    // [
+	    case 91:
+	      return new Tok(BRACKET_L, position, position + 1, line, col, prev);
+	    // ]
+	    case 93:
+	      return new Tok(BRACKET_R, position, position + 1, line, col, prev);
+	    // {
+	    case 123:
+	      return new Tok(BRACE_L, position, position + 1, line, col, prev);
+	    // |
+	    case 124:
+	      return new Tok(PIPE, position, position + 1, line, col, prev);
+	    // }
+	    case 125:
+	      return new Tok(BRACE_R, position, position + 1, line, col, prev);
+	    // A-Z _ a-z
+	    case 65:case 66:case 67:case 68:case 69:case 70:case 71:case 72:
+	    case 73:case 74:case 75:case 76:case 77:case 78:case 79:case 80:
+	    case 81:case 82:case 83:case 84:case 85:case 86:case 87:case 88:
+	    case 89:case 90:
+	    case 95:
+	    case 97:case 98:case 99:case 100:case 101:case 102:case 103:case 104:
+	    case 105:case 106:case 107:case 108:case 109:case 110:case 111:
+	    case 112:case 113:case 114:case 115:case 116:case 117:case 118:
+	    case 119:case 120:case 121:case 122:
+	      return readName(source, position, line, col, prev);
+	    // - 0-9
+	    case 45:
+	    case 48:case 49:case 50:case 51:case 52:
+	    case 53:case 54:case 55:case 56:case 57:
+	      return readNumber(source, position, code, line, col, prev);
+	    // "
+	    case 34:
+	      return readString(source, position, line, col, prev);
+	  }
+
+	  throw (0, _error.syntaxError)(source, position, 'Unexpected character ' + printCharCode(code) + '.');
+	}
+
+	/**
+	 * Reads from body starting at startPosition until it finds a non-whitespace
+	 * or commented character, then returns the position of that character for
+	 * lexing.
+	 */
+	function positionAfterWhitespace(body, startPosition, lexer) {
+	  var bodyLength = body.length;
+	  var position = startPosition;
+	  while (position < bodyLength) {
+	    var code = charCodeAt.call(body, position);
+	    // tab | space | comma | BOM
+	    if (code === 9 || code === 32 || code === 44 || code === 0xFEFF) {
+	      ++position;
+	    } else if (code === 10) {
+	      // new line
+	      ++position;
+	      ++lexer.line;
+	      lexer.lineStart = position;
+	    } else if (code === 13) {
+	      // carriage return
+	      if (charCodeAt.call(body, position + 1) === 10) {
+	        position += 2;
+	      } else {
+	        ++position;
+	      }
+	      ++lexer.line;
+	      lexer.lineStart = position;
+	    } else {
+	      break;
+	    }
+	  }
+	  return position;
+	}
+
+	/**
+	 * Reads a comment token from the source file.
+	 *
+	 * #[\u0009\u0020-\uFFFF]*
+	 */
+	function readComment(source, start, line, col, prev) {
+	  var body = source.body;
+	  var code = void 0;
+	  var position = start;
+
+	  do {
+	    code = charCodeAt.call(body, ++position);
+	  } while (code !== null && (
+	  // SourceCharacter but not LineTerminator
+	  code > 0x001F || code === 0x0009));
+
+	  return new Tok(COMMENT, start, position, line, col, prev, slice.call(body, start + 1, position));
+	}
+
+	/**
+	 * Reads a number token from the source file, either a float
+	 * or an int depending on whether a decimal point appears.
+	 *
+	 * Int:   -?(0|[1-9][0-9]*)
+	 * Float: -?(0|[1-9][0-9]*)(\.[0-9]+)?((E|e)(+|-)?[0-9]+)?
+	 */
+	function readNumber(source, start, firstCode, line, col, prev) {
+	  var body = source.body;
+	  var code = firstCode;
+	  var position = start;
+	  var isFloat = false;
+
+	  if (code === 45) {
+	    // -
+	    code = charCodeAt.call(body, ++position);
+	  }
+
+	  if (code === 48) {
+	    // 0
+	    code = charCodeAt.call(body, ++position);
+	    if (code >= 48 && code <= 57) {
+	      throw (0, _error.syntaxError)(source, position, 'Invalid number, unexpected digit after 0: ' + printCharCode(code) + '.');
+	    }
+	  } else {
+	    position = readDigits(source, position, code);
+	    code = charCodeAt.call(body, position);
+	  }
+
+	  if (code === 46) {
+	    // .
+	    isFloat = true;
+
+	    code = charCodeAt.call(body, ++position);
+	    position = readDigits(source, position, code);
+	    code = charCodeAt.call(body, position);
+	  }
+
+	  if (code === 69 || code === 101) {
+	    // E e
+	    isFloat = true;
+
+	    code = charCodeAt.call(body, ++position);
+	    if (code === 43 || code === 45) {
+	      // + -
+	      code = charCodeAt.call(body, ++position);
+	    }
+	    position = readDigits(source, position, code);
+	  }
+
+	  return new Tok(isFloat ? FLOAT : INT, start, position, line, col, prev, slice.call(body, start, position));
+	}
+
+	/**
+	 * Returns the new position in the source after reading digits.
+	 */
+	function readDigits(source, start, firstCode) {
+	  var body = source.body;
+	  var position = start;
+	  var code = firstCode;
+	  if (code >= 48 && code <= 57) {
+	    // 0 - 9
+	    do {
+	      code = charCodeAt.call(body, ++position);
+	    } while (code >= 48 && code <= 57); // 0 - 9
+	    return position;
+	  }
+	  throw (0, _error.syntaxError)(source, position, 'Invalid number, expected digit but got: ' + printCharCode(code) + '.');
+	}
+
+	/**
+	 * Reads a string token from the source file.
+	 *
+	 * "([^"\\\u000A\u000D]|(\\(u[0-9a-fA-F]{4}|["\\/bfnrt])))*"
+	 */
+	function readString(source, start, line, col, prev) {
+	  var body = source.body;
+	  var position = start + 1;
+	  var chunkStart = position;
+	  var code = 0;
+	  var value = '';
+
+	  while (position < body.length && (code = charCodeAt.call(body, position)) !== null &&
+	  // not LineTerminator
+	  code !== 0x000A && code !== 0x000D &&
+	  // not Quote (")
+	  code !== 34) {
+	    // SourceCharacter
+	    if (code < 0x0020 && code !== 0x0009) {
+	      throw (0, _error.syntaxError)(source, position, 'Invalid character within String: ' + printCharCode(code) + '.');
+	    }
+
+	    ++position;
+	    if (code === 92) {
+	      // \
+	      value += slice.call(body, chunkStart, position - 1);
+	      code = charCodeAt.call(body, position);
+	      switch (code) {
+	        case 34:
+	          value += '"';break;
+	        case 47:
+	          value += '\/';break;
+	        case 92:
+	          value += '\\';break;
+	        case 98:
+	          value += '\b';break;
+	        case 102:
+	          value += '\f';break;
+	        case 110:
+	          value += '\n';break;
+	        case 114:
+	          value += '\r';break;
+	        case 116:
+	          value += '\t';break;
+	        case 117:
+	          // u
+	          var charCode = uniCharCode(charCodeAt.call(body, position + 1), charCodeAt.call(body, position + 2), charCodeAt.call(body, position + 3), charCodeAt.call(body, position + 4));
+	          if (charCode < 0) {
+	            throw (0, _error.syntaxError)(source, position, 'Invalid character escape sequence: ' + ('\\u' + body.slice(position + 1, position + 5) + '.'));
+	          }
+	          value += String.fromCharCode(charCode);
+	          position += 4;
+	          break;
+	        default:
+	          throw (0, _error.syntaxError)(source, position, 'Invalid character escape sequence: \\' + String.fromCharCode(code) + '.');
+	      }
+	      ++position;
+	      chunkStart = position;
+	    }
+	  }
+
+	  if (code !== 34) {
+	    // quote (")
+	    throw (0, _error.syntaxError)(source, position, 'Unterminated string.');
+	  }
+
+	  value += slice.call(body, chunkStart, position);
+	  return new Tok(STRING, start, position + 1, line, col, prev, value);
+	}
+
+	/**
+	 * Converts four hexidecimal chars to the integer that the
+	 * string represents. For example, uniCharCode('0','0','0','f')
+	 * will return 15, and uniCharCode('0','0','f','f') returns 255.
+	 *
+	 * Returns a negative number on error, if a char was invalid.
+	 *
+	 * This is implemented by noting that char2hex() returns -1 on error,
+	 * which means the result of ORing the char2hex() will also be negative.
+	 */
+	function uniCharCode(a, b, c, d) {
+	  return char2hex(a) << 12 | char2hex(b) << 8 | char2hex(c) << 4 | char2hex(d);
+	}
+
+	/**
+	 * Converts a hex character to its integer value.
+	 * '0' becomes 0, '9' becomes 9
+	 * 'A' becomes 10, 'F' becomes 15
+	 * 'a' becomes 10, 'f' becomes 15
+	 *
+	 * Returns -1 on error.
+	 */
+	function char2hex(a) {
+	  return a >= 48 && a <= 57 ? a - 48 : // 0-9
+	  a >= 65 && a <= 70 ? a - 55 : // A-F
+	  a >= 97 && a <= 102 ? a - 87 : // a-f
+	  -1;
+	}
+
+	/**
+	 * Reads an alphanumeric + underscore name from the source.
+	 *
+	 * [_A-Za-z][_0-9A-Za-z]*
+	 */
+	function readName(source, position, line, col, prev) {
+	  var body = source.body;
+	  var bodyLength = body.length;
+	  var end = position + 1;
+	  var code = 0;
+	  while (end !== bodyLength && (code = charCodeAt.call(body, end)) !== null && (code === 95 || // _
+	  code >= 48 && code <= 57 || // 0-9
+	  code >= 65 && code <= 90 || // A-Z
+	  code >= 97 && code <= 122 // a-z
+	  )) {
+	    ++end;
+	  }
+	  return new Tok(NAME, position, end, line, col, prev, slice.call(body, position, end));
+	}
+
+/***/ },
+/* 194 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.print = print;
+
+	var _visitor = __webpack_require__(195);
+
+	/**
+	 * Converts an AST into a string, using one set of reasonable
+	 * formatting rules.
+	 */
+	function print(ast) {
+	  return (0, _visitor.visit)(ast, { leave: printDocASTReducer });
+	} /**
+	   *  Copyright (c) 2015, Facebook, Inc.
+	   *  All rights reserved.
+	   *
+	   *  This source code is licensed under the BSD-style license found in the
+	   *  LICENSE file in the root directory of this source tree. An additional grant
+	   *  of patent rights can be found in the PATENTS file in the same directory.
+	   */
+
+	var printDocASTReducer = {
+	  Name: function Name(node) {
+	    return node.value;
+	  },
+	  Variable: function Variable(node) {
+	    return '$' + node.name;
+	  },
+
+	  // Document
+
+	  Document: function Document(node) {
+	    return join(node.definitions, '\n\n') + '\n';
+	  },
+
+	  OperationDefinition: function OperationDefinition(node) {
+	    var op = node.operation;
+	    var name = node.name;
+	    var varDefs = wrap('(', join(node.variableDefinitions, ', '), ')');
+	    var directives = join(node.directives, ' ');
+	    var selectionSet = node.selectionSet;
+	    // Anonymous queries with no directives or variable definitions can use
+	    // the query short form.
+	    return !name && !directives && !varDefs && op === 'query' ? selectionSet : join([op, join([name, varDefs]), directives, selectionSet], ' ');
+	  },
+
+
+	  VariableDefinition: function VariableDefinition(_ref) {
+	    var variable = _ref.variable;
+	    var type = _ref.type;
+	    var defaultValue = _ref.defaultValue;
+	    return variable + ': ' + type + wrap(' = ', defaultValue);
+	  },
+
+	  SelectionSet: function SelectionSet(_ref2) {
+	    var selections = _ref2.selections;
+	    return block(selections);
+	  },
+
+	  Field: function Field(_ref3) {
+	    var alias = _ref3.alias;
+	    var name = _ref3.name;
+	    var args = _ref3.arguments;
+	    var directives = _ref3.directives;
+	    var selectionSet = _ref3.selectionSet;
+	    return join([wrap('', alias, ': ') + name + wrap('(', join(args, ', '), ')'), join(directives, ' '), selectionSet], ' ');
+	  },
+
+	  Argument: function Argument(_ref4) {
+	    var name = _ref4.name;
+	    var value = _ref4.value;
+	    return name + ': ' + value;
+	  },
+
+	  // Fragments
+
+	  FragmentSpread: function FragmentSpread(_ref5) {
+	    var name = _ref5.name;
+	    var directives = _ref5.directives;
+	    return '...' + name + wrap(' ', join(directives, ' '));
+	  },
+
+	  InlineFragment: function InlineFragment(_ref6) {
+	    var typeCondition = _ref6.typeCondition;
+	    var directives = _ref6.directives;
+	    var selectionSet = _ref6.selectionSet;
+	    return join(['...', wrap('on ', typeCondition), join(directives, ' '), selectionSet], ' ');
+	  },
+
+	  FragmentDefinition: function FragmentDefinition(_ref7) {
+	    var name = _ref7.name;
+	    var typeCondition = _ref7.typeCondition;
+	    var directives = _ref7.directives;
+	    var selectionSet = _ref7.selectionSet;
+	    return 'fragment ' + name + ' on ' + typeCondition + ' ' + wrap('', join(directives, ' '), ' ') + selectionSet;
+	  },
+
+	  // Value
+
+	  IntValue: function IntValue(_ref8) {
+	    var value = _ref8.value;
+	    return value;
+	  },
+	  FloatValue: function FloatValue(_ref9) {
+	    var value = _ref9.value;
+	    return value;
+	  },
+	  StringValue: function StringValue(_ref10) {
+	    var value = _ref10.value;
+	    return JSON.stringify(value);
+	  },
+	  BooleanValue: function BooleanValue(_ref11) {
+	    var value = _ref11.value;
+	    return JSON.stringify(value);
+	  },
+	  EnumValue: function EnumValue(_ref12) {
+	    var value = _ref12.value;
+	    return value;
+	  },
+	  ListValue: function ListValue(_ref13) {
+	    var values = _ref13.values;
+	    return '[' + join(values, ', ') + ']';
+	  },
+	  ObjectValue: function ObjectValue(_ref14) {
+	    var fields = _ref14.fields;
+	    return '{' + join(fields, ', ') + '}';
+	  },
+	  ObjectField: function ObjectField(_ref15) {
+	    var name = _ref15.name;
+	    var value = _ref15.value;
+	    return name + ': ' + value;
+	  },
+
+	  // Directive
+
+	  Directive: function Directive(_ref16) {
+	    var name = _ref16.name;
+	    var args = _ref16.arguments;
+	    return '@' + name + wrap('(', join(args, ', '), ')');
+	  },
+
+	  // Type
+
+	  NamedType: function NamedType(_ref17) {
+	    var name = _ref17.name;
+	    return name;
+	  },
+	  ListType: function ListType(_ref18) {
+	    var type = _ref18.type;
+	    return '[' + type + ']';
+	  },
+	  NonNullType: function NonNullType(_ref19) {
+	    var type = _ref19.type;
+	    return type + '!';
+	  },
+
+	  // Type System Definitions
+
+	  SchemaDefinition: function SchemaDefinition(_ref20) {
+	    var directives = _ref20.directives;
+	    var operationTypes = _ref20.operationTypes;
+	    return join(['schema', join(directives, ' '), block(operationTypes)], ' ');
+	  },
+
+	  OperationTypeDefinition: function OperationTypeDefinition(_ref21) {
+	    var operation = _ref21.operation;
+	    var type = _ref21.type;
+	    return operation + ': ' + type;
+	  },
+
+	  ScalarTypeDefinition: function ScalarTypeDefinition(_ref22) {
+	    var name = _ref22.name;
+	    var directives = _ref22.directives;
+	    return join(['scalar', name, join(directives, ' ')], ' ');
+	  },
+
+	  ObjectTypeDefinition: function ObjectTypeDefinition(_ref23) {
+	    var name = _ref23.name;
+	    var interfaces = _ref23.interfaces;
+	    var directives = _ref23.directives;
+	    var fields = _ref23.fields;
+	    return join(['type', name, wrap('implements ', join(interfaces, ', ')), join(directives, ' '), block(fields)], ' ');
+	  },
+
+	  FieldDefinition: function FieldDefinition(_ref24) {
+	    var name = _ref24.name;
+	    var args = _ref24.arguments;
+	    var type = _ref24.type;
+	    var directives = _ref24.directives;
+	    return name + wrap('(', join(args, ', '), ')') + ': ' + type + wrap(' ', join(directives, ' '));
+	  },
+
+	  InputValueDefinition: function InputValueDefinition(_ref25) {
+	    var name = _ref25.name;
+	    var type = _ref25.type;
+	    var defaultValue = _ref25.defaultValue;
+	    var directives = _ref25.directives;
+	    return join([name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')], ' ');
+	  },
+
+	  InterfaceTypeDefinition: function InterfaceTypeDefinition(_ref26) {
+	    var name = _ref26.name;
+	    var directives = _ref26.directives;
+	    var fields = _ref26.fields;
+	    return join(['interface', name, join(directives, ' '), block(fields)], ' ');
+	  },
+
+	  UnionTypeDefinition: function UnionTypeDefinition(_ref27) {
+	    var name = _ref27.name;
+	    var directives = _ref27.directives;
+	    var types = _ref27.types;
+	    return join(['union', name, join(directives, ' '), '= ' + join(types, ' | ')], ' ');
+	  },
+
+	  EnumTypeDefinition: function EnumTypeDefinition(_ref28) {
+	    var name = _ref28.name;
+	    var directives = _ref28.directives;
+	    var values = _ref28.values;
+	    return join(['enum', name, join(directives, ' '), block(values)], ' ');
+	  },
+
+	  EnumValueDefinition: function EnumValueDefinition(_ref29) {
+	    var name = _ref29.name;
+	    var directives = _ref29.directives;
+	    return join([name, join(directives, ' ')], ' ');
+	  },
+
+	  InputObjectTypeDefinition: function InputObjectTypeDefinition(_ref30) {
+	    var name = _ref30.name;
+	    var directives = _ref30.directives;
+	    var fields = _ref30.fields;
+	    return join(['input', name, join(directives, ' '), block(fields)], ' ');
+	  },
+
+	  TypeExtensionDefinition: function TypeExtensionDefinition(_ref31) {
+	    var definition = _ref31.definition;
+	    return 'extend ' + definition;
+	  },
+
+	  DirectiveDefinition: function DirectiveDefinition(_ref32) {
+	    var name = _ref32.name;
+	    var args = _ref32.arguments;
+	    var locations = _ref32.locations;
+	    return 'directive @' + name + wrap('(', join(args, ', '), ')') + ' on ' + join(locations, ' | ');
+	  }
+	};
+
+	/**
+	 * Given maybeArray, print an empty string if it is null or empty, otherwise
+	 * print all items together separated by separator if provided
+	 */
+	function join(maybeArray, separator) {
+	  return maybeArray ? maybeArray.filter(function (x) {
+	    return x;
+	  }).join(separator || '') : '';
+	}
+
+	/**
+	 * Given array, print each item on its own line, wrapped in an
+	 * indented "{ }" block.
+	 */
+	function block(array) {
+	  return array && array.length !== 0 ? indent('{\n' + join(array, '\n')) + '\n}' : '{}';
+	}
+
+	/**
+	 * If maybeString is not null or empty, then wrap with start and end, otherwise
+	 * print an empty string.
+	 */
+	function wrap(start, maybeString, end) {
+	  return maybeString ? start + maybeString + (end || '') : '';
+	}
+
+	function indent(maybeString) {
+	  return maybeString && maybeString.replace(/\n/g, '\n  ');
+	}
+
+/***/ },
+/* 195 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.visit = visit;
+	exports.visitInParallel = visitInParallel;
+	exports.visitWithTypeInfo = visitWithTypeInfo;
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	var QueryDocumentKeys = exports.QueryDocumentKeys = {
+	  Name: [],
+
+	  Document: ['definitions'],
+	  OperationDefinition: ['name', 'variableDefinitions', 'directives', 'selectionSet'],
+	  VariableDefinition: ['variable', 'type', 'defaultValue'],
+	  Variable: ['name'],
+	  SelectionSet: ['selections'],
+	  Field: ['alias', 'name', 'arguments', 'directives', 'selectionSet'],
+	  Argument: ['name', 'value'],
+
+	  FragmentSpread: ['name', 'directives'],
+	  InlineFragment: ['typeCondition', 'directives', 'selectionSet'],
+	  FragmentDefinition: ['name', 'typeCondition', 'directives', 'selectionSet'],
+
+	  IntValue: [],
+	  FloatValue: [],
+	  StringValue: [],
+	  BooleanValue: [],
+	  EnumValue: [],
+	  ListValue: ['values'],
+	  ObjectValue: ['fields'],
+	  ObjectField: ['name', 'value'],
+
+	  Directive: ['name', 'arguments'],
+
+	  NamedType: ['name'],
+	  ListType: ['type'],
+	  NonNullType: ['type'],
+
+	  SchemaDefinition: ['directives', 'operationTypes'],
+	  OperationTypeDefinition: ['type'],
+
+	  ScalarTypeDefinition: ['name', 'directives'],
+	  ObjectTypeDefinition: ['name', 'interfaces', 'directives', 'fields'],
+	  FieldDefinition: ['name', 'arguments', 'type', 'directives'],
+	  InputValueDefinition: ['name', 'type', 'defaultValue', 'directives'],
+	  InterfaceTypeDefinition: ['name', 'directives', 'fields'],
+	  UnionTypeDefinition: ['name', 'directives', 'types'],
+	  EnumTypeDefinition: ['name', 'directives', 'values'],
+	  EnumValueDefinition: ['name', 'directives'],
+	  InputObjectTypeDefinition: ['name', 'directives', 'fields'],
+
+	  TypeExtensionDefinition: ['definition'],
+
+	  DirectiveDefinition: ['name', 'arguments', 'locations']
+	};
+
+	var BREAK = exports.BREAK = {};
+
+	/**
+	 * visit() will walk through an AST using a depth first traversal, calling
+	 * the visitor's enter function at each node in the traversal, and calling the
+	 * leave function after visiting that node and all of its child nodes.
+	 *
+	 * By returning different values from the enter and leave functions, the
+	 * behavior of the visitor can be altered, including skipping over a sub-tree of
+	 * the AST (by returning false), editing the AST by returning a value or null
+	 * to remove the value, or to stop the whole traversal by returning BREAK.
+	 *
+	 * When using visit() to edit an AST, the original AST will not be modified, and
+	 * a new version of the AST with the changes applied will be returned from the
+	 * visit function.
+	 *
+	 *     const editedAST = visit(ast, {
+	 *       enter(node, key, parent, path, ancestors) {
+	 *         // @return
+	 *         //   undefined: no action
+	 *         //   false: skip visiting this node
+	 *         //   visitor.BREAK: stop visiting altogether
+	 *         //   null: delete this node
+	 *         //   any value: replace this node with the returned value
+	 *       },
+	 *       leave(node, key, parent, path, ancestors) {
+	 *         // @return
+	 *         //   undefined: no action
+	 *         //   false: no action
+	 *         //   visitor.BREAK: stop visiting altogether
+	 *         //   null: delete this node
+	 *         //   any value: replace this node with the returned value
+	 *       }
+	 *     });
+	 *
+	 * Alternatively to providing enter() and leave() functions, a visitor can
+	 * instead provide functions named the same as the kinds of AST nodes, or
+	 * enter/leave visitors at a named key, leading to four permutations of
+	 * visitor API:
+	 *
+	 * 1) Named visitors triggered when entering a node a specific kind.
+	 *
+	 *     visit(ast, {
+	 *       Kind(node) {
+	 *         // enter the "Kind" node
+	 *       }
+	 *     })
+	 *
+	 * 2) Named visitors that trigger upon entering and leaving a node of
+	 *    a specific kind.
+	 *
+	 *     visit(ast, {
+	 *       Kind: {
+	 *         enter(node) {
+	 *           // enter the "Kind" node
+	 *         }
+	 *         leave(node) {
+	 *           // leave the "Kind" node
+	 *         }
+	 *       }
+	 *     })
+	 *
+	 * 3) Generic visitors that trigger upon entering and leaving any node.
+	 *
+	 *     visit(ast, {
+	 *       enter(node) {
+	 *         // enter any node
+	 *       },
+	 *       leave(node) {
+	 *         // leave any node
+	 *       }
+	 *     })
+	 *
+	 * 4) Parallel visitors for entering and leaving nodes of a specific kind.
+	 *
+	 *     visit(ast, {
+	 *       enter: {
+	 *         Kind(node) {
+	 *           // enter the "Kind" node
+	 *         }
+	 *       },
+	 *       leave: {
+	 *         Kind(node) {
+	 *           // leave the "Kind" node
+	 *         }
+	 *       }
+	 *     })
+	 */
+	function visit(root, visitor, keyMap) {
+	  var visitorKeys = keyMap || QueryDocumentKeys;
+
+	  var stack = void 0;
+	  var inArray = Array.isArray(root);
+	  var keys = [root];
+	  var index = -1;
+	  var edits = [];
+	  var parent = void 0;
+	  var path = [];
+	  var ancestors = [];
+	  var newRoot = root;
+
+	  do {
+	    index++;
+	    var isLeaving = index === keys.length;
+	    var key = void 0;
+	    var node = void 0;
+	    var isEdited = isLeaving && edits.length !== 0;
+	    if (isLeaving) {
+	      key = ancestors.length === 0 ? undefined : path.pop();
+	      node = parent;
+	      parent = ancestors.pop();
+	      if (isEdited) {
+	        if (inArray) {
+	          node = node.slice();
+	        } else {
+	          var clone = {};
+	          for (var k in node) {
+	            if (node.hasOwnProperty(k)) {
+	              clone[k] = node[k];
+	            }
+	          }
+	          node = clone;
+	        }
+	        var editOffset = 0;
+	        for (var ii = 0; ii < edits.length; ii++) {
+	          var editKey = edits[ii][0];
+	          var editValue = edits[ii][1];
+	          if (inArray) {
+	            editKey -= editOffset;
+	          }
+	          if (inArray && editValue === null) {
+	            node.splice(editKey, 1);
+	            editOffset++;
+	          } else {
+	            node[editKey] = editValue;
+	          }
+	        }
+	      }
+	      index = stack.index;
+	      keys = stack.keys;
+	      edits = stack.edits;
+	      inArray = stack.inArray;
+	      stack = stack.prev;
+	    } else {
+	      key = parent ? inArray ? index : keys[index] : undefined;
+	      node = parent ? parent[key] : newRoot;
+	      if (node === null || node === undefined) {
+	        continue;
+	      }
+	      if (parent) {
+	        path.push(key);
+	      }
+	    }
+
+	    var result = void 0;
+	    if (!Array.isArray(node)) {
+	      if (!isNode(node)) {
+	        throw new Error('Invalid AST Node: ' + JSON.stringify(node));
+	      }
+	      var visitFn = getVisitFn(visitor, node.kind, isLeaving);
+	      if (visitFn) {
+	        result = visitFn.call(visitor, node, key, parent, path, ancestors);
+
+	        if (result === BREAK) {
+	          break;
+	        }
+
+	        if (result === false) {
+	          if (!isLeaving) {
+	            path.pop();
+	            continue;
+	          }
+	        } else if (result !== undefined) {
+	          edits.push([key, result]);
+	          if (!isLeaving) {
+	            if (isNode(result)) {
+	              node = result;
+	            } else {
+	              path.pop();
+	              continue;
+	            }
+	          }
+	        }
+	      }
+	    }
+
+	    if (result === undefined && isEdited) {
+	      edits.push([key, node]);
+	    }
+
+	    if (!isLeaving) {
+	      stack = { inArray: inArray, index: index, keys: keys, edits: edits, prev: stack };
+	      inArray = Array.isArray(node);
+	      keys = inArray ? node : visitorKeys[node.kind] || [];
+	      index = -1;
+	      edits = [];
+	      if (parent) {
+	        ancestors.push(parent);
+	      }
+	      parent = node;
+	    }
+	  } while (stack !== undefined);
+
+	  if (edits.length !== 0) {
+	    newRoot = edits[edits.length - 1][1];
+	  }
+
+	  return newRoot;
+	}
+
+	function isNode(maybeNode) {
+	  return maybeNode && typeof maybeNode.kind === 'string';
+	}
+
+	/**
+	 * Creates a new visitor instance which delegates to many visitors to run in
+	 * parallel. Each visitor will be visited for each node before moving on.
+	 *
+	 * If a prior visitor edits a node, no following visitors will see that node.
+	 */
+	function visitInParallel(visitors) {
+	  var skipping = new Array(visitors.length);
+
+	  return {
+	    enter: function enter(node) {
+	      for (var i = 0; i < visitors.length; i++) {
+	        if (!skipping[i]) {
+	          var fn = getVisitFn(visitors[i], node.kind, /* isLeaving */false);
+	          if (fn) {
+	            var result = fn.apply(visitors[i], arguments);
+	            if (result === false) {
+	              skipping[i] = node;
+	            } else if (result === BREAK) {
+	              skipping[i] = BREAK;
+	            } else if (result !== undefined) {
+	              return result;
+	            }
+	          }
+	        }
+	      }
+	    },
+	    leave: function leave(node) {
+	      for (var i = 0; i < visitors.length; i++) {
+	        if (!skipping[i]) {
+	          var fn = getVisitFn(visitors[i], node.kind, /* isLeaving */true);
+	          if (fn) {
+	            var result = fn.apply(visitors[i], arguments);
+	            if (result === BREAK) {
+	              skipping[i] = BREAK;
+	            } else if (result !== undefined && result !== false) {
+	              return result;
+	            }
+	          }
+	        } else if (skipping[i] === node) {
+	          skipping[i] = null;
+	        }
+	      }
+	    }
+	  };
+	}
+
+	/**
+	 * Creates a new visitor instance which maintains a provided TypeInfo instance
+	 * along with visiting visitor.
+	 */
+	function visitWithTypeInfo(typeInfo, visitor) {
+	  return {
+	    enter: function enter(node) {
+	      typeInfo.enter(node);
+	      var fn = getVisitFn(visitor, node.kind, /* isLeaving */false);
+	      if (fn) {
+	        var result = fn.apply(visitor, arguments);
+	        if (result !== undefined) {
+	          typeInfo.leave(node);
+	          if (isNode(result)) {
+	            typeInfo.enter(result);
+	          }
+	        }
+	        return result;
+	      }
+	    },
+	    leave: function leave(node) {
+	      var fn = getVisitFn(visitor, node.kind, /* isLeaving */true);
+	      var result = void 0;
+	      if (fn) {
+	        result = fn.apply(visitor, arguments);
+	      }
+	      typeInfo.leave(node);
+	      return result;
+	    }
+	  };
+	}
+
+	/**
+	 * Given a visitor instance, if it is leaving or not, and a node kind, return
+	 * the function the visitor runtime should call.
+	 */
+	function getVisitFn(visitor, kind, isLeaving) {
+	  var kindVisitor = visitor[kind];
+	  if (kindVisitor) {
+	    if (!isLeaving && typeof kindVisitor === 'function') {
+	      // { Kind() {} }
+	      return kindVisitor;
+	    }
+	    var kindSpecificVisitor = isLeaving ? kindVisitor.leave : kindVisitor.enter;
+	    if (typeof kindSpecificVisitor === 'function') {
+	      // { Kind: { enter() {}, leave() {} } }
+	      return kindSpecificVisitor;
+	    }
+	  } else {
+	    var specificVisitor = isLeaving ? visitor.leave : visitor.enter;
+	    if (specificVisitor) {
+	      if (typeof specificVisitor === 'function') {
+	        // { enter() {}, leave() {} }
+	        return specificVisitor;
+	      }
+	      var specificKindVisitor = specificVisitor[kind];
+	      if (typeof specificKindVisitor === 'function') {
+	        // { enter: { Kind() {} }, leave: { Kind() {} } }
+	        return specificKindVisitor;
+	      }
+	    }
+	  }
+	}
+
+/***/ },
+/* 196 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	// Name
+
+	var NAME = exports.NAME = 'Name';
+
+	// Document
+
+	var DOCUMENT = exports.DOCUMENT = 'Document';
+	var OPERATION_DEFINITION = exports.OPERATION_DEFINITION = 'OperationDefinition';
+	var VARIABLE_DEFINITION = exports.VARIABLE_DEFINITION = 'VariableDefinition';
+	var VARIABLE = exports.VARIABLE = 'Variable';
+	var SELECTION_SET = exports.SELECTION_SET = 'SelectionSet';
+	var FIELD = exports.FIELD = 'Field';
+	var ARGUMENT = exports.ARGUMENT = 'Argument';
+
+	// Fragments
+
+	var FRAGMENT_SPREAD = exports.FRAGMENT_SPREAD = 'FragmentSpread';
+	var INLINE_FRAGMENT = exports.INLINE_FRAGMENT = 'InlineFragment';
+	var FRAGMENT_DEFINITION = exports.FRAGMENT_DEFINITION = 'FragmentDefinition';
+
+	// Values
+
+	var INT = exports.INT = 'IntValue';
+	var FLOAT = exports.FLOAT = 'FloatValue';
+	var STRING = exports.STRING = 'StringValue';
+	var BOOLEAN = exports.BOOLEAN = 'BooleanValue';
+	var ENUM = exports.ENUM = 'EnumValue';
+	var LIST = exports.LIST = 'ListValue';
+	var OBJECT = exports.OBJECT = 'ObjectValue';
+	var OBJECT_FIELD = exports.OBJECT_FIELD = 'ObjectField';
+
+	// Directives
+
+	var DIRECTIVE = exports.DIRECTIVE = 'Directive';
+
+	// Types
+
+	var NAMED_TYPE = exports.NAMED_TYPE = 'NamedType';
+	var LIST_TYPE = exports.LIST_TYPE = 'ListType';
+	var NON_NULL_TYPE = exports.NON_NULL_TYPE = 'NonNullType';
+
+	// Type System Definitions
+
+	var SCHEMA_DEFINITION = exports.SCHEMA_DEFINITION = 'SchemaDefinition';
+	var OPERATION_TYPE_DEFINITION = exports.OPERATION_TYPE_DEFINITION = 'OperationTypeDefinition';
+
+	// Type Definitions
+
+	var SCALAR_TYPE_DEFINITION = exports.SCALAR_TYPE_DEFINITION = 'ScalarTypeDefinition';
+	var OBJECT_TYPE_DEFINITION = exports.OBJECT_TYPE_DEFINITION = 'ObjectTypeDefinition';
+	var FIELD_DEFINITION = exports.FIELD_DEFINITION = 'FieldDefinition';
+	var INPUT_VALUE_DEFINITION = exports.INPUT_VALUE_DEFINITION = 'InputValueDefinition';
+	var INTERFACE_TYPE_DEFINITION = exports.INTERFACE_TYPE_DEFINITION = 'InterfaceTypeDefinition';
+	var UNION_TYPE_DEFINITION = exports.UNION_TYPE_DEFINITION = 'UnionTypeDefinition';
+	var ENUM_TYPE_DEFINITION = exports.ENUM_TYPE_DEFINITION = 'EnumTypeDefinition';
+	var ENUM_VALUE_DEFINITION = exports.ENUM_VALUE_DEFINITION = 'EnumValueDefinition';
+	var INPUT_OBJECT_TYPE_DEFINITION = exports.INPUT_OBJECT_TYPE_DEFINITION = 'InputObjectTypeDefinition';
+
+	// Type Extensions
+
+	var TYPE_EXTENSION_DEFINITION = exports.TYPE_EXTENSION_DEFINITION = 'TypeExtensionDefinition';
+
+	// Directive Definitions
+
+	var DIRECTIVE_DEFINITION = exports.DIRECTIVE_DEFINITION = 'DirectiveDefinition';
+
+/***/ },
+/* 197 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.syntaxError = syntaxError;
+
+	var _location = __webpack_require__(192);
+
+	var _GraphQLError = __webpack_require__(190);
+
+	/**
+	 * Produces a GraphQLError representing a syntax error, containing useful
+	 * descriptive information about the syntax error's position in the source.
+	 */
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function syntaxError(source, position, description) {
+	  var location = (0, _location.getLocation)(source, position);
+	  var error = new _GraphQLError.GraphQLError('Syntax Error ' + source.name + ' (' + location.line + ':' + location.column + ') ' + description + '\n\n' + highlightSourceAtLocation(source, location), undefined, source, [position]);
+	  return error;
+	}
+
+	/**
+	 * Render a helpful description of the location of the error in the GraphQL
+	 * Source document.
+	 */
+	function highlightSourceAtLocation(source, location) {
+	  var line = location.line;
+	  var prevLineNum = (line - 1).toString();
+	  var lineNum = line.toString();
+	  var nextLineNum = (line + 1).toString();
+	  var padLen = nextLineNum.length;
+	  var lines = source.body.split(/\r\n|[\n\r]/g);
+	  return (line >= 2 ? lpad(padLen, prevLineNum) + ': ' + lines[line - 2] + '\n' : '') + lpad(padLen, lineNum) + ': ' + lines[line - 1] + '\n' + Array(2 + padLen + location.column).join(' ') + '^\n' + (line < lines.length ? lpad(padLen, nextLineNum) + ': ' + lines[line] + '\n' : '');
+	}
+
+	function lpad(len, str) {
+	  return Array(len - str.length + 1).join(' ') + str;
+	}
+
+/***/ },
+/* 198 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.locatedError = locatedError;
+
+	var _GraphQLError = __webpack_require__(190);
+
+	/**
+	 * Given an arbitrary Error, presumably thrown while attempting to execute a
+	 * GraphQL operation, produce a new GraphQLError aware of the location in the
+	 * document responsible for the original Error.
+	 */
+	function locatedError(originalError, nodes, path) {
+	  // Note: this uses a brand-check to support GraphQL errors originating from
+	  // other contexts.
+	  if (originalError && originalError.locations) {
+	    return originalError;
+	  }
+
+	  var message = originalError ? originalError.message || String(originalError) : 'An unknown error occurred.';
+	  return new _GraphQLError.GraphQLError(message, nodes, undefined, undefined, path, originalError);
+	}
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+/***/ },
+/* 199 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.formatError = formatError;
+
+	var _invariant = __webpack_require__(200);
+
+	var _invariant2 = _interopRequireDefault(_invariant);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 * Given a GraphQLError, format it according to the rules described by the
+	 * Response Format, Errors section of the GraphQL Specification.
+	 */
+	function formatError(error) {
+	  (0, _invariant2.default)(error, 'Received null or undefined error.');
+	  return {
+	    message: error.message,
+	    locations: error.locations
+	  };
+	}
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+/***/ },
+/* 200 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = invariant;
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function invariant(condition, message) {
+	  if (!condition) {
+	    throw new Error(message);
+	  }
+	}
+
+/***/ },
+/* 201 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.ValidationContext = undefined;
+	exports.validate = validate;
+	exports.visitUsingRules = visitUsingRules;
+
+	var _invariant = __webpack_require__(200);
+
+	var _invariant2 = _interopRequireDefault(_invariant);
+
+	var _error = __webpack_require__(189);
+
+	var _visitor = __webpack_require__(195);
+
+	var _kinds = __webpack_require__(196);
+
+	var Kind = _interopRequireWildcard(_kinds);
+
+	var _schema = __webpack_require__(202);
+
+	var _TypeInfo = __webpack_require__(213);
+
+	var _specifiedRules = __webpack_require__(215);
+
+	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	/**
+	 * Implements the "Validation" section of the spec.
+	 *
+	 * Validation runs synchronously, returning an array of encountered errors, or
+	 * an empty array if no errors were encountered and the document is valid.
+	 *
+	 * A list of specific validation rules may be provided. If not provided, the
+	 * default list of rules defined by the GraphQL specification will be used.
+	 *
+	 * Each validation rules is a function which returns a visitor
+	 * (see the language/visitor API). Visitor methods are expected to return
+	 * GraphQLErrors, or Arrays of GraphQLErrors when invalid.
+	 */
+	function validate(schema, ast, rules) {
+	  (0, _invariant2.default)(schema, 'Must provide schema');
+	  (0, _invariant2.default)(ast, 'Must provide document');
+	  (0, _invariant2.default)(schema instanceof _schema.GraphQLSchema, 'Schema must be an instance of GraphQLSchema. Also ensure that there are ' + 'not multiple versions of GraphQL installed in your node_modules directory.');
+	  var typeInfo = new _TypeInfo.TypeInfo(schema);
+	  return visitUsingRules(schema, typeInfo, ast, rules || _specifiedRules.specifiedRules);
+	}
+
+	/**
+	 * This uses a specialized visitor which runs multiple visitors in parallel,
+	 * while maintaining the visitor skip and break API.
+	 *
+	 * @internal
+	 */
+	function visitUsingRules(schema, typeInfo, documentAST, rules) {
+	  var context = new ValidationContext(schema, documentAST, typeInfo);
+	  var visitors = rules.map(function (rule) {
+	    return rule(context);
+	  });
+	  // Visit the whole document with each instance of all provided rules.
+	  (0, _visitor.visit)(documentAST, (0, _visitor.visitWithTypeInfo)(typeInfo, (0, _visitor.visitInParallel)(visitors)));
+	  return context.getErrors();
+	}
+
+	/**
+	 * An instance of this class is passed as the "this" context to all validators,
+	 * allowing access to commonly useful contextual information from within a
+	 * validation rule.
+	 */
+	var ValidationContext = exports.ValidationContext = function () {
+	  function ValidationContext(schema, ast, typeInfo) {
+	    _classCallCheck(this, ValidationContext);
+
+	    this._schema = schema;
+	    this._ast = ast;
+	    this._typeInfo = typeInfo;
+	    this._errors = [];
+	    this._fragmentSpreads = new Map();
+	    this._recursivelyReferencedFragments = new Map();
+	    this._variableUsages = new Map();
+	    this._recursiveVariableUsages = new Map();
+	  }
+
+	  ValidationContext.prototype.reportError = function reportError(error) {
+	    this._errors.push(error);
+	  };
+
+	  ValidationContext.prototype.getErrors = function getErrors() {
+	    return this._errors;
+	  };
+
+	  ValidationContext.prototype.getSchema = function getSchema() {
+	    return this._schema;
+	  };
+
+	  ValidationContext.prototype.getDocument = function getDocument() {
+	    return this._ast;
+	  };
+
+	  ValidationContext.prototype.getFragment = function getFragment(name) {
+	    var fragments = this._fragments;
+	    if (!fragments) {
+	      this._fragments = fragments = this.getDocument().definitions.reduce(function (frags, statement) {
+	        if (statement.kind === Kind.FRAGMENT_DEFINITION) {
+	          frags[statement.name.value] = statement;
+	        }
+	        return frags;
+	      }, {});
+	    }
+	    return fragments[name];
+	  };
+
+	  ValidationContext.prototype.getFragmentSpreads = function getFragmentSpreads(node) {
+	    var spreads = this._fragmentSpreads.get(node);
+	    if (!spreads) {
+	      spreads = [];
+	      var setsToVisit = [node];
+	      while (setsToVisit.length !== 0) {
+	        var set = setsToVisit.pop();
+	        for (var i = 0; i < set.selections.length; i++) {
+	          var selection = set.selections[i];
+	          if (selection.kind === Kind.FRAGMENT_SPREAD) {
+	            spreads.push(selection);
+	          } else if (selection.selectionSet) {
+	            setsToVisit.push(selection.selectionSet);
+	          }
+	        }
+	      }
+	      this._fragmentSpreads.set(node, spreads);
+	    }
+	    return spreads;
+	  };
+
+	  ValidationContext.prototype.getRecursivelyReferencedFragments = function getRecursivelyReferencedFragments(operation) {
+	    var fragments = this._recursivelyReferencedFragments.get(operation);
+	    if (!fragments) {
+	      fragments = [];
+	      var collectedNames = Object.create(null);
+	      var nodesToVisit = [operation.selectionSet];
+	      while (nodesToVisit.length !== 0) {
+	        var _node = nodesToVisit.pop();
+	        var spreads = this.getFragmentSpreads(_node);
+	        for (var i = 0; i < spreads.length; i++) {
+	          var fragName = spreads[i].name.value;
+	          if (collectedNames[fragName] !== true) {
+	            collectedNames[fragName] = true;
+	            var fragment = this.getFragment(fragName);
+	            if (fragment) {
+	              fragments.push(fragment);
+	              nodesToVisit.push(fragment.selectionSet);
+	            }
+	          }
+	        }
+	      }
+	      this._recursivelyReferencedFragments.set(operation, fragments);
+	    }
+	    return fragments;
+	  };
+
+	  ValidationContext.prototype.getVariableUsages = function getVariableUsages(node) {
+	    var _this = this;
+
+	    var usages = this._variableUsages.get(node);
+	    if (!usages) {
+	      (function () {
+	        var newUsages = [];
+	        var typeInfo = new _TypeInfo.TypeInfo(_this._schema);
+	        (0, _visitor.visit)(node, (0, _visitor.visitWithTypeInfo)(typeInfo, {
+	          VariableDefinition: function VariableDefinition() {
+	            return false;
+	          },
+	          Variable: function Variable(variable) {
+	            newUsages.push({ node: variable, type: typeInfo.getInputType() });
+	          }
+	        }));
+	        usages = newUsages;
+	        _this._variableUsages.set(node, usages);
+	      })();
+	    }
+	    return usages;
+	  };
+
+	  ValidationContext.prototype.getRecursiveVariableUsages = function getRecursiveVariableUsages(operation) {
+	    var usages = this._recursiveVariableUsages.get(operation);
+	    if (!usages) {
+	      usages = this.getVariableUsages(operation);
+	      var fragments = this.getRecursivelyReferencedFragments(operation);
+	      for (var i = 0; i < fragments.length; i++) {
+	        Array.prototype.push.apply(usages, this.getVariableUsages(fragments[i]));
+	      }
+	      this._recursiveVariableUsages.set(operation, usages);
+	    }
+	    return usages;
+	  };
+
+	  ValidationContext.prototype.getType = function getType() {
+	    return this._typeInfo.getType();
+	  };
+
+	  ValidationContext.prototype.getParentType = function getParentType() {
+	    return this._typeInfo.getParentType();
+	  };
+
+	  ValidationContext.prototype.getInputType = function getInputType() {
+	    return this._typeInfo.getInputType();
+	  };
+
+	  ValidationContext.prototype.getFieldDef = function getFieldDef() {
+	    return this._typeInfo.getFieldDef();
+	  };
+
+	  ValidationContext.prototype.getDirective = function getDirective() {
+	    return this._typeInfo.getDirective();
+	  };
+
+	  ValidationContext.prototype.getArgument = function getArgument() {
+	    return this._typeInfo.getArgument();
+	  };
+
+	  return ValidationContext;
+	}();
+
+/***/ },
+/* 202 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.GraphQLSchema = undefined;
+
+	var _definition = __webpack_require__(203);
+
+	var _directives = __webpack_require__(206);
+
+	var _introspection = __webpack_require__(208);
+
+	var _find = __webpack_require__(211);
+
+	var _find2 = _interopRequireDefault(_find);
+
+	var _invariant = __webpack_require__(200);
+
+	var _invariant2 = _interopRequireDefault(_invariant);
+
+	var _typeComparators = __webpack_require__(212);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	/**
+	 * Schema Definition
+	 *
+	 * A Schema is created by supplying the root types of each type of operation,
+	 * query and mutation (optional). A schema definition is then supplied to the
+	 * validator and executor.
+	 *
+	 * Example:
+	 *
+	 *     const MyAppSchema = new GraphQLSchema({
+	 *       query: MyAppQueryRootType,
+	 *       mutation: MyAppMutationRootType,
+	 *     })
+	 *
+	 * Note: If an array of `directives` are provided to GraphQLSchema, that will be
+	 * the exact list of directives represented and allowed. If `directives` is not
+	 * provided then a default set of the specified directives (e.g. @include and
+	 * @skip) will be used. If you wish to provide *additional* directives to these
+	 * specified directives, you must explicitly declare them. Example:
+	 *
+	 *     const MyAppSchema = new GraphQLSchema({
+	 *       ...
+	 *       directives: specifiedDirectives.concat([ myCustomDirective ]),
+	 *     })
+	 *
+	 */
+	var GraphQLSchema = exports.GraphQLSchema = function () {
+	  function GraphQLSchema(config) {
+	    var _this = this;
+
+	    _classCallCheck(this, GraphQLSchema);
+
+	    (0, _invariant2.default)(typeof config === 'object', 'Must provide configuration object.');
+
+	    (0, _invariant2.default)(config.query instanceof _definition.GraphQLObjectType, 'Schema query must be Object Type but got: ' + String(config.query) + '.');
+	    this._queryType = config.query;
+
+	    (0, _invariant2.default)(!config.mutation || config.mutation instanceof _definition.GraphQLObjectType, 'Schema mutation must be Object Type if provided but got: ' + String(config.mutation) + '.');
+	    this._mutationType = config.mutation;
+
+	    (0, _invariant2.default)(!config.subscription || config.subscription instanceof _definition.GraphQLObjectType, 'Schema subscription must be Object Type if provided but got: ' + String(config.subscription) + '.');
+	    this._subscriptionType = config.subscription;
+
+	    (0, _invariant2.default)(!config.types || Array.isArray(config.types), 'Schema types must be Array if provided but got: ' + String(config.types) + '.');
+
+	    (0, _invariant2.default)(!config.directives || Array.isArray(config.directives) && config.directives.every(function (directive) {
+	      return directive instanceof _directives.GraphQLDirective;
+	    }), 'Schema directives must be Array<GraphQLDirective> if provided but got: ' + String(config.directives) + '.');
+	    // Provide specified directives (e.g. @include and @skip) by default.
+	    this._directives = config.directives || _directives.specifiedDirectives;
+
+	    // Build type map now to detect any errors within this schema.
+	    var initialTypes = [this.getQueryType(), this.getMutationType(), this.getSubscriptionType(), _introspection.__Schema];
+
+	    var types = config.types;
+	    if (types) {
+	      initialTypes = initialTypes.concat(types);
+	    }
+
+	    this._typeMap = initialTypes.reduce(typeMapReducer, Object.create(null));
+
+	    // Keep track of all implementations by interface name.
+	    this._implementations = Object.create(null);
+	    Object.keys(this._typeMap).forEach(function (typeName) {
+	      var type = _this._typeMap[typeName];
+	      if (type instanceof _definition.GraphQLObjectType) {
+	        type.getInterfaces().forEach(function (iface) {
+	          var impls = _this._implementations[iface.name];
+	          if (impls) {
+	            impls.push(type);
+	          } else {
+	            _this._implementations[iface.name] = [type];
+	          }
+	        });
+	      }
+	    });
+
+	    // Enforce correct interface implementations.
+	    Object.keys(this._typeMap).forEach(function (typeName) {
+	      var type = _this._typeMap[typeName];
+	      if (type instanceof _definition.GraphQLObjectType) {
+	        type.getInterfaces().forEach(function (iface) {
+	          return assertObjectImplementsInterface(_this, type, iface);
+	        });
+	      }
+	    });
+	  }
+
+	  GraphQLSchema.prototype.getQueryType = function getQueryType() {
+	    return this._queryType;
+	  };
+
+	  GraphQLSchema.prototype.getMutationType = function getMutationType() {
+	    return this._mutationType;
+	  };
+
+	  GraphQLSchema.prototype.getSubscriptionType = function getSubscriptionType() {
+	    return this._subscriptionType;
+	  };
+
+	  GraphQLSchema.prototype.getTypeMap = function getTypeMap() {
+	    return this._typeMap;
+	  };
+
+	  GraphQLSchema.prototype.getType = function getType(name) {
+	    return this.getTypeMap()[name];
+	  };
+
+	  GraphQLSchema.prototype.getPossibleTypes = function getPossibleTypes(abstractType) {
+	    if (abstractType instanceof _definition.GraphQLUnionType) {
+	      return abstractType.getTypes();
+	    }
+	    (0, _invariant2.default)(abstractType instanceof _definition.GraphQLInterfaceType);
+	    return this._implementations[abstractType.name];
+	  };
+
+	  GraphQLSchema.prototype.isPossibleType = function isPossibleType(abstractType, possibleType) {
+	    var possibleTypeMap = this._possibleTypeMap;
+	    if (!possibleTypeMap) {
+	      this._possibleTypeMap = possibleTypeMap = Object.create(null);
+	    }
+
+	    if (!possibleTypeMap[abstractType.name]) {
+	      var possibleTypes = this.getPossibleTypes(abstractType);
+	      (0, _invariant2.default)(Array.isArray(possibleTypes), 'Could not find possible implementing types for ' + abstractType.name + ' ' + 'in schema. Check that schema.types is defined and is an array of ' + 'all possible types in the schema.');
+	      possibleTypeMap[abstractType.name] = possibleTypes.reduce(function (map, type) {
+	        return map[type.name] = true, map;
+	      }, Object.create(null));
+	    }
+
+	    return Boolean(possibleTypeMap[abstractType.name][possibleType.name]);
+	  };
+
+	  GraphQLSchema.prototype.getDirectives = function getDirectives() {
+	    return this._directives;
+	  };
+
+	  GraphQLSchema.prototype.getDirective = function getDirective(name) {
+	    return (0, _find2.default)(this.getDirectives(), function (directive) {
+	      return directive.name === name;
+	    });
+	  };
+
+	  return GraphQLSchema;
+	}();
+
+	function typeMapReducer(map, type) {
+	  if (!type) {
+	    return map;
+	  }
+	  if (type instanceof _definition.GraphQLList || type instanceof _definition.GraphQLNonNull) {
+	    return typeMapReducer(map, type.ofType);
+	  }
+	  if (map[type.name]) {
+	    (0, _invariant2.default)(map[type.name] === type, 'Schema must contain unique named types but contains multiple ' + ('types named "' + type.name + '".'));
+	    return map;
+	  }
+	  map[type.name] = type;
+
+	  var reducedMap = map;
+
+	  if (type instanceof _definition.GraphQLUnionType) {
+	    reducedMap = type.getTypes().reduce(typeMapReducer, reducedMap);
+	  }
+
+	  if (type instanceof _definition.GraphQLObjectType) {
+	    reducedMap = type.getInterfaces().reduce(typeMapReducer, reducedMap);
+	  }
+
+	  if (type instanceof _definition.GraphQLObjectType || type instanceof _definition.GraphQLInterfaceType) {
+	    (function () {
+	      var fieldMap = type.getFields();
+	      Object.keys(fieldMap).forEach(function (fieldName) {
+	        var field = fieldMap[fieldName];
+
+	        if (field.args) {
+	          var fieldArgTypes = field.args.map(function (arg) {
+	            return arg.type;
+	          });
+	          reducedMap = fieldArgTypes.reduce(typeMapReducer, reducedMap);
+	        }
+	        reducedMap = typeMapReducer(reducedMap, field.type);
+	      });
+	    })();
+	  }
+
+	  if (type instanceof _definition.GraphQLInputObjectType) {
+	    (function () {
+	      var fieldMap = type.getFields();
+	      Object.keys(fieldMap).forEach(function (fieldName) {
+	        var field = fieldMap[fieldName];
+	        reducedMap = typeMapReducer(reducedMap, field.type);
+	      });
+	    })();
+	  }
+
+	  return reducedMap;
+	}
+
+	function assertObjectImplementsInterface(schema, object, iface) {
+	  var objectFieldMap = object.getFields();
+	  var ifaceFieldMap = iface.getFields();
+
+	  // Assert each interface field is implemented.
+	  Object.keys(ifaceFieldMap).forEach(function (fieldName) {
+	    var objectField = objectFieldMap[fieldName];
+	    var ifaceField = ifaceFieldMap[fieldName];
+
+	    // Assert interface field exists on object.
+	    (0, _invariant2.default)(objectField, '"' + iface.name + '" expects field "' + fieldName + '" but "' + object.name + '" ' + 'does not provide it.');
+
+	    // Assert interface field type is satisfied by object field type, by being
+	    // a valid subtype. (covariant)
+	    (0, _invariant2.default)((0, _typeComparators.isTypeSubTypeOf)(schema, objectField.type, ifaceField.type), iface.name + '.' + fieldName + ' expects type "' + String(ifaceField.type) + '" ' + 'but ' + (object.name + '.' + fieldName + ' provides type "' + String(objectField.type) + '".'));
+
+	    // Assert each interface field arg is implemented.
+	    ifaceField.args.forEach(function (ifaceArg) {
+	      var argName = ifaceArg.name;
+	      var objectArg = (0, _find2.default)(objectField.args, function (arg) {
+	        return arg.name === argName;
+	      });
+
+	      // Assert interface field arg exists on object field.
+	      (0, _invariant2.default)(objectArg, iface.name + '.' + fieldName + ' expects argument "' + argName + '" but ' + (object.name + '.' + fieldName + ' does not provide it.'));
+
+	      // Assert interface field arg type matches object field arg type.
+	      // (invariant)
+	      (0, _invariant2.default)((0, _typeComparators.isEqualType)(ifaceArg.type, objectArg.type), iface.name + '.' + fieldName + '(' + argName + ':) expects type ' + ('"' + String(ifaceArg.type) + '" but ') + (object.name + '.' + fieldName + '(' + argName + ':) provides type ') + ('"' + String(objectArg.type) + '".'));
+	    });
+
+	    // Assert additional arguments must not be required.
+	    objectField.args.forEach(function (objectArg) {
+	      var argName = objectArg.name;
+	      var ifaceArg = (0, _find2.default)(ifaceField.args, function (arg) {
+	        return arg.name === argName;
+	      });
+	      if (!ifaceArg) {
+	        (0, _invariant2.default)(!(objectArg.type instanceof _definition.GraphQLNonNull), object.name + '.' + fieldName + '(' + argName + ':) is of required type ' + ('"' + String(objectArg.type) + '" but is not also provided by the ') + ('interface ' + iface.name + '.' + fieldName + '.'));
+	      }
+	    });
+	  });
+	}
+
+/***/ },
+/* 203 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.GraphQLNonNull = exports.GraphQLList = exports.GraphQLInputObjectType = exports.GraphQLEnumType = exports.GraphQLUnionType = exports.GraphQLInterfaceType = exports.GraphQLObjectType = exports.GraphQLScalarType = undefined;
+
+	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+	exports.isType = isType;
+	exports.isInputType = isInputType;
+	exports.isOutputType = isOutputType;
+	exports.isLeafType = isLeafType;
+	exports.isCompositeType = isCompositeType;
+	exports.isAbstractType = isAbstractType;
+	exports.getNullableType = getNullableType;
+	exports.getNamedType = getNamedType;
+
+	var _invariant = __webpack_require__(200);
+
+	var _invariant2 = _interopRequireDefault(_invariant);
+
+	var _isNullish = __webpack_require__(204);
+
+	var _isNullish2 = _interopRequireDefault(_isNullish);
+
+	var _kinds = __webpack_require__(196);
+
+	var _assertValidName = __webpack_require__(205);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	// Predicates
+
+	/**
+	 * These are all of the possible kinds of types.
+	 */
+	function isType(type) {
+	  return type instanceof GraphQLScalarType || type instanceof GraphQLObjectType || type instanceof GraphQLInterfaceType || type instanceof GraphQLUnionType || type instanceof GraphQLEnumType || type instanceof GraphQLInputObjectType || type instanceof GraphQLList || type instanceof GraphQLNonNull;
+	}
+
+	/**
+	 * These types may be used as input types for arguments and directives.
+	 */
+	function isInputType(type) {
+	  var namedType = getNamedType(type);
+	  return namedType instanceof GraphQLScalarType || namedType instanceof GraphQLEnumType || namedType instanceof GraphQLInputObjectType;
+	}
+
+	/**
+	 * These types may be used as output types as the result of fields.
+	 */
+	function isOutputType(type) {
+	  var namedType = getNamedType(type);
+	  return namedType instanceof GraphQLScalarType || namedType instanceof GraphQLObjectType || namedType instanceof GraphQLInterfaceType || namedType instanceof GraphQLUnionType || namedType instanceof GraphQLEnumType;
+	}
+
+	/**
+	 * These types may describe types which may be leaf values.
+	 */
+	function isLeafType(type) {
+	  var namedType = getNamedType(type);
+	  return namedType instanceof GraphQLScalarType || namedType instanceof GraphQLEnumType;
+	}
+
+	/**
+	 * These types may describe the parent context of a selection set.
+	 */
+	function isCompositeType(type) {
+	  return type instanceof GraphQLObjectType || type instanceof GraphQLInterfaceType || type instanceof GraphQLUnionType;
+	}
+
+	/**
+	 * These types may describe the parent context of a selection set.
+	 */
+	function isAbstractType(type) {
+	  return type instanceof GraphQLInterfaceType || type instanceof GraphQLUnionType;
+	}
+
+	/**
+	 * These types can all accept null as a value.
+	 */
+	function getNullableType(type) {
+	  return type instanceof GraphQLNonNull ? type.ofType : type;
+	}
+
+	/**
+	 * These named types do not include modifiers like List or NonNull.
+	 */
+	function getNamedType(type) {
+	  var unmodifiedType = type;
+	  while (unmodifiedType instanceof GraphQLList || unmodifiedType instanceof GraphQLNonNull) {
+	    unmodifiedType = unmodifiedType.ofType;
+	  }
+	  return unmodifiedType;
+	}
+
+	/**
+	 * Used while defining GraphQL types to allow for circular references in
+	 * otherwise immutable type definitions.
+	 */
+
+
+	function resolveThunk(thunk) {
+	  return typeof thunk === 'function' ? thunk() : thunk;
+	}
+
+	/**
+	 * Scalar Type Definition
+	 *
+	 * The leaf values of any request and input values to arguments are
+	 * Scalars (or Enums) and are defined with a name and a series of functions
+	 * used to parse input from ast or variables and to ensure validity.
+	 *
+	 * Example:
+	 *
+	 *     const OddType = new GraphQLScalarType({
+	 *       name: 'Odd',
+	 *       serialize(value) {
+	 *         return value % 2 === 1 ? value : null;
+	 *       }
+	 *     });
+	 *
+	 */
+
+	var GraphQLScalarType = exports.GraphQLScalarType = function () {
+	  function GraphQLScalarType(config) {
+	    _classCallCheck(this, GraphQLScalarType);
+
+	    (0, _invariant2.default)(config.name, 'Type must be named.');
+	    (0, _assertValidName.assertValidName)(config.name);
+	    this.name = config.name;
+	    this.description = config.description;
+	    (0, _invariant2.default)(typeof config.serialize === 'function', this.name + ' must provide "serialize" function. If this custom Scalar ' + 'is also used as an input type, ensure "parseValue" and "parseLiteral" ' + 'functions are also provided.');
+	    if (config.parseValue || config.parseLiteral) {
+	      (0, _invariant2.default)(typeof config.parseValue === 'function' && typeof config.parseLiteral === 'function', this.name + ' must provide both "parseValue" and "parseLiteral" ' + 'functions.');
+	    }
+	    this._scalarConfig = config;
+	  }
+
+	  // Serializes an internal value to include in a response.
+
+
+	  GraphQLScalarType.prototype.serialize = function serialize(value) {
+	    var serializer = this._scalarConfig.serialize;
+	    return serializer(value);
+	  };
+
+	  // Parses an externally provided value to use as an input.
+
+
+	  GraphQLScalarType.prototype.parseValue = function parseValue(value) {
+	    var parser = this._scalarConfig.parseValue;
+	    return parser ? parser(value) : null;
+	  };
+
+	  // Parses an externally provided literal value to use as an input.
+
+
+	  GraphQLScalarType.prototype.parseLiteral = function parseLiteral(valueAST) {
+	    var parser = this._scalarConfig.parseLiteral;
+	    return parser ? parser(valueAST) : null;
+	  };
+
+	  GraphQLScalarType.prototype.toString = function toString() {
+	    return this.name;
+	  };
+
+	  return GraphQLScalarType;
+	}();
+
+	/**
+	 * Object Type Definition
+	 *
+	 * Almost all of the GraphQL types you define will be object types. Object types
+	 * have a name, but most importantly describe their fields.
+	 *
+	 * Example:
+	 *
+	 *     const AddressType = new GraphQLObjectType({
+	 *       name: 'Address',
+	 *       fields: {
+	 *         street: { type: GraphQLString },
+	 *         number: { type: GraphQLInt },
+	 *         formatted: {
+	 *           type: GraphQLString,
+	 *           resolve(obj) {
+	 *             return obj.number + ' ' + obj.street
+	 *           }
+	 *         }
+	 *       }
+	 *     });
+	 *
+	 * When two types need to refer to each other, or a type needs to refer to
+	 * itself in a field, you can use a function expression (aka a closure or a
+	 * thunk) to supply the fields lazily.
+	 *
+	 * Example:
+	 *
+	 *     const PersonType = new GraphQLObjectType({
+	 *       name: 'Person',
+	 *       fields: () => ({
+	 *         name: { type: GraphQLString },
+	 *         bestFriend: { type: PersonType },
+	 *       })
+	 *     });
+	 *
+	 */
+	var GraphQLObjectType = exports.GraphQLObjectType = function () {
+	  function GraphQLObjectType(config) {
+	    _classCallCheck(this, GraphQLObjectType);
+
+	    (0, _invariant2.default)(config.name, 'Type must be named.');
+	    (0, _assertValidName.assertValidName)(config.name);
+	    this.name = config.name;
+	    this.description = config.description;
+	    if (config.isTypeOf) {
+	      (0, _invariant2.default)(typeof config.isTypeOf === 'function', this.name + ' must provide "isTypeOf" as a function.');
+	    }
+	    this.isTypeOf = config.isTypeOf;
+	    this._typeConfig = config;
+	  }
+
+	  GraphQLObjectType.prototype.getFields = function getFields() {
+	    return this._fields || (this._fields = defineFieldMap(this, this._typeConfig.fields));
+	  };
+
+	  GraphQLObjectType.prototype.getInterfaces = function getInterfaces() {
+	    return this._interfaces || (this._interfaces = defineInterfaces(this, this._typeConfig.interfaces));
+	  };
+
+	  GraphQLObjectType.prototype.toString = function toString() {
+	    return this.name;
+	  };
+
+	  return GraphQLObjectType;
+	}();
+
+	function defineInterfaces(type, interfacesThunk) {
+	  var interfaces = resolveThunk(interfacesThunk);
+	  if (!interfaces) {
+	    return [];
+	  }
+	  (0, _invariant2.default)(Array.isArray(interfaces), type.name + ' interfaces must be an Array or a function which returns ' + 'an Array.');
+	  interfaces.forEach(function (iface) {
+	    (0, _invariant2.default)(iface instanceof GraphQLInterfaceType, type.name + ' may only implement Interface types, it cannot ' + ('implement: ' + String(iface) + '.'));
+	    if (typeof iface.resolveType !== 'function') {
+	      (0, _invariant2.default)(typeof type.isTypeOf === 'function', 'Interface Type ' + iface.name + ' does not provide a "resolveType" ' + ('function and implementing Type ' + type.name + ' does not provide a ') + '"isTypeOf" function. There is no way to resolve this implementing ' + 'type during execution.');
+	    }
+	  });
+	  return interfaces;
+	}
+
+	function defineFieldMap(type, fieldsThunk) {
+	  var fieldMap = resolveThunk(fieldsThunk);
+	  (0, _invariant2.default)(isPlainObj(fieldMap), type.name + ' fields must be an object with field names as keys or a ' + 'function which returns such an object.');
+
+	  var fieldNames = Object.keys(fieldMap);
+	  (0, _invariant2.default)(fieldNames.length > 0, type.name + ' fields must be an object with field names as keys or a ' + 'function which returns such an object.');
+
+	  var resultFieldMap = {};
+	  fieldNames.forEach(function (fieldName) {
+	    (0, _assertValidName.assertValidName)(fieldName);
+	    var fieldConfig = fieldMap[fieldName];
+	    (0, _invariant2.default)(!fieldConfig.hasOwnProperty('isDeprecated'), type.name + '.' + fieldName + ' should provide "deprecationReason" instead ' + 'of "isDeprecated".');
+	    var field = _extends({}, fieldConfig, {
+	      isDeprecated: Boolean(fieldConfig.deprecationReason),
+	      name: fieldName
+	    });
+	    (0, _invariant2.default)(isOutputType(field.type), type.name + '.' + fieldName + ' field type must be Output Type but ' + ('got: ' + String(field.type) + '.'));
+	    var argsConfig = fieldConfig.args;
+	    if (!argsConfig) {
+	      field.args = [];
+	    } else {
+	      (0, _invariant2.default)(isPlainObj(argsConfig), type.name + '.' + fieldName + ' args must be an object with argument ' + 'names as keys.');
+	      field.args = Object.keys(argsConfig).map(function (argName) {
+	        (0, _assertValidName.assertValidName)(argName);
+	        var arg = argsConfig[argName];
+	        (0, _invariant2.default)(isInputType(arg.type), type.name + '.' + fieldName + '(' + argName + ':) argument type must be ' + ('Input Type but got: ' + String(arg.type) + '.'));
+	        return {
+	          name: argName,
+	          description: arg.description === undefined ? null : arg.description,
+	          type: arg.type,
+	          defaultValue: arg.defaultValue === undefined ? null : arg.defaultValue
+	        };
+	      });
+	    }
+	    resultFieldMap[fieldName] = field;
+	  });
+	  return resultFieldMap;
+	}
+
+	function isPlainObj(obj) {
+	  return obj && typeof obj === 'object' && !Array.isArray(obj);
+	}
+
+	/**
+	 * Interface Type Definition
+	 *
+	 * When a field can return one of a heterogeneous set of types, a Interface type
+	 * is used to describe what types are possible, what fields are in common across
+	 * all types, as well as a function to determine which type is actually used
+	 * when the field is resolved.
+	 *
+	 * Example:
+	 *
+	 *     const EntityType = new GraphQLInterfaceType({
+	 *       name: 'Entity',
+	 *       fields: {
+	 *         name: { type: GraphQLString }
+	 *       }
+	 *     });
+	 *
+	 */
+	var GraphQLInterfaceType = exports.GraphQLInterfaceType = function () {
+	  function GraphQLInterfaceType(config) {
+	    _classCallCheck(this, GraphQLInterfaceType);
+
+	    (0, _invariant2.default)(config.name, 'Type must be named.');
+	    (0, _assertValidName.assertValidName)(config.name);
+	    this.name = config.name;
+	    this.description = config.description;
+	    if (config.resolveType) {
+	      (0, _invariant2.default)(typeof config.resolveType === 'function', this.name + ' must provide "resolveType" as a function.');
+	    }
+	    this.resolveType = config.resolveType;
+	    this._typeConfig = config;
+	  }
+
+	  GraphQLInterfaceType.prototype.getFields = function getFields() {
+	    return this._fields || (this._fields = defineFieldMap(this, this._typeConfig.fields));
+	  };
+
+	  GraphQLInterfaceType.prototype.toString = function toString() {
+	    return this.name;
+	  };
+
+	  return GraphQLInterfaceType;
+	}();
+
+	/**
+	 * Union Type Definition
+	 *
+	 * When a field can return one of a heterogeneous set of types, a Union type
+	 * is used to describe what types are possible as well as providing a function
+	 * to determine which type is actually used when the field is resolved.
+	 *
+	 * Example:
+	 *
+	 *     const PetType = new GraphQLUnionType({
+	 *       name: 'Pet',
+	 *       types: [ DogType, CatType ],
+	 *       resolveType(value) {
+	 *         if (value instanceof Dog) {
+	 *           return DogType;
+	 *         }
+	 *         if (value instanceof Cat) {
+	 *           return CatType;
+	 *         }
+	 *       }
+	 *     });
+	 *
+	 */
+	var GraphQLUnionType = exports.GraphQLUnionType = function () {
+	  function GraphQLUnionType(config) {
+	    _classCallCheck(this, GraphQLUnionType);
+
+	    (0, _invariant2.default)(config.name, 'Type must be named.');
+	    (0, _assertValidName.assertValidName)(config.name);
+	    this.name = config.name;
+	    this.description = config.description;
+	    if (config.resolveType) {
+	      (0, _invariant2.default)(typeof config.resolveType === 'function', this.name + ' must provide "resolveType" as a function.');
+	    }
+	    this.resolveType = config.resolveType;
+	    this._typeConfig = config;
+	  }
+
+	  GraphQLUnionType.prototype.getTypes = function getTypes() {
+	    return this._types || (this._types = defineTypes(this, this._typeConfig.types));
+	  };
+
+	  GraphQLUnionType.prototype.toString = function toString() {
+	    return this.name;
+	  };
+
+	  return GraphQLUnionType;
+	}();
+
+	function defineTypes(unionType, typesThunk) {
+	  var types = resolveThunk(typesThunk);
+
+	  (0, _invariant2.default)(Array.isArray(types) && types.length > 0, 'Must provide Array of types or a function which returns ' + ('such an array for Union ' + unionType.name + '.'));
+	  types.forEach(function (objType) {
+	    (0, _invariant2.default)(objType instanceof GraphQLObjectType, unionType.name + ' may only contain Object types, it cannot contain: ' + (String(objType) + '.'));
+	    if (typeof unionType.resolveType !== 'function') {
+	      (0, _invariant2.default)(typeof objType.isTypeOf === 'function', 'Union type "' + unionType.name + '" does not provide a "resolveType" ' + ('function and possible type "' + objType.name + '" does not provide an ') + '"isTypeOf" function. There is no way to resolve this possible type ' + 'during execution.');
+	    }
+	  });
+
+	  return types;
+	}
+
+	/**
+	 * Enum Type Definition
+	 *
+	 * Some leaf values of requests and input values are Enums. GraphQL serializes
+	 * Enum values as strings, however internally Enums can be represented by any
+	 * kind of type, often integers.
+	 *
+	 * Example:
+	 *
+	 *     const RGBType = new GraphQLEnumType({
+	 *       name: 'RGB',
+	 *       values: {
+	 *         RED: { value: 0 },
+	 *         GREEN: { value: 1 },
+	 *         BLUE: { value: 2 }
+	 *       }
+	 *     });
+	 *
+	 * Note: If a value is not provided in a definition, the name of the enum value
+	 * will be used as its internal value.
+	 */
+	var GraphQLEnumType /* <T> */ = exports.GraphQLEnumType = function () {
+	  function GraphQLEnumType(config /* <T> */) {
+	    _classCallCheck(this, GraphQLEnumType);
+
+	    this.name = config.name;
+	    (0, _assertValidName.assertValidName)(config.name);
+	    this.description = config.description;
+	    this._values = defineEnumValues(this, config.values);
+	    this._enumConfig = config;
+	  }
+
+	  GraphQLEnumType.prototype.getValues = function getValues() {
+	    return this._values;
+	  };
+
+	  GraphQLEnumType.prototype.serialize = function serialize(value /* T */) {
+	    var enumValue = this._getValueLookup().get(value);
+	    return enumValue ? enumValue.name : null;
+	  };
+
+	  GraphQLEnumType.prototype.parseValue = function parseValue(value) /* T */{
+	    if (typeof value === 'string') {
+	      var enumValue = this._getNameLookup()[value];
+	      if (enumValue) {
+	        return enumValue.value;
+	      }
+	    }
+	  };
+
+	  GraphQLEnumType.prototype.parseLiteral = function parseLiteral(valueAST) /* T */{
+	    if (valueAST.kind === _kinds.ENUM) {
+	      var enumValue = this._getNameLookup()[valueAST.value];
+	      if (enumValue) {
+	        return enumValue.value;
+	      }
+	    }
+	  };
+
+	  GraphQLEnumType.prototype._getValueLookup = function _getValueLookup() {
+	    var _this = this;
+
+	    if (!this._valueLookup) {
+	      (function () {
+	        var lookup = new Map();
+	        _this.getValues().forEach(function (value) {
+	          lookup.set(value.value, value);
+	        });
+	        _this._valueLookup = lookup;
+	      })();
+	    }
+	    return this._valueLookup;
+	  };
+
+	  GraphQLEnumType.prototype._getNameLookup = function _getNameLookup() {
+	    var _this2 = this;
+
+	    if (!this._nameLookup) {
+	      (function () {
+	        var lookup = Object.create(null);
+	        _this2.getValues().forEach(function (value) {
+	          lookup[value.name] = value;
+	        });
+	        _this2._nameLookup = lookup;
+	      })();
+	    }
+	    return this._nameLookup;
+	  };
+
+	  GraphQLEnumType.prototype.toString = function toString() {
+	    return this.name;
+	  };
+
+	  return GraphQLEnumType;
+	}();
+
+	function defineEnumValues(type, valueMap /* <T> */
+	) {
+	  (0, _invariant2.default)(isPlainObj(valueMap), type.name + ' values must be an object with value names as keys.');
+	  var valueNames = Object.keys(valueMap);
+	  (0, _invariant2.default)(valueNames.length > 0, type.name + ' values must be an object with value names as keys.');
+	  return valueNames.map(function (valueName) {
+	    (0, _assertValidName.assertValidName)(valueName);
+	    var value = valueMap[valueName];
+	    (0, _invariant2.default)(isPlainObj(value), type.name + '.' + valueName + ' must refer to an object with a "value" key ' + ('representing an internal value but got: ' + String(value) + '.'));
+	    (0, _invariant2.default)(!value.hasOwnProperty('isDeprecated'), type.name + '.' + valueName + ' should provide "deprecationReason" instead ' + 'of "isDeprecated".');
+	    return {
+	      name: valueName,
+	      description: value.description,
+	      isDeprecated: Boolean(value.deprecationReason),
+	      deprecationReason: value.deprecationReason,
+	      value: (0, _isNullish2.default)(value.value) ? valueName : value.value
+	    };
+	  });
+	} /* <T> */
+
+
+	/**
+	 * Input Object Type Definition
+	 *
+	 * An input object defines a structured collection of fields which may be
+	 * supplied to a field argument.
+	 *
+	 * Using `NonNull` will ensure that a value must be provided by the query
+	 *
+	 * Example:
+	 *
+	 *     const GeoPoint = new GraphQLInputObjectType({
+	 *       name: 'GeoPoint',
+	 *       fields: {
+	 *         lat: { type: new GraphQLNonNull(GraphQLFloat) },
+	 *         lon: { type: new GraphQLNonNull(GraphQLFloat) },
+	 *         alt: { type: GraphQLFloat, defaultValue: 0 },
+	 *       }
+	 *     });
+	 *
+	 */
+	var GraphQLInputObjectType = exports.GraphQLInputObjectType = function () {
+	  function GraphQLInputObjectType(config) {
+	    _classCallCheck(this, GraphQLInputObjectType);
+
+	    (0, _invariant2.default)(config.name, 'Type must be named.');
+	    (0, _assertValidName.assertValidName)(config.name);
+	    this.name = config.name;
+	    this.description = config.description;
+	    this._typeConfig = config;
+	  }
+
+	  GraphQLInputObjectType.prototype.getFields = function getFields() {
+	    return this._fields || (this._fields = this._defineFieldMap());
+	  };
+
+	  GraphQLInputObjectType.prototype._defineFieldMap = function _defineFieldMap() {
+	    var _this3 = this;
+
+	    var fieldMap = resolveThunk(this._typeConfig.fields);
+	    (0, _invariant2.default)(isPlainObj(fieldMap), this.name + ' fields must be an object with field names as keys or a ' + 'function which returns such an object.');
+	    var fieldNames = Object.keys(fieldMap);
+	    (0, _invariant2.default)(fieldNames.length > 0, this.name + ' fields must be an object with field names as keys or a ' + 'function which returns such an object.');
+	    var resultFieldMap = {};
+	    fieldNames.forEach(function (fieldName) {
+	      (0, _assertValidName.assertValidName)(fieldName);
+	      var field = _extends({}, fieldMap[fieldName], {
+	        name: fieldName
+	      });
+	      (0, _invariant2.default)(isInputType(field.type), _this3.name + '.' + fieldName + ' field type must be Input Type but ' + ('got: ' + String(field.type) + '.'));
+	      resultFieldMap[fieldName] = field;
+	    });
+	    return resultFieldMap;
+	  };
+
+	  GraphQLInputObjectType.prototype.toString = function toString() {
+	    return this.name;
+	  };
+
+	  return GraphQLInputObjectType;
+	}();
+
+	/**
+	 * List Modifier
+	 *
+	 * A list is a kind of type marker, a wrapping type which points to another
+	 * type. Lists are often created within the context of defining the fields of
+	 * an object type.
+	 *
+	 * Example:
+	 *
+	 *     const PersonType = new GraphQLObjectType({
+	 *       name: 'Person',
+	 *       fields: () => ({
+	 *         parents: { type: new GraphQLList(Person) },
+	 *         children: { type: new GraphQLList(Person) },
+	 *       })
+	 *     })
+	 *
+	 */
+	var GraphQLList = exports.GraphQLList = function () {
+	  function GraphQLList(type) {
+	    _classCallCheck(this, GraphQLList);
+
+	    (0, _invariant2.default)(isType(type), 'Can only create List of a GraphQLType but got: ' + String(type) + '.');
+	    this.ofType = type;
+	  }
+
+	  GraphQLList.prototype.toString = function toString() {
+	    return '[' + String(this.ofType) + ']';
+	  };
+
+	  return GraphQLList;
+	}();
+
+	/**
+	 * Non-Null Modifier
+	 *
+	 * A non-null is a kind of type marker, a wrapping type which points to another
+	 * type. Non-null types enforce that their values are never null and can ensure
+	 * an error is raised if this ever occurs during a request. It is useful for
+	 * fields which you can make a strong guarantee on non-nullability, for example
+	 * usually the id field of a database row will never be null.
+	 *
+	 * Example:
+	 *
+	 *     const RowType = new GraphQLObjectType({
+	 *       name: 'Row',
+	 *       fields: () => ({
+	 *         id: { type: new GraphQLNonNull(GraphQLString) },
+	 *       })
+	 *     })
+	 *
+	 * Note: the enforcement of non-nullability occurs within the executor.
+	 */
+
+
+	var GraphQLNonNull = exports.GraphQLNonNull = function () {
+	  function GraphQLNonNull(type) {
+	    _classCallCheck(this, GraphQLNonNull);
+
+	    (0, _invariant2.default)(isType(type) && !(type instanceof GraphQLNonNull), 'Can only create NonNull of a Nullable GraphQLType but got: ' + (String(type) + '.'));
+	    this.ofType = type;
+	  }
+
+	  GraphQLNonNull.prototype.toString = function toString() {
+	    return this.ofType.toString() + '!';
+	  };
+
+	  return GraphQLNonNull;
+	}();
+
+/***/ },
+/* 204 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = isNullish;
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	/**
+	 * Returns true if a value is null, undefined, or NaN.
+	 */
+	function isNullish(value) {
+	  return value === null || value === undefined || value !== value;
+	}
+
+/***/ },
+/* 205 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.assertValidName = assertValidName;
+
+	var _invariant = __webpack_require__(200);
+
+	var _invariant2 = _interopRequireDefault(_invariant);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	var NAME_RX = /^[_a-zA-Z][_a-zA-Z0-9]*$/;
+
+	// Helper to assert that provided names are valid.
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function assertValidName(name) {
+	  (0, _invariant2.default)(NAME_RX.test(name), 'Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ but "' + name + '" does not.');
+	}
+
+/***/ },
+/* 206 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.specifiedDirectives = exports.GraphQLDeprecatedDirective = exports.DEFAULT_DEPRECATION_REASON = exports.GraphQLSkipDirective = exports.GraphQLIncludeDirective = exports.GraphQLDirective = exports.DirectiveLocation = undefined;
+
+	var _definition = __webpack_require__(203);
+
+	var _scalars = __webpack_require__(207);
+
+	var _invariant = __webpack_require__(200);
+
+	var _invariant2 = _interopRequireDefault(_invariant);
+
+	var _assertValidName = __webpack_require__(205);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	var DirectiveLocation = exports.DirectiveLocation = {
+	  // Operations
+	  QUERY: 'QUERY',
+	  MUTATION: 'MUTATION',
+	  SUBSCRIPTION: 'SUBSCRIPTION',
+	  FIELD: 'FIELD',
+	  FRAGMENT_DEFINITION: 'FRAGMENT_DEFINITION',
+	  FRAGMENT_SPREAD: 'FRAGMENT_SPREAD',
+	  INLINE_FRAGMENT: 'INLINE_FRAGMENT',
+	  // Schema Definitions
+	  SCHEMA: 'SCHEMA',
+	  SCALAR: 'SCALAR',
+	  OBJECT: 'OBJECT',
+	  FIELD_DEFINITION: 'FIELD_DEFINITION',
+	  ARGUMENT_DEFINITION: 'ARGUMENT_DEFINITION',
+	  INTERFACE: 'INTERFACE',
+	  UNION: 'UNION',
+	  ENUM: 'ENUM',
+	  ENUM_VALUE: 'ENUM_VALUE',
+	  INPUT_OBJECT: 'INPUT_OBJECT',
+	  INPUT_FIELD_DEFINITION: 'INPUT_FIELD_DEFINITION'
+	};
+
+	// eslint-disable-line
+
+	/**
+	 * Directives are used by the GraphQL runtime as a way of modifying execution
+	 * behavior. Type system creators will usually not create these directly.
+	 */
+	var GraphQLDirective = exports.GraphQLDirective = function GraphQLDirective(config) {
+	  _classCallCheck(this, GraphQLDirective);
+
+	  (0, _invariant2.default)(config.name, 'Directive must be named.');
+	  (0, _assertValidName.assertValidName)(config.name);
+	  (0, _invariant2.default)(Array.isArray(config.locations), 'Must provide locations for directive.');
+	  this.name = config.name;
+	  this.description = config.description;
+	  this.locations = config.locations;
+
+	  var args = config.args;
+	  if (!args) {
+	    this.args = [];
+	  } else {
+	    (0, _invariant2.default)(!Array.isArray(args), '@' + config.name + ' args must be an object with argument names as keys.');
+	    this.args = Object.keys(args).map(function (argName) {
+	      (0, _assertValidName.assertValidName)(argName);
+	      var arg = args[argName];
+	      (0, _invariant2.default)((0, _definition.isInputType)(arg.type), '@' + config.name + '(' + argName + ':) argument type must be ' + ('Input Type but got: ' + String(arg.type) + '.'));
+	      return {
+	        name: argName,
+	        description: arg.description === undefined ? null : arg.description,
+	        type: arg.type,
+	        defaultValue: arg.defaultValue === undefined ? null : arg.defaultValue
+	      };
+	    });
+	  }
+	};
+
+	/**
+	 * Used to conditionally include fields or fragments.
+	 */
+	var GraphQLIncludeDirective = exports.GraphQLIncludeDirective = new GraphQLDirective({
+	  name: 'include',
+	  description: 'Directs the executor to include this field or fragment only when ' + 'the `if` argument is true.',
+	  locations: [DirectiveLocation.FIELD, DirectiveLocation.FRAGMENT_SPREAD, DirectiveLocation.INLINE_FRAGMENT],
+	  args: {
+	    if: {
+	      type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
+	      description: 'Included when true.'
+	    }
+	  }
+	});
+
+	/**
+	 * Used to conditionally skip (exclude) fields or fragments.
+	 */
+	var GraphQLSkipDirective = exports.GraphQLSkipDirective = new GraphQLDirective({
+	  name: 'skip',
+	  description: 'Directs the executor to skip this field or fragment when the `if` ' + 'argument is true.',
+	  locations: [DirectiveLocation.FIELD, DirectiveLocation.FRAGMENT_SPREAD, DirectiveLocation.INLINE_FRAGMENT],
+	  args: {
+	    if: {
+	      type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
+	      description: 'Skipped when true.'
+	    }
+	  }
+	});
+
+	/**
+	 * Constant string used for default reason for a deprecation.
+	 */
+	var DEFAULT_DEPRECATION_REASON = exports.DEFAULT_DEPRECATION_REASON = 'No longer supported';
+
+	/**
+	 * Used to declare element of a GraphQL schema as deprecated.
+	 */
+	var GraphQLDeprecatedDirective = exports.GraphQLDeprecatedDirective = new GraphQLDirective({
+	  name: 'deprecated',
+	  description: 'Marks an element of a GraphQL schema as no longer supported.',
+	  locations: [DirectiveLocation.FIELD_DEFINITION, DirectiveLocation.ENUM_VALUE],
+	  args: {
+	    reason: {
+	      type: _scalars.GraphQLString,
+	      description: 'Explains why this element was deprecated, usually also including a ' + 'suggestion for how to access supported similar data. Formatted ' + 'in [Markdown](https://daringfireball.net/projects/markdown/).',
+	      defaultValue: DEFAULT_DEPRECATION_REASON
+	    }
+	  }
+	});
+
+	/**
+	 * The full list of specified directives.
+	 */
+	var specifiedDirectives = exports.specifiedDirectives = [GraphQLIncludeDirective, GraphQLSkipDirective, GraphQLDeprecatedDirective];
+
+/***/ },
+/* 207 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.GraphQLID = exports.GraphQLBoolean = exports.GraphQLString = exports.GraphQLFloat = exports.GraphQLInt = undefined;
+
+	var _definition = __webpack_require__(203);
+
+	var _kinds = __webpack_require__(196);
+
+	var Kind = _interopRequireWildcard(_kinds);
+
+	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+	// As per the GraphQL Spec, Integers are only treated as valid when a valid
+	// 32-bit signed integer, providing the broadest support across platforms.
+	//
+	// n.b. JavaScript's integers are safe between -(2^53 - 1) and 2^53 - 1 because
+	// they are internally represented as IEEE 754 doubles.
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	var MAX_INT = 2147483647;
+	var MIN_INT = -2147483648;
+
+	function coerceInt(value) {
+	  if (value === '') {
+	    throw new TypeError('Int cannot represent non 32-bit signed integer value: (empty string)');
+	  }
+	  var num = Number(value);
+	  if (num === num && num <= MAX_INT && num >= MIN_INT) {
+	    return (num < 0 ? Math.ceil : Math.floor)(num);
+	  }
+	  throw new TypeError('Int cannot represent non 32-bit signed integer value: ' + value);
+	}
+
+	var GraphQLInt = exports.GraphQLInt = new _definition.GraphQLScalarType({
+	  name: 'Int',
+	  description: 'The `Int` scalar type represents non-fractional signed whole numeric ' + 'values. Int can represent values between -(2^31) and 2^31 - 1. ',
+	  serialize: coerceInt,
+	  parseValue: coerceInt,
+	  parseLiteral: function parseLiteral(ast) {
+	    if (ast.kind === Kind.INT) {
+	      var num = parseInt(ast.value, 10);
+	      if (num <= MAX_INT && num >= MIN_INT) {
+	        return num;
+	      }
+	    }
+	    return null;
+	  }
+	});
+
+	function coerceFloat(value) {
+	  if (value === '') {
+	    throw new TypeError('Float cannot represent non numeric value: (empty string)');
+	  }
+	  var num = Number(value);
+	  if (num === num) {
+	    return num;
+	  }
+	  throw new TypeError('Float cannot represent non numeric value: ' + value);
+	}
+
+	var GraphQLFloat = exports.GraphQLFloat = new _definition.GraphQLScalarType({
+	  name: 'Float',
+	  description: 'The `Float` scalar type represents signed double-precision fractional ' + 'values as specified by ' + '[IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point). ',
+	  serialize: coerceFloat,
+	  parseValue: coerceFloat,
+	  parseLiteral: function parseLiteral(ast) {
+	    return ast.kind === Kind.FLOAT || ast.kind === Kind.INT ? parseFloat(ast.value) : null;
+	  }
+	});
+
+	var GraphQLString = exports.GraphQLString = new _definition.GraphQLScalarType({
+	  name: 'String',
+	  description: 'The `String` scalar type represents textual data, represented as UTF-8 ' + 'character sequences. The String type is most often used by GraphQL to ' + 'represent free-form human-readable text.',
+	  serialize: String,
+	  parseValue: String,
+	  parseLiteral: function parseLiteral(ast) {
+	    return ast.kind === Kind.STRING ? ast.value : null;
+	  }
+	});
+
+	var GraphQLBoolean = exports.GraphQLBoolean = new _definition.GraphQLScalarType({
+	  name: 'Boolean',
+	  description: 'The `Boolean` scalar type represents `true` or `false`.',
+	  serialize: Boolean,
+	  parseValue: Boolean,
+	  parseLiteral: function parseLiteral(ast) {
+	    return ast.kind === Kind.BOOLEAN ? ast.value : null;
+	  }
+	});
+
+	var GraphQLID = exports.GraphQLID = new _definition.GraphQLScalarType({
+	  name: 'ID',
+	  description: 'The `ID` scalar type represents a unique identifier, often used to ' + 'refetch an object or as key for a cache. The ID type appears in a JSON ' + 'response as a String; however, it is not intended to be human-readable. ' + 'When expected as an input type, any string (such as `"4"`) or integer ' + '(such as `4`) input value will be accepted as an ID.',
+	  serialize: String,
+	  parseValue: String,
+	  parseLiteral: function parseLiteral(ast) {
+	    return ast.kind === Kind.STRING || ast.kind === Kind.INT ? ast.value : null;
+	  }
+	});
+
+/***/ },
+/* 208 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.TypeNameMetaFieldDef = exports.TypeMetaFieldDef = exports.SchemaMetaFieldDef = exports.__TypeKind = exports.TypeKind = exports.__EnumValue = exports.__InputValue = exports.__Field = exports.__Type = exports.__DirectiveLocation = exports.__Directive = exports.__Schema = undefined;
+
+	var _isNullish = __webpack_require__(204);
+
+	var _isNullish2 = _interopRequireDefault(_isNullish);
+
+	var _astFromValue = __webpack_require__(209);
+
+	var _printer = __webpack_require__(194);
+
+	var _definition = __webpack_require__(203);
+
+	var _scalars = __webpack_require__(207);
+
+	var _directives = __webpack_require__(206);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	var __Schema = exports.__Schema = new _definition.GraphQLObjectType({
+	  name: '__Schema',
+	  description: 'A GraphQL Schema defines the capabilities of a GraphQL server. It ' + 'exposes all available types and directives on the server, as well as ' + 'the entry points for query, mutation, and subscription operations.',
+	  fields: function fields() {
+	    return {
+	      types: {
+	        description: 'A list of all types supported by this server.',
+	        type: new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__Type))),
+	        resolve: function resolve(schema) {
+	          var typeMap = schema.getTypeMap();
+	          return Object.keys(typeMap).map(function (key) {
+	            return typeMap[key];
+	          });
+	        }
+	      },
+	      queryType: {
+	        description: 'The type that query operations will be rooted at.',
+	        type: new _definition.GraphQLNonNull(__Type),
+	        resolve: function resolve(schema) {
+	          return schema.getQueryType();
+	        }
+	      },
+	      mutationType: {
+	        description: 'If this server supports mutation, the type that ' + 'mutation operations will be rooted at.',
+	        type: __Type,
+	        resolve: function resolve(schema) {
+	          return schema.getMutationType();
+	        }
+	      },
+	      subscriptionType: {
+	        description: 'If this server support subscription, the type that ' + 'subscription operations will be rooted at.',
+	        type: __Type,
+	        resolve: function resolve(schema) {
+	          return schema.getSubscriptionType();
+	        }
+	      },
+	      directives: {
+	        description: 'A list of all directives supported by this server.',
+	        type: new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__Directive))),
+	        resolve: function resolve(schema) {
+	          return schema.getDirectives();
+	        }
+	      }
+	    };
+	  }
+	});
+
+	var __Directive = exports.__Directive = new _definition.GraphQLObjectType({
+	  name: '__Directive',
+	  description: 'A Directive provides a way to describe alternate runtime execution and ' + 'type validation behavior in a GraphQL document.' + '\n\nIn some cases, you need to provide options to alter GraphQL\'s ' + 'execution behavior in ways field arguments will not suffice, such as ' + 'conditionally including or skipping a field. Directives provide this by ' + 'describing additional information to the executor.',
+	  fields: function fields() {
+	    return {
+	      name: { type: new _definition.GraphQLNonNull(_scalars.GraphQLString) },
+	      description: { type: _scalars.GraphQLString },
+	      locations: {
+	        type: new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__DirectiveLocation)))
+	      },
+	      args: {
+	        type: new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__InputValue))),
+	        resolve: function resolve(directive) {
+	          return directive.args || [];
+	        }
+	      },
+	      // NOTE: the following three fields are deprecated and are no longer part
+	      // of the GraphQL specification.
+	      onOperation: {
+	        deprecationReason: 'Use `locations`.',
+	        type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
+	        resolve: function resolve(d) {
+	          return d.locations.indexOf(_directives.DirectiveLocation.QUERY) !== -1 || d.locations.indexOf(_directives.DirectiveLocation.MUTATION) !== -1 || d.locations.indexOf(_directives.DirectiveLocation.SUBSCRIPTION) !== -1;
+	        }
+	      },
+	      onFragment: {
+	        deprecationReason: 'Use `locations`.',
+	        type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
+	        resolve: function resolve(d) {
+	          return d.locations.indexOf(_directives.DirectiveLocation.FRAGMENT_SPREAD) !== -1 || d.locations.indexOf(_directives.DirectiveLocation.INLINE_FRAGMENT) !== -1 || d.locations.indexOf(_directives.DirectiveLocation.FRAGMENT_DEFINITION) !== -1;
+	        }
+	      },
+	      onField: {
+	        deprecationReason: 'Use `locations`.',
+	        type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
+	        resolve: function resolve(d) {
+	          return d.locations.indexOf(_directives.DirectiveLocation.FIELD) !== -1;
+	        }
+	      }
+	    };
+	  }
+	});
+
+	var __DirectiveLocation = exports.__DirectiveLocation = new _definition.GraphQLEnumType({
+	  name: '__DirectiveLocation',
+	  description: 'A Directive can be adjacent to many parts of the GraphQL language, a ' + '__DirectiveLocation describes one such possible adjacencies.',
+	  values: {
+	    QUERY: {
+	      value: _directives.DirectiveLocation.QUERY,
+	      description: 'Location adjacent to a query operation.'
+	    },
+	    MUTATION: {
+	      value: _directives.DirectiveLocation.MUTATION,
+	      description: 'Location adjacent to a mutation operation.'
+	    },
+	    SUBSCRIPTION: {
+	      value: _directives.DirectiveLocation.SUBSCRIPTION,
+	      description: 'Location adjacent to a subscription operation.'
+	    },
+	    FIELD: {
+	      value: _directives.DirectiveLocation.FIELD,
+	      description: 'Location adjacent to a field.'
+	    },
+	    FRAGMENT_DEFINITION: {
+	      value: _directives.DirectiveLocation.FRAGMENT_DEFINITION,
+	      description: 'Location adjacent to a fragment definition.'
+	    },
+	    FRAGMENT_SPREAD: {
+	      value: _directives.DirectiveLocation.FRAGMENT_SPREAD,
+	      description: 'Location adjacent to a fragment spread.'
+	    },
+	    INLINE_FRAGMENT: {
+	      value: _directives.DirectiveLocation.INLINE_FRAGMENT,
+	      description: 'Location adjacent to an inline fragment.'
+	    },
+	    SCHEMA: {
+	      value: _directives.DirectiveLocation.SCHEMA,
+	      description: 'Location adjacent to a schema definition.'
+	    },
+	    SCALAR: {
+	      value: _directives.DirectiveLocation.SCALAR,
+	      description: 'Location adjacent to a scalar definition.'
+	    },
+	    OBJECT: {
+	      value: _directives.DirectiveLocation.OBJECT,
+	      description: 'Location adjacent to an object type definition.'
+	    },
+	    FIELD_DEFINITION: {
+	      value: _directives.DirectiveLocation.FIELD_DEFINITION,
+	      description: 'Location adjacent to a field definition.'
+	    },
+	    ARGUMENT_DEFINITION: {
+	      value: _directives.DirectiveLocation.ARGUMENT_DEFINITION,
+	      description: 'Location adjacent to an argument definition.'
+	    },
+	    INTERFACE: {
+	      value: _directives.DirectiveLocation.INTERFACE,
+	      description: 'Location adjacent to an interface definition.'
+	    },
+	    UNION: {
+	      value: _directives.DirectiveLocation.UNION,
+	      description: 'Location adjacent to a union definition.'
+	    },
+	    ENUM: {
+	      value: _directives.DirectiveLocation.ENUM,
+	      description: 'Location adjacent to an enum definition.'
+	    },
+	    ENUM_VALUE: {
+	      value: _directives.DirectiveLocation.ENUM_VALUE,
+	      description: 'Location adjacent to an enum value definition.'
+	    },
+	    INPUT_OBJECT: {
+	      value: _directives.DirectiveLocation.INPUT_OBJECT,
+	      description: 'Location adjacent to an input object type definition.'
+	    },
+	    INPUT_FIELD_DEFINITION: {
+	      value: _directives.DirectiveLocation.INPUT_FIELD_DEFINITION,
+	      description: 'Location adjacent to an input object field definition.'
+	    }
+	  }
+	});
+
+	var __Type = exports.__Type = new _definition.GraphQLObjectType({
+	  name: '__Type',
+	  description: 'The fundamental unit of any GraphQL Schema is the type. There are ' + 'many kinds of types in GraphQL as represented by the `__TypeKind` enum.' + '\n\nDepending on the kind of a type, certain fields describe ' + 'information about that type. Scalar types provide no information ' + 'beyond a name and description, while Enum types provide their values. ' + 'Object and Interface types provide the fields they describe. Abstract ' + 'types, Union and Interface, provide the Object types possible ' + 'at runtime. List and NonNull types compose other types.',
+	  fields: function fields() {
+	    return {
+	      kind: {
+	        type: new _definition.GraphQLNonNull(__TypeKind),
+	        resolve: function resolve(type) {
+	          if (type instanceof _definition.GraphQLScalarType) {
+	            return TypeKind.SCALAR;
+	          } else if (type instanceof _definition.GraphQLObjectType) {
+	            return TypeKind.OBJECT;
+	          } else if (type instanceof _definition.GraphQLInterfaceType) {
+	            return TypeKind.INTERFACE;
+	          } else if (type instanceof _definition.GraphQLUnionType) {
+	            return TypeKind.UNION;
+	          } else if (type instanceof _definition.GraphQLEnumType) {
+	            return TypeKind.ENUM;
+	          } else if (type instanceof _definition.GraphQLInputObjectType) {
+	            return TypeKind.INPUT_OBJECT;
+	          } else if (type instanceof _definition.GraphQLList) {
+	            return TypeKind.LIST;
+	          } else if (type instanceof _definition.GraphQLNonNull) {
+	            return TypeKind.NON_NULL;
+	          }
+	          throw new Error('Unknown kind of type: ' + type);
+	        }
+	      },
+	      name: { type: _scalars.GraphQLString },
+	      description: { type: _scalars.GraphQLString },
+	      fields: {
+	        type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__Field)),
+	        args: {
+	          includeDeprecated: { type: _scalars.GraphQLBoolean, defaultValue: false }
+	        },
+	        resolve: function resolve(type, _ref) {
+	          var includeDeprecated = _ref.includeDeprecated;
+
+	          if (type instanceof _definition.GraphQLObjectType || type instanceof _definition.GraphQLInterfaceType) {
+	            var _ret = function () {
+	              var fieldMap = type.getFields();
+	              var fields = Object.keys(fieldMap).map(function (fieldName) {
+	                return fieldMap[fieldName];
+	              });
+	              if (!includeDeprecated) {
+	                fields = fields.filter(function (field) {
+	                  return !field.deprecationReason;
+	                });
+	              }
+	              return {
+	                v: fields
+	              };
+	            }();
+
+	            if (typeof _ret === "object") return _ret.v;
+	          }
+	          return null;
+	        }
+	      },
+	      interfaces: {
+	        type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__Type)),
+	        resolve: function resolve(type) {
+	          if (type instanceof _definition.GraphQLObjectType) {
+	            return type.getInterfaces();
+	          }
+	        }
+	      },
+	      possibleTypes: {
+	        type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__Type)),
+	        resolve: function resolve(type, args, context, _ref2) {
+	          var schema = _ref2.schema;
+
+	          if (type instanceof _definition.GraphQLInterfaceType || type instanceof _definition.GraphQLUnionType) {
+	            return schema.getPossibleTypes(type);
+	          }
+	        }
+	      },
+	      enumValues: {
+	        type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__EnumValue)),
+	        args: {
+	          includeDeprecated: { type: _scalars.GraphQLBoolean, defaultValue: false }
+	        },
+	        resolve: function resolve(type, _ref3) {
+	          var includeDeprecated = _ref3.includeDeprecated;
+
+	          if (type instanceof _definition.GraphQLEnumType) {
+	            var values = type.getValues();
+	            if (!includeDeprecated) {
+	              values = values.filter(function (value) {
+	                return !value.deprecationReason;
+	              });
+	            }
+	            return values;
+	          }
+	        }
+	      },
+	      inputFields: {
+	        type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__InputValue)),
+	        resolve: function resolve(type) {
+	          if (type instanceof _definition.GraphQLInputObjectType) {
+	            var _ret2 = function () {
+	              var fieldMap = type.getFields();
+	              return {
+	                v: Object.keys(fieldMap).map(function (fieldName) {
+	                  return fieldMap[fieldName];
+	                })
+	              };
+	            }();
+
+	            if (typeof _ret2 === "object") return _ret2.v;
+	          }
+	        }
+	      },
+	      ofType: { type: __Type }
+	    };
+	  }
+	});
+
+	var __Field = exports.__Field = new _definition.GraphQLObjectType({
+	  name: '__Field',
+	  description: 'Object and Interface types are described by a list of Fields, each of ' + 'which has a name, potentially a list of arguments, and a return type.',
+	  fields: function fields() {
+	    return {
+	      name: { type: new _definition.GraphQLNonNull(_scalars.GraphQLString) },
+	      description: { type: _scalars.GraphQLString },
+	      args: {
+	        type: new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__InputValue))),
+	        resolve: function resolve(field) {
+	          return field.args || [];
+	        }
+	      },
+	      type: { type: new _definition.GraphQLNonNull(__Type) },
+	      isDeprecated: { type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean) },
+	      deprecationReason: {
+	        type: _scalars.GraphQLString
+	      }
+	    };
+	  }
+	});
+
+	var __InputValue = exports.__InputValue = new _definition.GraphQLObjectType({
+	  name: '__InputValue',
+	  description: 'Arguments provided to Fields or Directives and the input fields of an ' + 'InputObject are represented as Input Values which describe their type ' + 'and optionally a default value.',
+	  fields: function fields() {
+	    return {
+	      name: { type: new _definition.GraphQLNonNull(_scalars.GraphQLString) },
+	      description: { type: _scalars.GraphQLString },
+	      type: { type: new _definition.GraphQLNonNull(__Type) },
+	      defaultValue: {
+	        type: _scalars.GraphQLString,
+	        description: 'A GraphQL-formatted string representing the default value for this ' + 'input value.',
+	        resolve: function resolve(inputVal) {
+	          return (0, _isNullish2.default)(inputVal.defaultValue) ? null : (0, _printer.print)((0, _astFromValue.astFromValue)(inputVal.defaultValue, inputVal.type));
+	        }
+	      }
+	    };
+	  }
+	});
+
+	var __EnumValue = exports.__EnumValue = new _definition.GraphQLObjectType({
+	  name: '__EnumValue',
+	  description: 'One possible value for a given Enum. Enum values are unique values, not ' + 'a placeholder for a string or numeric value. However an Enum value is ' + 'returned in a JSON response as a string.',
+	  fields: function fields() {
+	    return {
+	      name: { type: new _definition.GraphQLNonNull(_scalars.GraphQLString) },
+	      description: { type: _scalars.GraphQLString },
+	      isDeprecated: { type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean) },
+	      deprecationReason: {
+	        type: _scalars.GraphQLString
+	      }
+	    };
+	  }
+	});
+
+	var TypeKind = exports.TypeKind = {
+	  SCALAR: 'SCALAR',
+	  OBJECT: 'OBJECT',
+	  INTERFACE: 'INTERFACE',
+	  UNION: 'UNION',
+	  ENUM: 'ENUM',
+	  INPUT_OBJECT: 'INPUT_OBJECT',
+	  LIST: 'LIST',
+	  NON_NULL: 'NON_NULL'
+	};
+
+	var __TypeKind = exports.__TypeKind = new _definition.GraphQLEnumType({
+	  name: '__TypeKind',
+	  description: 'An enum describing what kind of type a given `__Type` is.',
+	  values: {
+	    SCALAR: {
+	      value: TypeKind.SCALAR,
+	      description: 'Indicates this type is a scalar.'
+	    },
+	    OBJECT: {
+	      value: TypeKind.OBJECT,
+	      description: 'Indicates this type is an object. ' + '`fields` and `interfaces` are valid fields.'
+	    },
+	    INTERFACE: {
+	      value: TypeKind.INTERFACE,
+	      description: 'Indicates this type is an interface. ' + '`fields` and `possibleTypes` are valid fields.'
+	    },
+	    UNION: {
+	      value: TypeKind.UNION,
+	      description: 'Indicates this type is a union. ' + '`possibleTypes` is a valid field.'
+	    },
+	    ENUM: {
+	      value: TypeKind.ENUM,
+	      description: 'Indicates this type is an enum. ' + '`enumValues` is a valid field.'
+	    },
+	    INPUT_OBJECT: {
+	      value: TypeKind.INPUT_OBJECT,
+	      description: 'Indicates this type is an input object. ' + '`inputFields` is a valid field.'
+	    },
+	    LIST: {
+	      value: TypeKind.LIST,
+	      description: 'Indicates this type is a list. ' + '`ofType` is a valid field.'
+	    },
+	    NON_NULL: {
+	      value: TypeKind.NON_NULL,
+	      description: 'Indicates this type is a non-null. ' + '`ofType` is a valid field.'
+	    }
+	  }
+	});
+
+	/**
+	 * Note that these are GraphQLFieldDefinition and not GraphQLFieldConfig,
+	 * so the format for args is different.
+	 */
+
+	var SchemaMetaFieldDef = exports.SchemaMetaFieldDef = {
+	  name: '__schema',
+	  type: new _definition.GraphQLNonNull(__Schema),
+	  description: 'Access the current type schema of this server.',
+	  args: [],
+	  resolve: function resolve(source, args, context, _ref4) {
+	    var schema = _ref4.schema;
+	    return schema;
+	  }
+	};
+
+	var TypeMetaFieldDef = exports.TypeMetaFieldDef = {
+	  name: '__type',
+	  type: __Type,
+	  description: 'Request the type information of a single type.',
+	  args: [{ name: 'name', type: new _definition.GraphQLNonNull(_scalars.GraphQLString) }],
+	  resolve: function resolve(source, _ref5, context, _ref6) {
+	    var name = _ref5.name;
+	    var schema = _ref6.schema;
+	    return schema.getType(name);
+	  }
+	};
+
+	var TypeNameMetaFieldDef = exports.TypeNameMetaFieldDef = {
+	  name: '__typename',
+	  type: new _definition.GraphQLNonNull(_scalars.GraphQLString),
+	  description: 'The name of the current Object type at runtime.',
+	  args: [],
+	  resolve: function resolve(source, args, context, _ref7) {
+	    var parentType = _ref7.parentType;
+	    return parentType.name;
+	  }
+	};
+
+/***/ },
+/* 209 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.astFromValue = astFromValue;
+
+	var _iterall = __webpack_require__(210);
+
+	var _invariant = __webpack_require__(200);
+
+	var _invariant2 = _interopRequireDefault(_invariant);
+
+	var _isNullish = __webpack_require__(204);
+
+	var _isNullish2 = _interopRequireDefault(_isNullish);
+
+	var _kinds = __webpack_require__(196);
+
+	var _definition = __webpack_require__(203);
+
+	var _scalars = __webpack_require__(207);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 * Produces a GraphQL Value AST given a JavaScript value.
+	 *
+	 * A GraphQL type must be provided, which will be used to interpret different
+	 * JavaScript values.
+	 *
+	 * | JSON Value    | GraphQL Value        |
+	 * | ------------- | -------------------- |
+	 * | Object        | Input Object         |
+	 * | Array         | List                 |
+	 * | Boolean       | Boolean              |
+	 * | String        | String / Enum Value  |
+	 * | Number        | Int / Float          |
+	 * | Mixed         | Enum Value           |
+	 *
+	 */
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function astFromValue(value, type) {
+	  // Ensure flow knows that we treat function params as const.
+	  var _value = value;
+
+	  if (type instanceof _definition.GraphQLNonNull) {
+	    // Note: we're not checking that the result is non-null.
+	    // This function is not responsible for validating the input value.
+	    return astFromValue(_value, type.ofType);
+	  }
+
+	  if ((0, _isNullish2.default)(_value)) {
+	    return null;
+	  }
+
+	  // Convert JavaScript array to GraphQL list. If the GraphQLType is a list, but
+	  // the value is not an array, convert the value using the list's item type.
+	  if (type instanceof _definition.GraphQLList) {
+	    var _ret = function () {
+	      var itemType = type.ofType;
+	      if ((0, _iterall.isCollection)(_value)) {
+	        var _ret2 = function () {
+	          var valuesASTs = [];
+	          (0, _iterall.forEach)(_value, function (item) {
+	            var itemAST = astFromValue(item, itemType);
+	            if (itemAST) {
+	              valuesASTs.push(itemAST);
+	            }
+	          });
+	          return {
+	            v: {
+	              v: { kind: _kinds.LIST, values: valuesASTs }
+	            }
+	          };
+	        }();
+
+	        if (typeof _ret2 === "object") return _ret2.v;
+	      }
+	      return {
+	        v: astFromValue(_value, itemType)
+	      };
+	    }();
+
+	    if (typeof _ret === "object") return _ret.v;
+	  }
+
+	  // Populate the fields of the input object by creating ASTs from each value
+	  // in the JavaScript object according to the fields in the input type.
+	  if (type instanceof _definition.GraphQLInputObjectType) {
+	    var _ret3 = function () {
+	      if (_value === null || typeof _value !== 'object') {
+	        return {
+	          v: null
+	        };
+	      }
+	      var fields = type.getFields();
+	      var fieldASTs = [];
+	      Object.keys(fields).forEach(function (fieldName) {
+	        var fieldType = fields[fieldName].type;
+	        var fieldValue = astFromValue(_value[fieldName], fieldType);
+	        if (fieldValue) {
+	          fieldASTs.push({
+	            kind: _kinds.OBJECT_FIELD,
+	            name: { kind: _kinds.NAME, value: fieldName },
+	            value: fieldValue
+	          });
+	        }
+	      });
+	      return {
+	        v: { kind: _kinds.OBJECT, fields: fieldASTs }
+	      };
+	    }();
+
+	    if (typeof _ret3 === "object") return _ret3.v;
+	  }
+
+	  (0, _invariant2.default)(type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType, 'Must provide Input Type, cannot use: ' + String(type));
+
+	  // Since value is an internally represented value, it must be serialized
+	  // to an externally represented value before converting into an AST.
+	  var serialized = type.serialize(_value);
+	  if ((0, _isNullish2.default)(serialized)) {
+	    return null;
+	  }
+
+	  // Others serialize based on their corresponding JavaScript scalar types.
+	  if (typeof serialized === 'boolean') {
+	    return { kind: _kinds.BOOLEAN, value: serialized };
+	  }
+
+	  // JavaScript numbers can be Int or Float values.
+	  if (typeof serialized === 'number') {
+	    var stringNum = String(serialized);
+	    return (/^[0-9]+$/.test(stringNum) ? { kind: _kinds.INT, value: stringNum } : { kind: _kinds.FLOAT, value: stringNum }
+	    );
+	  }
+
+	  if (typeof serialized === 'string') {
+	    // Enum types use Enum literals.
+	    if (type instanceof _definition.GraphQLEnumType) {
+	      return { kind: _kinds.ENUM, value: serialized };
+	    }
+
+	    // ID types can use Int literals.
+	    if (type === _scalars.GraphQLID && /^[0-9]+$/.test(serialized)) {
+	      return { kind: _kinds.INT, value: serialized };
+	    }
+
+	    // Use JSON stringify, which uses the same string encoding as GraphQL,
+	    // then remove the quotes.
+	    return {
+	      kind: _kinds.STRING,
+	      value: JSON.stringify(serialized).slice(1, -1)
+	    };
+	  }
+
+	  throw new TypeError('Cannot convert value to AST: ' + String(serialized));
+	}
+
+/***/ },
+/* 210 */
+/***/ function(module, exports) {
+
+	/**
+	 * Copyright (c) 2016, Lee Byron
+	 * All rights reserved.
+	 *
+	 * This source code is licensed under the MIT license found in the
+	 * LICENSE file in the root directory of this source tree.
+	 *
+	 * @ignore
+	 */
+
+	/**
+	 * [Iterator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterator)
+	 * is a *protocol* which describes a standard way to produce a sequence of
+	 * values, typically the values of the Iterable represented by this Iterator.
+	 *
+	 * While described by the [ES2015 version of JavaScript](http://www.ecma-international.org/ecma-262/6.0/#sec-iterator-interface)
+	 * it can be utilized by any version of JavaScript.
+	 *
+	 * @typedef {Object} Iterator
+	 * @template T The type of each iterated value
+	 * @property {function (): { value: T, done: boolean }} next
+	 *   A method which produces either the next value in a sequence or a result
+	 *   where the `done` property is `true` indicating the end of the Iterator.
+	 */
+
+	/**
+	 * [Iterable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterable)
+	 * is a *protocol* which when implemented allows a JavaScript object to define
+	 * their iteration behavior, such as what values are looped over in a `for..of`
+	 * loop or `iterall`'s `forEach` function. Many [built-in types](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#Builtin_iterables)
+	 * implement the Iterable protocol, including `Array` and `Map`.
+	 *
+	 * While described by the [ES2015 version of JavaScript](http://www.ecma-international.org/ecma-262/6.0/#sec-iterable-interface)
+	 * it can be utilized by any version of JavaScript.
+	 *
+	 * @typedef {Object} Iterable
+	 * @template T The type of each iterated value
+	 * @property {function (): Iterator<T>} Symbol.iterator
+	 *   A method which produces an Iterator for this Iterable.
+	 */
+
+	// In ES2015 (or a polyfilled) environment, this will be Symbol.iterator
+	var SYMBOL_ITERATOR = typeof Symbol === 'function' && Symbol.iterator
+
+	/**
+	 * A property name to be used as the name of an Iterable's method responsible
+	 * for producing an Iterator, referred to as `@@iterator`. Typically represents
+	 * the value `Symbol.iterator` but falls back to the string `"@@iterator"` when
+	 * `Symbol.iterator` is not defined.
+	 *
+	 * Use `$$iterator` for defining new Iterables instead of `Symbol.iterator`,
+	 * but do not use it for accessing existing Iterables, instead use
+	 * `getIterator()` or `isIterable()`.
+	 *
+	 * @example
+	 *
+	 * var $$iterator = require('iterall').$$iterator
+	 *
+	 * function Counter (to) {
+	 *   this.to = to
+	 * }
+	 *
+	 * Counter.prototype[$$iterator] = function () {
+	 *   return {
+	 *     to: this.to,
+	 *     num: 0,
+	 *     next () {
+	 *       if (this.num >= this.to) {
+	 *         return { value: undefined, done: true }
+	 *       }
+	 *       return { value: this.num++, done: false }
+	 *     }
+	 *   }
+	 * }
+	 *
+	 * var counter = new Counter(3)
+	 * for (var number of counter) {
+	 *   console.log(number) // 0 ... 1 ... 2
+	 * }
+	 *
+	 * @type {Symbol|string}
+	 */
+	var $$iterator = SYMBOL_ITERATOR || '@@iterator'
+	exports.$$iterator = $$iterator
+
+	/**
+	 * Returns true if the provided object implements the Iterator protocol via
+	 * either implementing a `Symbol.iterator` or `"@@iterator"` method.
+	 *
+	 * @example
+	 *
+	 * var isIterable = require('iterall').isIterable
+	 * isIterable([ 1, 2, 3 ]) // true
+	 * isIterable('ABC') // true
+	 * isIterable({ length: 1, 0: 'Alpha' }) // false
+	 * isIterable({ key: 'value' }) // false
+	 * isIterable(new Map()) // true
+	 *
+	 * @param obj
+	 *   A value which might implement the Iterable protocol.
+	 * @return {boolean} true if Iterable.
+	 */
+	function isIterable (obj) {
+	  return !!getIteratorMethod(obj)
+	}
+	exports.isIterable = isIterable
+
+	/**
+	 * Returns true if the provided object implements the Array-like protocol via
+	 * defining a positive-integer `length` property.
+	 *
+	 * @example
+	 *
+	 * var isArrayLike = require('iterall').isArrayLike
+	 * isArrayLike([ 1, 2, 3 ]) // true
+	 * isArrayLike('ABC') // true
+	 * isArrayLike({ length: 1, 0: 'Alpha' }) // true
+	 * isArrayLike({ key: 'value' }) // false
+	 * isArrayLike(new Map()) // false
+	 *
+	 * @param obj
+	 *   A value which might implement the Array-like protocol.
+	 * @return {boolean} true if Array-like.
+	 */
+	function isArrayLike (obj) {
+	  var length = obj != null && obj.length
+	  return typeof length === 'number' && length >= 0 && length % 1 === 0
+	}
+	exports.isArrayLike = isArrayLike
+
+	/**
+	 * Returns true if the provided object is an Object (i.e. not a string literal)
+	 * and is either Iterable or Array-like.
+	 *
+	 * This may be used in place of [Array.isArray()][isArray] to determine if an
+	 * object should be iterated-over. It always excludes string literals and
+	 * includes Arrays (regardless of if it is Iterable). It also includes other
+	 * Array-like objects such as NodeList, TypedArray, and Buffer.
+	 *
+	 * @example
+	 *
+	 * var isCollection = require('iterall').isCollection
+	 * isCollection([ 1, 2, 3 ]) // true
+	 * isCollection('ABC') // false
+	 * isCollection({ length: 1, 0: 'Alpha' }) // true
+	 * isCollection({ key: 'value' }) // false
+	 * isCollection(new Map()) // true
+	 *
+	 * @example
+	 *
+	 * var forEach = require('iterall').forEach
+	 * if (isCollection(obj)) {
+	 *   forEach(obj, function (value) {
+	 *     console.log(value)
+	 *   })
+	 * }
+	 *
+	 * @param obj
+	 *   An Object value which might implement the Iterable or Array-like protocols.
+	 * @return {boolean} true if Iterable or Array-like Object.
+	 */
+	function isCollection (obj) {
+	  return Object(obj) === obj && (isArrayLike(obj) || isIterable(obj))
+	}
+	exports.isCollection = isCollection
+
+	/**
+	 * If the provided object implements the Iterator protocol, its Iterator object
+	 * is returned. Otherwise returns undefined.
+	 *
+	 * @example
+	 *
+	 * var getIterator = require('iterall').getIterator
+	 * var iterator = getIterator([ 1, 2, 3 ])
+	 * iterator.next() // { value: 1, done: false }
+	 * iterator.next() // { value: 2, done: false }
+	 * iterator.next() // { value: 3, done: false }
+	 * iterator.next() // { value: undefined, done: true }
+	 *
+	 * @template T the type of each iterated value
+	 * @param {Iterable<T>} iterable
+	 *   An Iterable object which is the source of an Iterator.
+	 * @return {Iterator<T>} new Iterator instance.
+	 */
+	function getIterator (iterable) {
+	  var method = getIteratorMethod(iterable)
+	  if (method) {
+	    return method.call(iterable)
+	  }
+	}
+	exports.getIterator = getIterator
+
+	/**
+	 * If the provided object implements the Iterator protocol, the method
+	 * responsible for producing its Iterator object is returned.
+	 *
+	 * This is used in rare cases for performance tuning. This method must be called
+	 * with obj as the contextual this-argument.
+	 *
+	 * @example
+	 *
+	 * var getIteratorMethod = require('iterall').getIteratorMethod
+	 * var myArray = [ 1, 2, 3 ]
+	 * var method = getIteratorMethod(myArray)
+	 * if (method) {
+	 *   var iterator = method.call(myArray)
+	 * }
+	 *
+	 * @template T the type of each iterated value
+	 * @param {Iterable<T>} iterable
+	 *   An Iterable object which defines an `@@iterator` method.
+	 * @return {function(): Iterator<T>} `@@iterator` method.
+	 */
+	function getIteratorMethod (iterable) {
+	  if (iterable != null) {
+	    var method = SYMBOL_ITERATOR && iterable[SYMBOL_ITERATOR] || iterable['@@iterator']
+	    if (typeof method === 'function') {
+	      return method
+	    }
+	  }
+	}
+	exports.getIteratorMethod = getIteratorMethod
+
+	/**
+	 * Given an object which either implements the Iterable protocol or is
+	 * Array-like, iterate over it, calling the `callback` at each iteration.
+	 *
+	 * Use `forEach` where you would expect to use a `for ... of` loop in ES6.
+	 * However `forEach` adheres to the behavior of [Array#forEach][] described in
+	 * the ECMAScript specification, skipping over "holes" in Array-likes. It will
+	 * also delegate to a `forEach` method on `collection` if one is defined,
+	 * ensuring native performance for `Arrays`.
+	 *
+	 * Similar to [Array#forEach][], the `callback` function accepts three
+	 * arguments, and is provided with `thisArg` as the calling context.
+	 *
+	 * Note: providing an infinite Iterator to forEach will produce an error.
+	 *
+	 * [Array#forEach]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach
+	 *
+	 * @example
+	 *
+	 * var forEach = require('iterall').forEach
+	 *
+	 * forEach(myIterable, function (value, index, iterable) {
+	 *   console.log(value, index, iterable === myIterable)
+	 * })
+	 *
+	 * @example
+	 *
+	 * // ES6:
+	 * for (let value of myIterable) {
+	 *   console.log(value)
+	 * }
+	 *
+	 * // Any JavaScript environment:
+	 * forEach(myIterable, function (value) {
+	 *   console.log(value)
+	 * })
+	 *
+	 * @template T the type of each iterated value
+	 * @param {Iterable<T>|{ length: number }} collection
+	 *   The Iterable or array to iterate over.
+	 * @param {function(T, number, object)} callback
+	 *   Function to execute for each iteration, taking up to three arguments
+	 * @param [thisArg]
+	 *   Optional. Value to use as `this` when executing `callback`.
+	 */
+	function forEach (collection, callback, thisArg) {
+	  if (collection != null) {
+	    if (typeof collection.forEach === 'function') {
+	      return collection.forEach(callback, thisArg)
+	    }
+	    var i = 0
+	    var iterator = getIterator(collection)
+	    if (iterator) {
+	      var step
+	      while (!(step = iterator.next()).done) {
+	        callback.call(thisArg, step.value, i++, collection)
+	        // Infinite Iterators could cause forEach to run forever.
+	        // After a very large number of iterations, produce an error.
+	        /* istanbul ignore if */
+	        if (i > 9999999) {
+	          throw new TypeError('Near-infinite iteration.')
+	        }
+	      }
+	    } else if (isArrayLike(collection)) {
+	      for (; i < collection.length; i++) {
+	        if (collection.hasOwnProperty(i)) {
+	          callback.call(thisArg, collection[i], i, collection)
+	        }
+	      }
+	    }
+	  }
+	}
+	exports.forEach = forEach
+
+	/**
+	 * Similar to `getIterator()`, this method returns a new Iterator given an
+	 * Iterable. However it will also create an Iterator for a non-Iterable
+	 * Array-like collection, such as Array in a non-ES2015 environment.
+	 *
+	 * `createIterator` is complimentary to `forEach`, but allows a "pull"-based
+	 * iteration as opposed to `forEach`'s "push"-based iteration.
+	 *
+	 * `createIterator` produces an Iterator for Array-likes with the same behavior
+	 * as ArrayIteratorPrototype described in the ECMAScript specification, and
+	 * does *not* skip over "holes".
+	 *
+	 * @example
+	 *
+	 * var createIterator = require('iterall').createIterator
+	 *
+	 * var myArraylike = { length: 3, 0: 'Alpha', 1: 'Bravo', 2: 'Charlie' }
+	 * var iterator = createIterator(myArraylike)
+	 * iterator.next() // { value: 'Alpha', done: false }
+	 * iterator.next() // { value: 'Bravo', done: false }
+	 * iterator.next() // { value: 'Charlie', done: false }
+	 * iterator.next() // { value: undefined, done: true }
+	 *
+	 * @template T the type of each iterated value
+	 * @param {Iterable<T>|{ length: number }} collection
+	 *   An Iterable or Array-like object to produce an Iterator.
+	 * @return {Iterator<T>} new Iterator instance.
+	 */
+	function createIterator (collection) {
+	  if (collection != null) {
+	    var iterator = getIterator(collection)
+	    if (iterator) {
+	      return iterator
+	    }
+	    if (isArrayLike(collection)) {
+	      return new ArrayLikeIterator(collection)
+	    }
+	  }
+	}
+	exports.createIterator = createIterator
+
+	// When the object provided to `createIterator` is not Iterable but is
+	// Array-like, this simple Iterator is created.
+	function ArrayLikeIterator (obj) {
+	  this._o = obj
+	  this._i = 0
+	}
+
+	// Note: all Iterators are themselves Iterable.
+	ArrayLikeIterator.prototype[$$iterator] = function () {
+	  return this
+	}
+
+	// A simple state-machine determines the IteratorResult returned, yielding
+	// each value in the Array-like object in order of their indicies.
+	ArrayLikeIterator.prototype.next = function () {
+	  if (this._o === void 0 || this._i >= this._o.length) {
+	    this._o = void 0
+	    return { value: void 0, done: true }
+	  }
+	  return { value: this._o[this._i++], done: false }
+	}
+
+
+/***/ },
+/* 211 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = find;
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function find(list, predicate) {
+	  for (var i = 0; i < list.length; i++) {
+	    if (predicate(list[i])) {
+	      return list[i];
+	    }
+	  }
+	}
+
+/***/ },
+/* 212 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.isEqualType = isEqualType;
+	exports.isTypeSubTypeOf = isTypeSubTypeOf;
+	exports.doTypesOverlap = doTypesOverlap;
+
+	var _definition = __webpack_require__(203);
+
+	/**
+	 * Provided two types, return true if the types are equal (invariant).
+	 */
+	function isEqualType(typeA, typeB) {
+	  // Equivalent types are equal.
+	  if (typeA === typeB) {
+	    return true;
+	  }
+
+	  // If either type is non-null, the other must also be non-null.
+	  if (typeA instanceof _definition.GraphQLNonNull && typeB instanceof _definition.GraphQLNonNull) {
+	    return isEqualType(typeA.ofType, typeB.ofType);
+	  }
+
+	  // If either type is a list, the other must also be a list.
+	  if (typeA instanceof _definition.GraphQLList && typeB instanceof _definition.GraphQLList) {
+	    return isEqualType(typeA.ofType, typeB.ofType);
+	  }
+
+	  // Otherwise the types are not equal.
+	  return false;
+	}
+
+	/**
+	 * Provided a type and a super type, return true if the first type is either
+	 * equal or a subset of the second super type (covariant).
+	 */
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function isTypeSubTypeOf(schema, maybeSubType, superType) {
+	  // Equivalent type is a valid subtype
+	  if (maybeSubType === superType) {
+	    return true;
+	  }
+
+	  // If superType is non-null, maybeSubType must also be non-null.
+	  if (superType instanceof _definition.GraphQLNonNull) {
+	    if (maybeSubType instanceof _definition.GraphQLNonNull) {
+	      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
+	    }
+	    return false;
+	  } else if (maybeSubType instanceof _definition.GraphQLNonNull) {
+	    // If superType is nullable, maybeSubType may be non-null or nullable.
+	    return isTypeSubTypeOf(schema, maybeSubType.ofType, superType);
+	  }
+
+	  // If superType type is a list, maybeSubType type must also be a list.
+	  if (superType instanceof _definition.GraphQLList) {
+	    if (maybeSubType instanceof _definition.GraphQLList) {
+	      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
+	    }
+	    return false;
+	  } else if (maybeSubType instanceof _definition.GraphQLList) {
+	    // If superType is not a list, maybeSubType must also be not a list.
+	    return false;
+	  }
+
+	  // If superType type is an abstract type, maybeSubType type may be a currently
+	  // possible object type.
+	  if ((0, _definition.isAbstractType)(superType) && maybeSubType instanceof _definition.GraphQLObjectType && schema.isPossibleType(superType, maybeSubType)) {
+	    return true;
+	  }
+
+	  // Otherwise, the child type is not a valid subtype of the parent type.
+	  return false;
+	}
+
+	/**
+	 * Provided two composite types, determine if they "overlap". Two composite
+	 * types overlap when the Sets of possible concrete types for each intersect.
+	 *
+	 * This is often used to determine if a fragment of a given type could possibly
+	 * be visited in a context of another type.
+	 *
+	 * This function is commutative.
+	 */
+	function doTypesOverlap(schema, typeA, typeB) {
+	  // So flow is aware this is constant
+	  var _typeB = typeB;
+
+	  // Equivalent types overlap
+	  if (typeA === _typeB) {
+	    return true;
+	  }
+
+	  if (typeA instanceof _definition.GraphQLInterfaceType || typeA instanceof _definition.GraphQLUnionType) {
+	    if (_typeB instanceof _definition.GraphQLInterfaceType || _typeB instanceof _definition.GraphQLUnionType) {
+	      // If both types are abstract, then determine if there is any intersection
+	      // between possible concrete types of each.
+	      return schema.getPossibleTypes(typeA).some(function (type) {
+	        return schema.isPossibleType(_typeB, type);
+	      });
+	    }
+	    // Determine if the latter type is a possible concrete type of the former.
+	    return schema.isPossibleType(typeA, _typeB);
+	  }
+
+	  if (_typeB instanceof _definition.GraphQLInterfaceType || _typeB instanceof _definition.GraphQLUnionType) {
+	    // Determine if the former type is a possible concrete type of the latter.
+	    return schema.isPossibleType(_typeB, typeA);
+	  }
+
+	  // Otherwise the types do not overlap.
+	  return false;
+	}
+
+/***/ },
+/* 213 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.TypeInfo = undefined;
+
+	var _kinds = __webpack_require__(196);
+
+	var Kind = _interopRequireWildcard(_kinds);
+
+	var _definition = __webpack_require__(203);
+
+	var _introspection = __webpack_require__(208);
+
+	var _typeFromAST = __webpack_require__(214);
+
+	var _find = __webpack_require__(211);
+
+	var _find2 = _interopRequireDefault(_find);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	/**
+	 * TypeInfo is a utility class which, given a GraphQL schema, can keep track
+	 * of the current field and type definitions at any point in a GraphQL document
+	 * AST during a recursive descent by calling `enter(node)` and `leave(node)`.
+	 */
+	var TypeInfo = exports.TypeInfo = function () {
+	  function TypeInfo(schema,
+	  // NOTE: this experimental optional second parameter is only needed in order
+	  // to support non-spec-compliant codebases. You should never need to use it.
+	  getFieldDefFn) {
+	    _classCallCheck(this, TypeInfo);
+
+	    this._schema = schema;
+	    this._typeStack = [];
+	    this._parentTypeStack = [];
+	    this._inputTypeStack = [];
+	    this._fieldDefStack = [];
+	    this._directive = null;
+	    this._argument = null;
+	    this._getFieldDef = getFieldDefFn || getFieldDef;
+	  }
+
+	  TypeInfo.prototype.getType = function getType() {
+	    if (this._typeStack.length > 0) {
+	      return this._typeStack[this._typeStack.length - 1];
+	    }
+	  };
+
+	  TypeInfo.prototype.getParentType = function getParentType() {
+	    if (this._parentTypeStack.length > 0) {
+	      return this._parentTypeStack[this._parentTypeStack.length - 1];
+	    }
+	  };
+
+	  TypeInfo.prototype.getInputType = function getInputType() {
+	    if (this._inputTypeStack.length > 0) {
+	      return this._inputTypeStack[this._inputTypeStack.length - 1];
+	    }
+	  };
+
+	  TypeInfo.prototype.getFieldDef = function getFieldDef() {
+	    if (this._fieldDefStack.length > 0) {
+	      return this._fieldDefStack[this._fieldDefStack.length - 1];
+	    }
+	  };
+
+	  TypeInfo.prototype.getDirective = function getDirective() {
+	    return this._directive;
+	  };
+
+	  TypeInfo.prototype.getArgument = function getArgument() {
+	    return this._argument;
+	  };
+
+	  // Flow does not yet handle this case.
+
+
+	  TypeInfo.prototype.enter = function enter(node /* Node */) {
+	    var schema = this._schema;
+	    switch (node.kind) {
+	      case Kind.SELECTION_SET:
+	        var namedType = (0, _definition.getNamedType)(this.getType());
+	        var compositeType = void 0;
+	        if ((0, _definition.isCompositeType)(namedType)) {
+	          // isCompositeType is a type refining predicate, so this is safe.
+	          compositeType = namedType;
+	        }
+	        this._parentTypeStack.push(compositeType);
+	        break;
+	      case Kind.FIELD:
+	        var parentType = this.getParentType();
+	        var fieldDef = void 0;
+	        if (parentType) {
+	          fieldDef = this._getFieldDef(schema, parentType, node);
+	        }
+	        this._fieldDefStack.push(fieldDef);
+	        this._typeStack.push(fieldDef && fieldDef.type);
+	        break;
+	      case Kind.DIRECTIVE:
+	        this._directive = schema.getDirective(node.name.value);
+	        break;
+	      case Kind.OPERATION_DEFINITION:
+	        var type = void 0;
+	        if (node.operation === 'query') {
+	          type = schema.getQueryType();
+	        } else if (node.operation === 'mutation') {
+	          type = schema.getMutationType();
+	        } else if (node.operation === 'subscription') {
+	          type = schema.getSubscriptionType();
+	        }
+	        this._typeStack.push(type);
+	        break;
+	      case Kind.INLINE_FRAGMENT:
+	      case Kind.FRAGMENT_DEFINITION:
+	        var typeConditionAST = node.typeCondition;
+	        var outputType = typeConditionAST ? (0, _typeFromAST.typeFromAST)(schema, typeConditionAST) : this.getType();
+	        this._typeStack.push(outputType);
+	        break;
+	      case Kind.VARIABLE_DEFINITION:
+	        var inputType = (0, _typeFromAST.typeFromAST)(schema, node.type);
+	        this._inputTypeStack.push(inputType);
+	        break;
+	      case Kind.ARGUMENT:
+	        var argDef = void 0;
+	        var argType = void 0;
+	        var fieldOrDirective = this.getDirective() || this.getFieldDef();
+	        if (fieldOrDirective) {
+	          argDef = (0, _find2.default)(fieldOrDirective.args, function (arg) {
+	            return arg.name === node.name.value;
+	          });
+	          if (argDef) {
+	            argType = argDef.type;
+	          }
+	        }
+	        this._argument = argDef;
+	        this._inputTypeStack.push(argType);
+	        break;
+	      case Kind.LIST:
+	        var listType = (0, _definition.getNullableType)(this.getInputType());
+	        this._inputTypeStack.push(listType instanceof _definition.GraphQLList ? listType.ofType : undefined);
+	        break;
+	      case Kind.OBJECT_FIELD:
+	        var objectType = (0, _definition.getNamedType)(this.getInputType());
+	        var fieldType = void 0;
+	        if (objectType instanceof _definition.GraphQLInputObjectType) {
+	          var inputField = objectType.getFields()[node.name.value];
+	          fieldType = inputField ? inputField.type : undefined;
+	        }
+	        this._inputTypeStack.push(fieldType);
+	        break;
+	    }
+	  };
+
+	  TypeInfo.prototype.leave = function leave(node) {
+	    switch (node.kind) {
+	      case Kind.SELECTION_SET:
+	        this._parentTypeStack.pop();
+	        break;
+	      case Kind.FIELD:
+	        this._fieldDefStack.pop();
+	        this._typeStack.pop();
+	        break;
+	      case Kind.DIRECTIVE:
+	        this._directive = null;
+	        break;
+	      case Kind.OPERATION_DEFINITION:
+	      case Kind.INLINE_FRAGMENT:
+	      case Kind.FRAGMENT_DEFINITION:
+	        this._typeStack.pop();
+	        break;
+	      case Kind.VARIABLE_DEFINITION:
+	        this._inputTypeStack.pop();
+	        break;
+	      case Kind.ARGUMENT:
+	        this._argument = null;
+	        this._inputTypeStack.pop();
+	        break;
+	      case Kind.LIST:
+	      case Kind.OBJECT_FIELD:
+	        this._inputTypeStack.pop();
+	        break;
+	    }
+	  };
+
+	  return TypeInfo;
+	}();
+
+	/**
+	 * Not exactly the same as the executor's definition of getFieldDef, in this
+	 * statically evaluated environment we do not always have an Object type,
+	 * and need to handle Interface and Union types.
+	 */
+
+
+	function getFieldDef(schema, parentType, fieldAST) {
+	  var name = fieldAST.name.value;
+	  if (name === _introspection.SchemaMetaFieldDef.name && schema.getQueryType() === parentType) {
+	    return _introspection.SchemaMetaFieldDef;
+	  }
+	  if (name === _introspection.TypeMetaFieldDef.name && schema.getQueryType() === parentType) {
+	    return _introspection.TypeMetaFieldDef;
+	  }
+	  if (name === _introspection.TypeNameMetaFieldDef.name && (parentType instanceof _definition.GraphQLObjectType || parentType instanceof _definition.GraphQLInterfaceType || parentType instanceof _definition.GraphQLUnionType)) {
+	    return _introspection.TypeNameMetaFieldDef;
+	  }
+	  if (parentType instanceof _definition.GraphQLObjectType || parentType instanceof _definition.GraphQLInterfaceType) {
+	    return parentType.getFields()[name];
+	  }
+	}
+
+/***/ },
+/* 214 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.typeFromAST = typeFromAST;
+
+	var _invariant = __webpack_require__(200);
+
+	var _invariant2 = _interopRequireDefault(_invariant);
+
+	var _kinds = __webpack_require__(196);
+
+	var _definition = __webpack_require__(203);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function typeFromAST(schema, inputTypeAST) {
+	  var innerType = void 0;
+	  if (inputTypeAST.kind === _kinds.LIST_TYPE) {
+	    innerType = typeFromAST(schema, inputTypeAST.type);
+	    return innerType && new _definition.GraphQLList(innerType);
+	  }
+	  if (inputTypeAST.kind === _kinds.NON_NULL_TYPE) {
+	    innerType = typeFromAST(schema, inputTypeAST.type);
+	    return innerType && new _definition.GraphQLNonNull(innerType);
+	  }
+	  (0, _invariant2.default)(inputTypeAST.kind === _kinds.NAMED_TYPE, 'Must be a named type.');
+	  return schema.getType(inputTypeAST.name.value);
+	}
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+/***/ },
+/* 215 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.specifiedRules = undefined;
+
+	var _UniqueOperationNames = __webpack_require__(216);
+
+	var _LoneAnonymousOperation = __webpack_require__(217);
+
+	var _KnownTypeNames = __webpack_require__(218);
+
+	var _FragmentsOnCompositeTypes = __webpack_require__(221);
+
+	var _VariablesAreInputTypes = __webpack_require__(222);
+
+	var _ScalarLeafs = __webpack_require__(223);
+
+	var _FieldsOnCorrectType = __webpack_require__(224);
+
+	var _UniqueFragmentNames = __webpack_require__(225);
+
+	var _KnownFragmentNames = __webpack_require__(226);
+
+	var _NoUnusedFragments = __webpack_require__(227);
+
+	var _PossibleFragmentSpreads = __webpack_require__(228);
+
+	var _NoFragmentCycles = __webpack_require__(229);
+
+	var _UniqueVariableNames = __webpack_require__(230);
+
+	var _NoUndefinedVariables = __webpack_require__(231);
+
+	var _NoUnusedVariables = __webpack_require__(232);
+
+	var _KnownDirectives = __webpack_require__(233);
+
+	var _KnownArgumentNames = __webpack_require__(234);
+
+	var _UniqueArgumentNames = __webpack_require__(235);
+
+	var _ArgumentsOfCorrectType = __webpack_require__(236);
+
+	var _ProvidedNonNullArguments = __webpack_require__(239);
+
+	var _DefaultValuesOfCorrectType = __webpack_require__(240);
+
+	var _VariablesInAllowedPosition = __webpack_require__(241);
+
+	var _OverlappingFieldsCanBeMerged = __webpack_require__(242);
+
+	var _UniqueInputFieldNames = __webpack_require__(243);
+
+	/**
+	 * This set includes all validation rules defined by the GraphQL spec.
+	 */
+
+
+	// Spec Section: "Field Selection Merging"
+
+
+	// Spec Section: "Variable Default Values Are Correctly Typed"
+
+
+	// Spec Section: "Argument Values Type Correctness"
+
+
+	// Spec Section: "Argument Names"
+
+
+	// Spec Section: "All Variables Used"
+
+
+	// Spec Section: "Variable Uniqueness"
+
+
+	// Spec Section: "Fragment spread is possible"
+
+
+	// Spec Section: "Fragment spread target defined"
+
+
+	// Spec Section: "Field Selections on Objects, Interfaces, and Unions Types"
+
+
+	// Spec Section: "Variables are Input Types"
+
+
+	// Spec Section: "Fragment Spread Type Existence"
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	// Spec Section: "Operation Name Uniqueness"
+	var specifiedRules = exports.specifiedRules = [_UniqueOperationNames.UniqueOperationNames, _LoneAnonymousOperation.LoneAnonymousOperation, _KnownTypeNames.KnownTypeNames, _FragmentsOnCompositeTypes.FragmentsOnCompositeTypes, _VariablesAreInputTypes.VariablesAreInputTypes, _ScalarLeafs.ScalarLeafs, _FieldsOnCorrectType.FieldsOnCorrectType, _UniqueFragmentNames.UniqueFragmentNames, _KnownFragmentNames.KnownFragmentNames, _NoUnusedFragments.NoUnusedFragments, _PossibleFragmentSpreads.PossibleFragmentSpreads, _NoFragmentCycles.NoFragmentCycles, _UniqueVariableNames.UniqueVariableNames, _NoUndefinedVariables.NoUndefinedVariables, _NoUnusedVariables.NoUnusedVariables, _KnownDirectives.KnownDirectives, _KnownArgumentNames.KnownArgumentNames, _UniqueArgumentNames.UniqueArgumentNames, _ArgumentsOfCorrectType.ArgumentsOfCorrectType, _ProvidedNonNullArguments.ProvidedNonNullArguments, _DefaultValuesOfCorrectType.DefaultValuesOfCorrectType, _VariablesInAllowedPosition.VariablesInAllowedPosition, _OverlappingFieldsCanBeMerged.OverlappingFieldsCanBeMerged, _UniqueInputFieldNames.UniqueInputFieldNames];
+
+	// Spec Section: "Input Object Field Uniqueness"
+
+
+	// Spec Section: "All Variable Usages Are Allowed"
+
+
+	// Spec Section: "Argument Optionality"
+
+
+	// Spec Section: "Argument Uniqueness"
+
+
+	// Spec Section: "Directives Are Defined"
+
+
+	// Spec Section: "All Variable Used Defined"
+
+
+	// Spec Section: "Fragments must not form cycles"
+
+
+	// Spec Section: "Fragments must be used"
+
+
+	// Spec Section: "Fragment Name Uniqueness"
+
+
+	// Spec Section: "Leaf Field Selections"
+
+
+	// Spec Section: "Fragments on Composite Types"
+
+
+	// Spec Section: "Lone Anonymous Operation"
+
+/***/ },
+/* 216 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.duplicateOperationNameMessage = duplicateOperationNameMessage;
+	exports.UniqueOperationNames = UniqueOperationNames;
+
+	var _error = __webpack_require__(189);
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function duplicateOperationNameMessage(operationName) {
+	  return 'There can only be one operation named "' + operationName + '".';
+	}
+
+	/**
+	 * Unique operation names
+	 *
+	 * A GraphQL document is only valid if all defined operations have unique names.
+	 */
+	function UniqueOperationNames(context) {
+	  var knownOperationNames = Object.create(null);
+	  return {
+	    OperationDefinition: function OperationDefinition(node) {
+	      var operationName = node.name;
+	      if (operationName) {
+	        if (knownOperationNames[operationName.value]) {
+	          context.reportError(new _error.GraphQLError(duplicateOperationNameMessage(operationName.value), [knownOperationNames[operationName.value], operationName]));
+	        } else {
+	          knownOperationNames[operationName.value] = operationName;
+	        }
+	      }
+	      return false;
+	    },
+
+	    FragmentDefinition: function FragmentDefinition() {
+	      return false;
+	    }
+	  };
+	}
+
+/***/ },
+/* 217 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.anonOperationNotAloneMessage = anonOperationNotAloneMessage;
+	exports.LoneAnonymousOperation = LoneAnonymousOperation;
+
+	var _error = __webpack_require__(189);
+
+	var _kinds = __webpack_require__(196);
+
+	function anonOperationNotAloneMessage() {
+	  return 'This anonymous operation must be the only defined operation.';
+	}
+
+	/**
+	 * Lone anonymous operation
+	 *
+	 * A GraphQL document is only valid if when it contains an anonymous operation
+	 * (the query short-hand) that it contains only that one operation definition.
+	 */
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function LoneAnonymousOperation(context) {
+	  var operationCount = 0;
+	  return {
+	    Document: function Document(node) {
+	      operationCount = node.definitions.filter(function (definition) {
+	        return definition.kind === _kinds.OPERATION_DEFINITION;
+	      }).length;
+	    },
+	    OperationDefinition: function OperationDefinition(node) {
+	      if (!node.name && operationCount > 1) {
+	        context.reportError(new _error.GraphQLError(anonOperationNotAloneMessage(), [node]));
+	      }
+	    }
+	  };
+	}
+
+/***/ },
+/* 218 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.unknownTypeMessage = unknownTypeMessage;
+	exports.KnownTypeNames = KnownTypeNames;
+
+	var _error = __webpack_require__(189);
+
+	var _suggestionList = __webpack_require__(219);
+
+	var _suggestionList2 = _interopRequireDefault(_suggestionList);
+
+	var _quotedOrList = __webpack_require__(220);
+
+	var _quotedOrList2 = _interopRequireDefault(_quotedOrList);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function unknownTypeMessage(type, suggestedTypes) {
+	  var message = 'Unknown type "' + String(type) + '".';
+	  if (suggestedTypes.length) {
+	    message += ' Did you mean ' + (0, _quotedOrList2.default)(suggestedTypes) + '?';
+	  }
+	  return message;
+	}
+
+	/**
+	 * Known type names
+	 *
+	 * A GraphQL document is only valid if referenced types (specifically
+	 * variable definitions and fragment conditions) are defined by the type schema.
+	 */
+	function KnownTypeNames(context) {
+	  return {
+	    // TODO: when validating IDL, re-enable these. Experimental version does not
+	    // add unreferenced types, resulting in false-positive errors. Squelched
+	    // errors for now.
+	    ObjectTypeDefinition: function ObjectTypeDefinition() {
+	      return false;
+	    },
+	    InterfaceTypeDefinition: function InterfaceTypeDefinition() {
+	      return false;
+	    },
+	    UnionTypeDefinition: function UnionTypeDefinition() {
+	      return false;
+	    },
+	    InputObjectTypeDefinition: function InputObjectTypeDefinition() {
+	      return false;
+	    },
+	    NamedType: function NamedType(node) {
+	      var schema = context.getSchema();
+	      var typeName = node.name.value;
+	      var type = schema.getType(typeName);
+	      if (!type) {
+	        context.reportError(new _error.GraphQLError(unknownTypeMessage(typeName, (0, _suggestionList2.default)(typeName, Object.keys(schema.getTypeMap()))), [node]));
+	      }
+	    }
+	  };
+	}
+
+/***/ },
+/* 219 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = suggestionList;
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	/**
+	 * Given an invalid input string and a list of valid options, returns a filtered
+	 * list of valid options sorted based on their similarity with the input.
+	 */
+	function suggestionList(input, options) {
+	  var optionsByDistance = Object.create(null);
+	  var oLength = options.length;
+	  var inputThreshold = input.length / 2;
+	  for (var i = 0; i < oLength; i++) {
+	    var distance = lexicalDistance(input, options[i]);
+	    var threshold = Math.max(inputThreshold, options[i].length / 2, 1);
+	    if (distance <= threshold) {
+	      optionsByDistance[options[i]] = distance;
+	    }
+	  }
+	  return Object.keys(optionsByDistance).sort(function (a, b) {
+	    return optionsByDistance[a] - optionsByDistance[b];
+	  });
+	}
+
+	/**
+	 * Computes the lexical distance between strings A and B.
+	 *
+	 * The "distance" between two strings is given by counting the minimum number
+	 * of edits needed to transform string A into string B. An edit can be an
+	 * insertion, deletion, or substitution of a single character, or a swap of two
+	 * adjacent characters.
+	 *
+	 * This distance can be useful for detecting typos in input or sorting
+	 *
+	 * @param {string} a
+	 * @param {string} b
+	 * @return {int} distance in number of edits
+	 */
+	function lexicalDistance(a, b) {
+	  var i = void 0;
+	  var j = void 0;
+	  var d = [];
+	  var aLength = a.length;
+	  var bLength = b.length;
+
+	  for (i = 0; i <= aLength; i++) {
+	    d[i] = [i];
+	  }
+
+	  for (j = 1; j <= bLength; j++) {
+	    d[0][j] = j;
+	  }
+
+	  for (i = 1; i <= aLength; i++) {
+	    for (j = 1; j <= bLength; j++) {
+	      var cost = a[i - 1] === b[j - 1] ? 0 : 1;
+
+	      d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+
+	      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+	        d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + cost);
+	      }
+	    }
+	  }
+
+	  return d[aLength][bLength];
+	}
+
+/***/ },
+/* 220 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = quotedOrList;
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	var MAX_LENGTH = 5;
+
+	/**
+	 * Given [ A, B, C ] return '"A", "B", or "C"'.
+	 */
+	function quotedOrList(items) {
+	  var selected = items.slice(0, MAX_LENGTH);
+	  return selected.map(function (item) {
+	    return '"' + item + '"';
+	  }).reduce(function (list, quoted, index) {
+	    return list + (selected.length > 2 ? ', ' : ' ') + (index === selected.length - 1 ? 'or ' : '') + quoted;
+	  });
+	}
+
+/***/ },
+/* 221 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.inlineFragmentOnNonCompositeErrorMessage = inlineFragmentOnNonCompositeErrorMessage;
+	exports.fragmentOnNonCompositeErrorMessage = fragmentOnNonCompositeErrorMessage;
+	exports.FragmentsOnCompositeTypes = FragmentsOnCompositeTypes;
+
+	var _error = __webpack_require__(189);
+
+	var _printer = __webpack_require__(194);
+
+	var _definition = __webpack_require__(203);
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function inlineFragmentOnNonCompositeErrorMessage(type) {
+	  return 'Fragment cannot condition on non composite type "' + String(type) + '".';
+	}
+
+	function fragmentOnNonCompositeErrorMessage(fragName, type) {
+	  return 'Fragment "' + fragName + '" cannot condition on non composite ' + ('type "' + String(type) + '".');
+	}
+
+	/**
+	 * Fragments on composite type
+	 *
+	 * Fragments use a type condition to determine if they apply, since fragments
+	 * can only be spread into a composite type (object, interface, or union), the
+	 * type condition must also be a composite type.
+	 */
+	function FragmentsOnCompositeTypes(context) {
+	  return {
+	    InlineFragment: function InlineFragment(node) {
+	      var type = context.getType();
+	      if (node.typeCondition && type && !(0, _definition.isCompositeType)(type)) {
+	        context.reportError(new _error.GraphQLError(inlineFragmentOnNonCompositeErrorMessage((0, _printer.print)(node.typeCondition)), [node.typeCondition]));
+	      }
+	    },
+	    FragmentDefinition: function FragmentDefinition(node) {
+	      var type = context.getType();
+	      if (type && !(0, _definition.isCompositeType)(type)) {
+	        context.reportError(new _error.GraphQLError(fragmentOnNonCompositeErrorMessage(node.name.value, (0, _printer.print)(node.typeCondition)), [node.typeCondition]));
+	      }
+	    }
+	  };
+	}
+
+/***/ },
+/* 222 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.nonInputTypeOnVarMessage = nonInputTypeOnVarMessage;
+	exports.VariablesAreInputTypes = VariablesAreInputTypes;
+
+	var _error = __webpack_require__(189);
+
+	var _printer = __webpack_require__(194);
+
+	var _definition = __webpack_require__(203);
+
+	var _typeFromAST = __webpack_require__(214);
+
+	function nonInputTypeOnVarMessage(variableName, typeName) {
+	  return 'Variable "$' + variableName + '" cannot be non-input type "' + typeName + '".';
+	}
+
+	/**
+	 * Variables are input types
+	 *
+	 * A GraphQL operation is only valid if all the variables it defines are of
+	 * input types (scalar, enum, or input object).
+	 */
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function VariablesAreInputTypes(context) {
+	  return {
+	    VariableDefinition: function VariableDefinition(node) {
+	      var type = (0, _typeFromAST.typeFromAST)(context.getSchema(), node.type);
+
+	      // If the variable type is not an input type, return an error.
+	      if (type && !(0, _definition.isInputType)(type)) {
+	        var variableName = node.variable.name.value;
+	        context.reportError(new _error.GraphQLError(nonInputTypeOnVarMessage(variableName, (0, _printer.print)(node.type)), [node.type]));
+	      }
+	    }
+	  };
+	}
+
+/***/ },
+/* 223 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.noSubselectionAllowedMessage = noSubselectionAllowedMessage;
+	exports.requiredSubselectionMessage = requiredSubselectionMessage;
+	exports.ScalarLeafs = ScalarLeafs;
+
+	var _error = __webpack_require__(189);
+
+	var _definition = __webpack_require__(203);
+
+	function noSubselectionAllowedMessage(fieldName, type) {
+	  return 'Field "' + fieldName + '" must not have a selection since ' + ('type "' + String(type) + '" has no subfields.');
+	}
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function requiredSubselectionMessage(fieldName, type) {
+	  return 'Field "' + fieldName + '" of type "' + String(type) + '" must have a ' + ('selection of subfields. Did you mean "' + fieldName + ' { ... }"?');
+	}
+
+	/**
+	 * Scalar leafs
+	 *
+	 * A GraphQL document is valid only if all leaf fields (fields without
+	 * sub selections) are of scalar or enum types.
+	 */
+	function ScalarLeafs(context) {
+	  return {
+	    Field: function Field(node) {
+	      var type = context.getType();
+	      if (type) {
+	        if ((0, _definition.isLeafType)(type)) {
+	          if (node.selectionSet) {
+	            context.reportError(new _error.GraphQLError(noSubselectionAllowedMessage(node.name.value, type), [node.selectionSet]));
+	          }
+	        } else if (!node.selectionSet) {
+	          context.reportError(new _error.GraphQLError(requiredSubselectionMessage(node.name.value, type), [node]));
+	        }
+	      }
+	    }
+	  };
+	}
+
+/***/ },
+/* 224 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.undefinedFieldMessage = undefinedFieldMessage;
+	exports.FieldsOnCorrectType = FieldsOnCorrectType;
+
+	var _error = __webpack_require__(189);
+
+	var _suggestionList = __webpack_require__(219);
+
+	var _suggestionList2 = _interopRequireDefault(_suggestionList);
+
+	var _quotedOrList = __webpack_require__(220);
+
+	var _quotedOrList2 = _interopRequireDefault(_quotedOrList);
+
+	var _definition = __webpack_require__(203);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function undefinedFieldMessage(fieldName, type, suggestedTypeNames, suggestedFieldNames) {
+	  var message = 'Cannot query field "' + fieldName + '" on type "' + type + '".';
+	  if (suggestedTypeNames.length !== 0) {
+	    var suggestions = (0, _quotedOrList2.default)(suggestedTypeNames);
+	    message += ' Did you mean to use an inline fragment on ' + suggestions + '?';
+	  } else if (suggestedFieldNames.length !== 0) {
+	    message += ' Did you mean ' + (0, _quotedOrList2.default)(suggestedFieldNames) + '?';
+	  }
+	  return message;
+	}
+
+	/**
+	 * Fields on correct type
+	 *
+	 * A GraphQL document is only valid if all fields selected are defined by the
+	 * parent type, or are an allowed meta field such as __typename.
+	 */
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function FieldsOnCorrectType(context) {
+	  return {
+	    Field: function Field(node) {
+	      var type = context.getParentType();
+	      if (type) {
+	        var fieldDef = context.getFieldDef();
+	        if (!fieldDef) {
+	          // This field doesn't exist, lets look for suggestions.
+	          var schema = context.getSchema();
+	          var fieldName = node.name.value;
+	          // First determine if there are any suggested types to condition on.
+	          var suggestedTypeNames = getSuggestedTypeNames(schema, type, fieldName);
+	          // If there are no suggested types, then perhaps this was a typo?
+	          var suggestedFieldNames = suggestedTypeNames.length !== 0 ? [] : getSuggestedFieldNames(schema, type, fieldName);
+
+	          // Report an error, including helpful suggestions.
+	          context.reportError(new _error.GraphQLError(undefinedFieldMessage(fieldName, type.name, suggestedTypeNames, suggestedFieldNames), [node]));
+	        }
+	      }
+	    }
+	  };
+	}
+
+	/**
+	 * Go through all of the implementations of type, as well as the interfaces
+	 * that they implement. If any of those types include the provided field,
+	 * suggest them, sorted by how often the type is referenced,  starting
+	 * with Interfaces.
+	 */
+	function getSuggestedTypeNames(schema, type, fieldName) {
+	  if (type instanceof _definition.GraphQLInterfaceType || type instanceof _definition.GraphQLUnionType) {
+	    var _ret = function () {
+	      var suggestedObjectTypes = [];
+	      var interfaceUsageCount = Object.create(null);
+	      schema.getPossibleTypes(type).forEach(function (possibleType) {
+	        if (!possibleType.getFields()[fieldName]) {
+	          return;
+	        }
+	        // This object type defines this field.
+	        suggestedObjectTypes.push(possibleType.name);
+	        possibleType.getInterfaces().forEach(function (possibleInterface) {
+	          if (!possibleInterface.getFields()[fieldName]) {
+	            return;
+	          }
+	          // This interface type defines this field.
+	          interfaceUsageCount[possibleInterface.name] = (interfaceUsageCount[possibleInterface.name] || 0) + 1;
+	        });
+	      });
+
+	      // Suggest interface types based on how common they are.
+	      var suggestedInterfaceTypes = Object.keys(interfaceUsageCount).sort(function (a, b) {
+	        return interfaceUsageCount[b] - interfaceUsageCount[a];
+	      });
+
+	      // Suggest both interface and object types.
+	      return {
+	        v: suggestedInterfaceTypes.concat(suggestedObjectTypes)
+	      };
+	    }();
+
+	    if (typeof _ret === "object") return _ret.v;
+	  }
+
+	  // Otherwise, must be an Object type, which does not have possible fields.
+	  return [];
+	}
+
+	/**
+	 * For the field name provided, determine if there are any similar field names
+	 * that may be the result of a typo.
+	 */
+	function getSuggestedFieldNames(schema, type, fieldName) {
+	  if (type instanceof _definition.GraphQLObjectType || type instanceof _definition.GraphQLInterfaceType) {
+	    var possibleFieldNames = Object.keys(type.getFields());
+	    return (0, _suggestionList2.default)(fieldName, possibleFieldNames);
+	  }
+	  // Otherwise, must be a Union type, which does not define fields.
+	  return [];
+	}
+
+/***/ },
+/* 225 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.duplicateFragmentNameMessage = duplicateFragmentNameMessage;
+	exports.UniqueFragmentNames = UniqueFragmentNames;
+
+	var _error = __webpack_require__(189);
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function duplicateFragmentNameMessage(fragName) {
+	  return 'There can only be one fragment named "' + fragName + '".';
+	}
+
+	/**
+	 * Unique fragment names
+	 *
+	 * A GraphQL document is only valid if all defined fragments have unique names.
+	 */
+	function UniqueFragmentNames(context) {
+	  var knownFragmentNames = Object.create(null);
+	  return {
+	    OperationDefinition: function OperationDefinition() {
+	      return false;
+	    },
+	    FragmentDefinition: function FragmentDefinition(node) {
+	      var fragmentName = node.name.value;
+	      if (knownFragmentNames[fragmentName]) {
+	        context.reportError(new _error.GraphQLError(duplicateFragmentNameMessage(fragmentName), [knownFragmentNames[fragmentName], node.name]));
+	      } else {
+	        knownFragmentNames[fragmentName] = node.name;
+	      }
+	      return false;
+	    }
+	  };
+	}
+
+/***/ },
+/* 226 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.unknownFragmentMessage = unknownFragmentMessage;
+	exports.KnownFragmentNames = KnownFragmentNames;
+
+	var _error = __webpack_require__(189);
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function unknownFragmentMessage(fragName) {
+	  return 'Unknown fragment "' + fragName + '".';
+	}
+
+	/**
+	 * Known fragment names
+	 *
+	 * A GraphQL document is only valid if all `...Fragment` fragment spreads refer
+	 * to fragments defined in the same document.
+	 */
+	function KnownFragmentNames(context) {
+	  return {
+	    FragmentSpread: function FragmentSpread(node) {
+	      var fragmentName = node.name.value;
+	      var fragment = context.getFragment(fragmentName);
+	      if (!fragment) {
+	        context.reportError(new _error.GraphQLError(unknownFragmentMessage(fragmentName), [node.name]));
+	      }
+	    }
+	  };
+	}
+
+/***/ },
+/* 227 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.unusedFragMessage = unusedFragMessage;
+	exports.NoUnusedFragments = NoUnusedFragments;
+
+	var _error = __webpack_require__(189);
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function unusedFragMessage(fragName) {
+	  return 'Fragment "' + fragName + '" is never used.';
+	}
+
+	/**
+	 * No unused fragments
+	 *
+	 * A GraphQL document is only valid if all fragment definitions are spread
+	 * within operations, or spread within other fragments spread within operations.
+	 */
+	function NoUnusedFragments(context) {
+	  var operationDefs = [];
+	  var fragmentDefs = [];
+
+	  return {
+	    OperationDefinition: function OperationDefinition(node) {
+	      operationDefs.push(node);
+	      return false;
+	    },
+	    FragmentDefinition: function FragmentDefinition(node) {
+	      fragmentDefs.push(node);
+	      return false;
+	    },
+
+	    Document: {
+	      leave: function leave() {
+	        var fragmentNameUsed = Object.create(null);
+	        operationDefs.forEach(function (operation) {
+	          context.getRecursivelyReferencedFragments(operation).forEach(function (fragment) {
+	            fragmentNameUsed[fragment.name.value] = true;
+	          });
+	        });
+
+	        fragmentDefs.forEach(function (fragmentDef) {
+	          var fragName = fragmentDef.name.value;
+	          if (fragmentNameUsed[fragName] !== true) {
+	            context.reportError(new _error.GraphQLError(unusedFragMessage(fragName), [fragmentDef]));
+	          }
+	        });
+	      }
+	    }
+	  };
+	}
+
+/***/ },
+/* 228 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.typeIncompatibleSpreadMessage = typeIncompatibleSpreadMessage;
+	exports.typeIncompatibleAnonSpreadMessage = typeIncompatibleAnonSpreadMessage;
+	exports.PossibleFragmentSpreads = PossibleFragmentSpreads;
+
+	var _error = __webpack_require__(189);
+
+	var _typeComparators = __webpack_require__(212);
+
+	var _typeFromAST = __webpack_require__(214);
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function typeIncompatibleSpreadMessage(fragName, parentType, fragType) {
+	  return 'Fragment "' + fragName + '" cannot be spread here as objects of ' + ('type "' + String(parentType) + '" can never be of type "' + String(fragType) + '".');
+	}
+
+	function typeIncompatibleAnonSpreadMessage(parentType, fragType) {
+	  return 'Fragment cannot be spread here as objects of ' + ('type "' + String(parentType) + '" can never be of type "' + String(fragType) + '".');
+	}
+
+	/**
+	 * Possible fragment spread
+	 *
+	 * A fragment spread is only valid if the type condition could ever possibly
+	 * be true: if there is a non-empty intersection of the possible parent types,
+	 * and possible types which pass the type condition.
+	 */
+	function PossibleFragmentSpreads(context) {
+	  return {
+	    InlineFragment: function InlineFragment(node) {
+	      var fragType = context.getType();
+	      var parentType = context.getParentType();
+	      if (fragType && parentType && !(0, _typeComparators.doTypesOverlap)(context.getSchema(), fragType, parentType)) {
+	        context.reportError(new _error.GraphQLError(typeIncompatibleAnonSpreadMessage(parentType, fragType), [node]));
+	      }
+	    },
+	    FragmentSpread: function FragmentSpread(node) {
+	      var fragName = node.name.value;
+	      var fragType = getFragmentType(context, fragName);
+	      var parentType = context.getParentType();
+	      if (fragType && parentType && !(0, _typeComparators.doTypesOverlap)(context.getSchema(), fragType, parentType)) {
+	        context.reportError(new _error.GraphQLError(typeIncompatibleSpreadMessage(fragName, parentType, fragType), [node]));
+	      }
+	    }
+	  };
+	}
+
+	function getFragmentType(context, name) {
+	  var frag = context.getFragment(name);
+	  return frag && (0, _typeFromAST.typeFromAST)(context.getSchema(), frag.typeCondition);
+	}
+
+/***/ },
+/* 229 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.cycleErrorMessage = cycleErrorMessage;
+	exports.NoFragmentCycles = NoFragmentCycles;
+
+	var _error = __webpack_require__(189);
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function cycleErrorMessage(fragName, spreadNames) {
+	  var via = spreadNames.length ? ' via ' + spreadNames.join(', ') : '';
+	  return 'Cannot spread fragment "' + fragName + '" within itself' + via + '.';
+	}
+
+	function NoFragmentCycles(context) {
+	  // Tracks already visited fragments to maintain O(N) and to ensure that cycles
+	  // are not redundantly reported.
+	  var visitedFrags = Object.create(null);
+
+	  // Array of AST nodes used to produce meaningful errors
+	  var spreadPath = [];
+
+	  // Position in the spread path
+	  var spreadPathIndexByName = Object.create(null);
+
+	  return {
+	    OperationDefinition: function OperationDefinition() {
+	      return false;
+	    },
+	    FragmentDefinition: function FragmentDefinition(node) {
+	      if (!visitedFrags[node.name.value]) {
+	        detectCycleRecursive(node);
+	      }
+	      return false;
+	    }
+	  };
+
+	  // This does a straight-forward DFS to find cycles.
+	  // It does not terminate when a cycle was found but continues to explore
+	  // the graph to find all possible cycles.
+	  function detectCycleRecursive(fragment) {
+	    var fragmentName = fragment.name.value;
+	    visitedFrags[fragmentName] = true;
+
+	    var spreadNodes = context.getFragmentSpreads(fragment.selectionSet);
+	    if (spreadNodes.length === 0) {
+	      return;
+	    }
+
+	    spreadPathIndexByName[fragmentName] = spreadPath.length;
+
+	    for (var i = 0; i < spreadNodes.length; i++) {
+	      var spreadNode = spreadNodes[i];
+	      var spreadName = spreadNode.name.value;
+	      var cycleIndex = spreadPathIndexByName[spreadName];
+
+	      if (cycleIndex === undefined) {
+	        spreadPath.push(spreadNode);
+	        if (!visitedFrags[spreadName]) {
+	          var spreadFragment = context.getFragment(spreadName);
+	          if (spreadFragment) {
+	            detectCycleRecursive(spreadFragment);
+	          }
+	        }
+	        spreadPath.pop();
+	      } else {
+	        var cyclePath = spreadPath.slice(cycleIndex);
+	        context.reportError(new _error.GraphQLError(cycleErrorMessage(spreadName, cyclePath.map(function (s) {
+	          return s.name.value;
+	        })), cyclePath.concat(spreadNode)));
+	      }
+	    }
+
+	    spreadPathIndexByName[fragmentName] = undefined;
+	  }
+	}
+
+/***/ },
+/* 230 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.duplicateVariableMessage = duplicateVariableMessage;
+	exports.UniqueVariableNames = UniqueVariableNames;
+
+	var _error = __webpack_require__(189);
+
+	function duplicateVariableMessage(variableName) {
+	  return 'There can be only one variable named "' + variableName + '".';
+	}
+
+	/**
+	 * Unique variable names
+	 *
+	 * A GraphQL operation is only valid if all its variables are uniquely named.
+	 */
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function UniqueVariableNames(context) {
+	  var knownVariableNames = Object.create(null);
+	  return {
+	    OperationDefinition: function OperationDefinition() {
+	      knownVariableNames = Object.create(null);
+	    },
+	    VariableDefinition: function VariableDefinition(node) {
+	      var variableName = node.variable.name.value;
+	      if (knownVariableNames[variableName]) {
+	        context.reportError(new _error.GraphQLError(duplicateVariableMessage(variableName), [knownVariableNames[variableName], node.variable.name]));
+	      } else {
+	        knownVariableNames[variableName] = node.variable.name;
+	      }
+	    }
+	  };
+	}
+
+/***/ },
+/* 231 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.undefinedVarMessage = undefinedVarMessage;
+	exports.NoUndefinedVariables = NoUndefinedVariables;
+
+	var _error = __webpack_require__(189);
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function undefinedVarMessage(varName, opName) {
+	  return opName ? 'Variable "$' + varName + '" is not defined by operation "' + opName + '".' : 'Variable "$' + varName + '" is not defined.';
+	}
+
+	/**
+	 * No undefined variables
+	 *
+	 * A GraphQL operation is only valid if all variables encountered, both directly
+	 * and via fragment spreads, are defined by that operation.
+	 */
+	function NoUndefinedVariables(context) {
+	  var variableNameDefined = Object.create(null);
+
+	  return {
+	    OperationDefinition: {
+	      enter: function enter() {
+	        variableNameDefined = Object.create(null);
+	      },
+	      leave: function leave(operation) {
+	        var usages = context.getRecursiveVariableUsages(operation);
+
+	        usages.forEach(function (_ref) {
+	          var node = _ref.node;
+
+	          var varName = node.name.value;
+	          if (variableNameDefined[varName] !== true) {
+	            context.reportError(new _error.GraphQLError(undefinedVarMessage(varName, operation.name && operation.name.value), [node, operation]));
+	          }
+	        });
+	      }
+	    },
+	    VariableDefinition: function VariableDefinition(varDefAST) {
+	      variableNameDefined[varDefAST.variable.name.value] = true;
+	    }
+	  };
+	}
+
+/***/ },
+/* 232 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.unusedVariableMessage = unusedVariableMessage;
+	exports.NoUnusedVariables = NoUnusedVariables;
+
+	var _error = __webpack_require__(189);
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function unusedVariableMessage(varName, opName) {
+	  return opName ? 'Variable "$' + varName + '" is never used in operation "' + opName + '".' : 'Variable "$' + varName + '" is never used.';
+	}
+
+	/**
+	 * No unused variables
+	 *
+	 * A GraphQL operation is only valid if all variables defined by an operation
+	 * are used, either directly or within a spread fragment.
+	 */
+	function NoUnusedVariables(context) {
+	  var variableDefs = [];
+
+	  return {
+	    OperationDefinition: {
+	      enter: function enter() {
+	        variableDefs = [];
+	      },
+	      leave: function leave(operation) {
+	        var variableNameUsed = Object.create(null);
+	        var usages = context.getRecursiveVariableUsages(operation);
+	        var opName = operation.name ? operation.name.value : null;
+
+	        usages.forEach(function (_ref) {
+	          var node = _ref.node;
+
+	          variableNameUsed[node.name.value] = true;
+	        });
+
+	        variableDefs.forEach(function (variableDef) {
+	          var variableName = variableDef.variable.name.value;
+	          if (variableNameUsed[variableName] !== true) {
+	            context.reportError(new _error.GraphQLError(unusedVariableMessage(variableName, opName), [variableDef]));
+	          }
+	        });
+	      }
+	    },
+	    VariableDefinition: function VariableDefinition(def) {
+	      variableDefs.push(def);
+	    }
+	  };
+	}
+
+/***/ },
+/* 233 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.unknownDirectiveMessage = unknownDirectiveMessage;
+	exports.misplacedDirectiveMessage = misplacedDirectiveMessage;
+	exports.KnownDirectives = KnownDirectives;
+
+	var _error = __webpack_require__(189);
+
+	var _find = __webpack_require__(211);
+
+	var _find2 = _interopRequireDefault(_find);
+
+	var _kinds = __webpack_require__(196);
+
+	var _directives = __webpack_require__(206);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function unknownDirectiveMessage(directiveName) {
+	  return 'Unknown directive "' + directiveName + '".';
+	}
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function misplacedDirectiveMessage(directiveName, location) {
+	  return 'Directive "' + directiveName + '" may not be used on ' + location + '.';
+	}
+
+	/**
+	 * Known directives
+	 *
+	 * A GraphQL document is only valid if all `@directives` are known by the
+	 * schema and legally positioned.
+	 */
+	function KnownDirectives(context) {
+	  return {
+	    Directive: function Directive(node, key, parent, path, ancestors) {
+	      var directiveDef = (0, _find2.default)(context.getSchema().getDirectives(), function (def) {
+	        return def.name === node.name.value;
+	      });
+	      if (!directiveDef) {
+	        context.reportError(new _error.GraphQLError(unknownDirectiveMessage(node.name.value), [node]));
+	        return;
+	      }
+	      var candidateLocation = getDirectiveLocationForASTPath(ancestors);
+	      if (!candidateLocation) {
+	        context.reportError(new _error.GraphQLError(misplacedDirectiveMessage(node.name.value, node.type), [node]));
+	      } else if (directiveDef.locations.indexOf(candidateLocation) === -1) {
+	        context.reportError(new _error.GraphQLError(misplacedDirectiveMessage(node.name.value, candidateLocation), [node]));
+	      }
+	    }
+	  };
+	}
+
+	function getDirectiveLocationForASTPath(ancestors) {
+	  var appliedTo = ancestors[ancestors.length - 1];
+	  switch (appliedTo.kind) {
+	    case _kinds.OPERATION_DEFINITION:
+	      switch (appliedTo.operation) {
+	        case 'query':
+	          return _directives.DirectiveLocation.QUERY;
+	        case 'mutation':
+	          return _directives.DirectiveLocation.MUTATION;
+	        case 'subscription':
+	          return _directives.DirectiveLocation.SUBSCRIPTION;
+	      }
+	      break;
+	    case _kinds.FIELD:
+	      return _directives.DirectiveLocation.FIELD;
+	    case _kinds.FRAGMENT_SPREAD:
+	      return _directives.DirectiveLocation.FRAGMENT_SPREAD;
+	    case _kinds.INLINE_FRAGMENT:
+	      return _directives.DirectiveLocation.INLINE_FRAGMENT;
+	    case _kinds.FRAGMENT_DEFINITION:
+	      return _directives.DirectiveLocation.FRAGMENT_DEFINITION;
+	    case _kinds.SCHEMA_DEFINITION:
+	      return _directives.DirectiveLocation.SCHEMA;
+	    case _kinds.SCALAR_TYPE_DEFINITION:
+	      return _directives.DirectiveLocation.SCALAR;
+	    case _kinds.OBJECT_TYPE_DEFINITION:
+	      return _directives.DirectiveLocation.OBJECT;
+	    case _kinds.FIELD_DEFINITION:
+	      return _directives.DirectiveLocation.FIELD_DEFINITION;
+	    case _kinds.INTERFACE_TYPE_DEFINITION:
+	      return _directives.DirectiveLocation.INTERFACE;
+	    case _kinds.UNION_TYPE_DEFINITION:
+	      return _directives.DirectiveLocation.UNION;
+	    case _kinds.ENUM_TYPE_DEFINITION:
+	      return _directives.DirectiveLocation.ENUM;
+	    case _kinds.ENUM_VALUE_DEFINITION:
+	      return _directives.DirectiveLocation.ENUM_VALUE;
+	    case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
+	      return _directives.DirectiveLocation.INPUT_OBJECT;
+	    case _kinds.INPUT_VALUE_DEFINITION:
+	      var parentNode = ancestors[ancestors.length - 3];
+	      return parentNode.kind === _kinds.INPUT_OBJECT_TYPE_DEFINITION ? _directives.DirectiveLocation.INPUT_FIELD_DEFINITION : _directives.DirectiveLocation.ARGUMENT_DEFINITION;
+	  }
+	}
+
+/***/ },
+/* 234 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.unknownArgMessage = unknownArgMessage;
+	exports.unknownDirectiveArgMessage = unknownDirectiveArgMessage;
+	exports.KnownArgumentNames = KnownArgumentNames;
+
+	var _error = __webpack_require__(189);
+
+	var _find = __webpack_require__(211);
+
+	var _find2 = _interopRequireDefault(_find);
+
+	var _invariant = __webpack_require__(200);
+
+	var _invariant2 = _interopRequireDefault(_invariant);
+
+	var _suggestionList = __webpack_require__(219);
+
+	var _suggestionList2 = _interopRequireDefault(_suggestionList);
+
+	var _quotedOrList = __webpack_require__(220);
+
+	var _quotedOrList2 = _interopRequireDefault(_quotedOrList);
+
+	var _kinds = __webpack_require__(196);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function unknownArgMessage(argName, fieldName, type, suggestedArgs) {
+	  var message = 'Unknown argument "' + argName + '" on field "' + fieldName + '" of ' + ('type "' + String(type) + '".');
+	  if (suggestedArgs.length) {
+	    message += ' Did you mean ' + (0, _quotedOrList2.default)(suggestedArgs) + '?';
+	  }
+	  return message;
+	}
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function unknownDirectiveArgMessage(argName, directiveName, suggestedArgs) {
+	  var message = 'Unknown argument "' + argName + '" on directive "@' + directiveName + '".';
+	  if (suggestedArgs.length) {
+	    message += ' Did you mean ' + (0, _quotedOrList2.default)(suggestedArgs) + '?';
+	  }
+	  return message;
+	}
+
+	/**
+	 * Known argument names
+	 *
+	 * A GraphQL field is only valid if all supplied arguments are defined by
+	 * that field.
+	 */
+	function KnownArgumentNames(context) {
+	  return {
+	    Argument: function Argument(node, key, parent, path, ancestors) {
+	      var argumentOf = ancestors[ancestors.length - 1];
+	      if (argumentOf.kind === _kinds.FIELD) {
+	        var fieldDef = context.getFieldDef();
+	        if (fieldDef) {
+	          var fieldArgDef = (0, _find2.default)(fieldDef.args, function (arg) {
+	            return arg.name === node.name.value;
+	          });
+	          if (!fieldArgDef) {
+	            var parentType = context.getParentType();
+	            (0, _invariant2.default)(parentType);
+	            context.reportError(new _error.GraphQLError(unknownArgMessage(node.name.value, fieldDef.name, parentType.name, (0, _suggestionList2.default)(node.name.value, fieldDef.args.map(function (arg) {
+	              return arg.name;
+	            }))), [node]));
+	          }
+	        }
+	      } else if (argumentOf.kind === _kinds.DIRECTIVE) {
+	        var directive = context.getDirective();
+	        if (directive) {
+	          var directiveArgDef = (0, _find2.default)(directive.args, function (arg) {
+	            return arg.name === node.name.value;
+	          });
+	          if (!directiveArgDef) {
+	            context.reportError(new _error.GraphQLError(unknownDirectiveArgMessage(node.name.value, directive.name, (0, _suggestionList2.default)(node.name.value, directive.args.map(function (arg) {
+	              return arg.name;
+	            }))), [node]));
+	          }
+	        }
+	      }
+	    }
+	  };
+	}
+
+/***/ },
+/* 235 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.duplicateArgMessage = duplicateArgMessage;
+	exports.UniqueArgumentNames = UniqueArgumentNames;
+
+	var _error = __webpack_require__(189);
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function duplicateArgMessage(argName) {
+	  return 'There can be only one argument named "' + argName + '".';
+	}
+
+	/**
+	 * Unique argument names
+	 *
+	 * A GraphQL field or directive is only valid if all supplied arguments are
+	 * uniquely named.
+	 */
+	function UniqueArgumentNames(context) {
+	  var knownArgNames = Object.create(null);
+	  return {
+	    Field: function Field() {
+	      knownArgNames = Object.create(null);
+	    },
+	    Directive: function Directive() {
+	      knownArgNames = Object.create(null);
+	    },
+	    Argument: function Argument(node) {
+	      var argName = node.name.value;
+	      if (knownArgNames[argName]) {
+	        context.reportError(new _error.GraphQLError(duplicateArgMessage(argName), [knownArgNames[argName], node.name]));
+	      } else {
+	        knownArgNames[argName] = node.name;
+	      }
+	      return false;
+	    }
+	  };
+	}
+
+/***/ },
+/* 236 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.badValueMessage = badValueMessage;
+	exports.ArgumentsOfCorrectType = ArgumentsOfCorrectType;
+
+	var _error = __webpack_require__(189);
+
+	var _printer = __webpack_require__(194);
+
+	var _isValidLiteralValue = __webpack_require__(237);
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function badValueMessage(argName, type, value, verboseErrors) {
+	  var message = verboseErrors ? '\n' + verboseErrors.join('\n') : '';
+	  return 'Argument "' + argName + '" has invalid value ' + value + '.' + message;
+	}
+
+	/**
+	 * Argument values of correct type
+	 *
+	 * A GraphQL document is only valid if all field argument literal values are
+	 * of the type expected by their position.
+	 */
+	function ArgumentsOfCorrectType(context) {
+	  return {
+	    Argument: function Argument(argAST) {
+	      var argDef = context.getArgument();
+	      if (argDef) {
+	        var errors = (0, _isValidLiteralValue.isValidLiteralValue)(argDef.type, argAST.value);
+	        if (errors && errors.length > 0) {
+	          context.reportError(new _error.GraphQLError(badValueMessage(argAST.name.value, argDef.type, (0, _printer.print)(argAST.value), errors), [argAST.value]));
+	        }
+	      }
+	      return false;
+	    }
+	  };
+	}
+
+/***/ },
+/* 237 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.isValidLiteralValue = isValidLiteralValue;
+
+	var _printer = __webpack_require__(194);
+
+	var _kinds = __webpack_require__(196);
+
+	var _definition = __webpack_require__(203);
+
+	var _invariant = __webpack_require__(200);
+
+	var _invariant2 = _interopRequireDefault(_invariant);
+
+	var _keyMap = __webpack_require__(238);
+
+	var _keyMap2 = _interopRequireDefault(_keyMap);
+
+	var _isNullish = __webpack_require__(204);
+
+	var _isNullish2 = _interopRequireDefault(_isNullish);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 * Utility for validators which determines if a value literal AST is valid given
+	 * an input type.
+	 *
+	 * Note that this only validates literal values, variables are assumed to
+	 * provide values of the correct type.
+	 */
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function isValidLiteralValue(type, valueAST) {
+	  // A value must be provided if the type is non-null.
+	  if (type instanceof _definition.GraphQLNonNull) {
+	    if (!valueAST) {
+	      if (type.ofType.name) {
+	        return ['Expected "' + String(type.ofType.name) + '!", found null.'];
+	      }
+	      return ['Expected non-null value, found null.'];
+	    }
+	    return isValidLiteralValue(type.ofType, valueAST);
+	  }
+
+	  if (!valueAST) {
+	    return [];
+	  }
+
+	  // This function only tests literals, and assumes variables will provide
+	  // values of the correct type.
+	  if (valueAST.kind === _kinds.VARIABLE) {
+	    return [];
+	  }
+
+	  // Lists accept a non-list value as a list of one.
+	  if (type instanceof _definition.GraphQLList) {
+	    var _ret = function () {
+	      var itemType = type.ofType;
+	      if (valueAST.kind === _kinds.LIST) {
+	        return {
+	          v: valueAST.values.reduce(function (acc, itemAST, index) {
+	            var errors = isValidLiteralValue(itemType, itemAST);
+	            return acc.concat(errors.map(function (error) {
+	              return 'In element #' + index + ': ' + error;
+	            }));
+	          }, [])
+	        };
+	      }
+	      return {
+	        v: isValidLiteralValue(itemType, valueAST)
+	      };
+	    }();
+
+	    if (typeof _ret === "object") return _ret.v;
+	  }
+
+	  // Input objects check each defined field and look for undefined fields.
+	  if (type instanceof _definition.GraphQLInputObjectType) {
+	    var _ret2 = function () {
+	      if (valueAST.kind !== _kinds.OBJECT) {
+	        return {
+	          v: ['Expected "' + type.name + '", found not an object.']
+	        };
+	      }
+	      var fields = type.getFields();
+
+	      var errors = [];
+
+	      // Ensure every provided field is defined.
+	      var fieldASTs = valueAST.fields;
+	      fieldASTs.forEach(function (providedFieldAST) {
+	        if (!fields[providedFieldAST.name.value]) {
+	          errors.push('In field "' + providedFieldAST.name.value + '": Unknown field.');
+	        }
+	      });
+
+	      // Ensure every defined field is valid.
+	      var fieldASTMap = (0, _keyMap2.default)(fieldASTs, function (fieldAST) {
+	        return fieldAST.name.value;
+	      });
+	      Object.keys(fields).forEach(function (fieldName) {
+	        var result = isValidLiteralValue(fields[fieldName].type, fieldASTMap[fieldName] && fieldASTMap[fieldName].value);
+	        errors.push.apply(errors, result.map(function (error) {
+	          return 'In field "' + fieldName + '": ' + error;
+	        }));
+	      });
+
+	      return {
+	        v: errors
+	      };
+	    }();
+
+	    if (typeof _ret2 === "object") return _ret2.v;
+	  }
+
+	  (0, _invariant2.default)(type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType, 'Must be input type');
+
+	  // Scalar/Enum input checks to ensure the type can parse the value to
+	  // a non-null value.
+	  var parseResult = type.parseLiteral(valueAST);
+	  if ((0, _isNullish2.default)(parseResult)) {
+	    return ['Expected type "' + type.name + '", found ' + (0, _printer.print)(valueAST) + '.'];
+	  }
+
+	  return [];
+	}
+
+/***/ },
+/* 238 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = keyMap;
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	/**
+	 * Creates a keyed JS object from an array, given a function to produce the keys
+	 * for each value in the array.
+	 *
+	 * This provides a convenient lookup for the array items if the key function
+	 * produces unique results.
+	 *
+	 *     const phoneBook = [
+	 *       { name: 'Jon', num: '555-1234' },
+	 *       { name: 'Jenny', num: '867-5309' }
+	 *     ]
+	 *
+	 *     // { Jon: { name: 'Jon', num: '555-1234' },
+	 *     //   Jenny: { name: 'Jenny', num: '867-5309' } }
+	 *     const entriesByName = keyMap(
+	 *       phoneBook,
+	 *       entry => entry.name
+	 *     )
+	 *
+	 *     // { name: 'Jenny', num: '857-6309' }
+	 *     const jennyEntry = entriesByName['Jenny']
+	 *
+	 */
+	function keyMap(list, keyFn) {
+	  return list.reduce(function (map, item) {
+	    return map[keyFn(item)] = item, map;
+	  }, {});
+	}
+
+/***/ },
+/* 239 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.missingFieldArgMessage = missingFieldArgMessage;
+	exports.missingDirectiveArgMessage = missingDirectiveArgMessage;
+	exports.ProvidedNonNullArguments = ProvidedNonNullArguments;
+
+	var _error = __webpack_require__(189);
+
+	var _keyMap = __webpack_require__(238);
+
+	var _keyMap2 = _interopRequireDefault(_keyMap);
+
+	var _definition = __webpack_require__(203);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function missingFieldArgMessage(fieldName, argName, type) {
+	  return 'Field "' + fieldName + '" argument "' + argName + '" of type ' + ('"' + String(type) + '" is required but not provided.');
+	}
+
+	function missingDirectiveArgMessage(directiveName, argName, type) {
+	  return 'Directive "@' + directiveName + '" argument "' + argName + '" of type ' + ('"' + String(type) + '" is required but not provided.');
+	}
+
+	/**
+	 * Provided required arguments
+	 *
+	 * A field or directive is only valid if all required (non-null) field arguments
+	 * have been provided.
+	 */
+	function ProvidedNonNullArguments(context) {
+	  return {
+	    Field: {
+	      // Validate on leave to allow for deeper errors to appear first.
+	      leave: function leave(fieldAST) {
+	        var fieldDef = context.getFieldDef();
+	        if (!fieldDef) {
+	          return false;
+	        }
+	        var argASTs = fieldAST.arguments || [];
+
+	        var argASTMap = (0, _keyMap2.default)(argASTs, function (arg) {
+	          return arg.name.value;
+	        });
+	        fieldDef.args.forEach(function (argDef) {
+	          var argAST = argASTMap[argDef.name];
+	          if (!argAST && argDef.type instanceof _definition.GraphQLNonNull) {
+	            context.reportError(new _error.GraphQLError(missingFieldArgMessage(fieldAST.name.value, argDef.name, argDef.type), [fieldAST]));
+	          }
+	        });
+	      }
+	    },
+
+	    Directive: {
+	      // Validate on leave to allow for deeper errors to appear first.
+	      leave: function leave(directiveAST) {
+	        var directiveDef = context.getDirective();
+	        if (!directiveDef) {
+	          return false;
+	        }
+	        var argASTs = directiveAST.arguments || [];
+
+	        var argASTMap = (0, _keyMap2.default)(argASTs, function (arg) {
+	          return arg.name.value;
+	        });
+	        directiveDef.args.forEach(function (argDef) {
+	          var argAST = argASTMap[argDef.name];
+	          if (!argAST && argDef.type instanceof _definition.GraphQLNonNull) {
+	            context.reportError(new _error.GraphQLError(missingDirectiveArgMessage(directiveAST.name.value, argDef.name, argDef.type), [directiveAST]));
+	          }
+	        });
+	      }
+	    }
+	  };
+	}
+
+/***/ },
+/* 240 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.defaultForNonNullArgMessage = defaultForNonNullArgMessage;
+	exports.badValueForDefaultArgMessage = badValueForDefaultArgMessage;
+	exports.DefaultValuesOfCorrectType = DefaultValuesOfCorrectType;
+
+	var _error = __webpack_require__(189);
+
+	var _printer = __webpack_require__(194);
+
+	var _definition = __webpack_require__(203);
+
+	var _isValidLiteralValue = __webpack_require__(237);
+
+	function defaultForNonNullArgMessage(varName, type, guessType) {
+	  return 'Variable "$' + varName + '" of type "' + String(type) + '" is required and ' + 'will not use the default value. ' + ('Perhaps you meant to use type "' + String(guessType) + '".');
+	}
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function badValueForDefaultArgMessage(varName, type, value, verboseErrors) {
+	  var message = verboseErrors ? '\n' + verboseErrors.join('\n') : '';
+	  return 'Variable "$' + varName + '" of type "' + String(type) + '" has invalid ' + ('default value ' + value + '.' + message);
+	}
+
+	/**
+	 * Variable default values of correct type
+	 *
+	 * A GraphQL document is only valid if all variable default values are of the
+	 * type expected by their definition.
+	 */
+	function DefaultValuesOfCorrectType(context) {
+	  return {
+	    VariableDefinition: function VariableDefinition(varDefAST) {
+	      var name = varDefAST.variable.name.value;
+	      var defaultValue = varDefAST.defaultValue;
+	      var type = context.getInputType();
+	      if (type instanceof _definition.GraphQLNonNull && defaultValue) {
+	        context.reportError(new _error.GraphQLError(defaultForNonNullArgMessage(name, type, type.ofType), [defaultValue]));
+	      }
+	      if (type && defaultValue) {
+	        var errors = (0, _isValidLiteralValue.isValidLiteralValue)(type, defaultValue);
+	        if (errors && errors.length > 0) {
+	          context.reportError(new _error.GraphQLError(badValueForDefaultArgMessage(name, type, (0, _printer.print)(defaultValue), errors), [defaultValue]));
+	        }
+	      }
+	      return false;
+	    },
+
+	    SelectionSet: function SelectionSet() {
+	      return false;
+	    },
+	    FragmentDefinition: function FragmentDefinition() {
+	      return false;
+	    }
+	  };
+	}
+
+/***/ },
+/* 241 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.badVarPosMessage = badVarPosMessage;
+	exports.VariablesInAllowedPosition = VariablesInAllowedPosition;
+
+	var _error = __webpack_require__(189);
+
+	var _definition = __webpack_require__(203);
+
+	var _typeComparators = __webpack_require__(212);
+
+	var _typeFromAST = __webpack_require__(214);
+
+	function badVarPosMessage(varName, varType, expectedType) {
+	  return 'Variable "$' + varName + '" of type "' + String(varType) + '" used in ' + ('position expecting type "' + String(expectedType) + '".');
+	}
+
+	/**
+	 * Variables passed to field arguments conform to type
+	 */
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function VariablesInAllowedPosition(context) {
+	  var varDefMap = Object.create(null);
+
+	  return {
+	    OperationDefinition: {
+	      enter: function enter() {
+	        varDefMap = Object.create(null);
+	      },
+	      leave: function leave(operation) {
+	        var usages = context.getRecursiveVariableUsages(operation);
+
+	        usages.forEach(function (_ref) {
+	          var node = _ref.node;
+	          var type = _ref.type;
+
+	          var varName = node.name.value;
+	          var varDef = varDefMap[varName];
+	          if (varDef && type) {
+	            // A var type is allowed if it is the same or more strict (e.g. is
+	            // a subtype of) than the expected type. It can be more strict if
+	            // the variable type is non-null when the expected type is nullable.
+	            // If both are list types, the variable item type can be more strict
+	            // than the expected item type (contravariant).
+	            var schema = context.getSchema();
+	            var varType = (0, _typeFromAST.typeFromAST)(schema, varDef.type);
+	            if (varType && !(0, _typeComparators.isTypeSubTypeOf)(schema, effectiveType(varType, varDef), type)) {
+	              context.reportError(new _error.GraphQLError(badVarPosMessage(varName, varType, type), [varDef, node]));
+	            }
+	          }
+	        });
+	      }
+	    },
+	    VariableDefinition: function VariableDefinition(varDefAST) {
+	      varDefMap[varDefAST.variable.name.value] = varDefAST;
+	    }
+	  };
+	}
+
+	// If a variable definition has a default value, it's effectively non-null.
+	function effectiveType(varType, varDef) {
+	  return !varDef.defaultValue || varType instanceof _definition.GraphQLNonNull ? varType : new _definition.GraphQLNonNull(varType);
+	}
+
+/***/ },
+/* 242 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.fieldsConflictMessage = fieldsConflictMessage;
+	exports.OverlappingFieldsCanBeMerged = OverlappingFieldsCanBeMerged;
+
+	var _error = __webpack_require__(189);
+
+	var _find = __webpack_require__(211);
+
+	var _find2 = _interopRequireDefault(_find);
+
+	var _kinds = __webpack_require__(196);
+
+	var _printer = __webpack_require__(194);
+
+	var _definition = __webpack_require__(203);
+
+	var _typeFromAST = __webpack_require__(214);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function fieldsConflictMessage(responseName, reason) {
+	  return 'Fields "' + responseName + '" conflict because ' + reasonMessage(reason) + '. Use different aliases on the fields to fetch both if this was ' + 'intentional.';
+	}
+
+	function reasonMessage(reason) {
+	  if (Array.isArray(reason)) {
+	    return reason.map(function (_ref) {
+	      var responseName = _ref[0];
+	      var subreason = _ref[1];
+	      return 'subfields "' + responseName + '" conflict because ' + reasonMessage(subreason);
+	    }).join(' and ');
+	  }
+	  return reason;
+	}
+
+	/**
+	 * Overlapping fields can be merged
+	 *
+	 * A selection set is only valid if all fields (including spreading any
+	 * fragments) either correspond to distinct response names or can be merged
+	 * without ambiguity.
+	 */
+	function OverlappingFieldsCanBeMerged(context) {
+	  // A memoization for when two fragments are compared "between" each other for
+	  // conflicts. Two fragments may be compared many times, so memoizing this can
+	  // dramatically improve the performance of this validator.
+	  var comparedFragments = new PairSet();
+
+	  // A cache for the "field map" and list of fragment names found in any given
+	  // selection set. Selection sets may be asked for this information multiple
+	  // times, so this improves the performance of this validator.
+	  var cachedFieldsAndFragmentNames = new Map();
+
+	  return {
+	    SelectionSet: function SelectionSet(selectionSet) {
+	      var conflicts = findConflictsWithinSelectionSet(context, cachedFieldsAndFragmentNames, comparedFragments, context.getParentType(), selectionSet);
+	      conflicts.forEach(function (_ref2) {
+	        var _ref2$ = _ref2[0];
+	        var responseName = _ref2$[0];
+	        var reason = _ref2$[1];
+	        var fields1 = _ref2[1];
+	        var fields2 = _ref2[2];
+	        return context.reportError(new _error.GraphQLError(fieldsConflictMessage(responseName, reason), fields1.concat(fields2)));
+	      });
+	    }
+	  };
+	}
+	// Field name and reason.
+
+	// Reason is a string, or a nested list of conflicts.
+
+	// Tuple defining an AST in a context
+
+	// Map of array of those.
+
+
+	/**
+	 * Algorithm:
+	 *
+	 * Conflicts occur when two fields exist in a query which will produce the same
+	 * response name, but represent differing values, thus creating a conflict.
+	 * The algorithm below finds all conflicts via making a series of comparisons
+	 * between fields. In order to compare as few fields as possible, this makes
+	 * a series of comparisons "within" sets of fields and "between" sets of fields.
+	 *
+	 * Given any selection set, a collection produces both a set of fields by
+	 * also including all inline fragments, as well as a list of fragments
+	 * referenced by fragment spreads.
+	 *
+	 * A) Each selection set represented in the document first compares "within" its
+	 * collected set of fields, finding any conflicts between every pair of
+	 * overlapping fields.
+	 * Note: This is the *only time* that a the fields "within" a set are compared
+	 * to each other. After this only fields "between" sets are compared.
+	 *
+	 * B) Also, if any fragment is referenced in a selection set, then a
+	 * comparison is made "between" the original set of fields and the
+	 * referenced fragment.
+	 *
+	 * C) Also, if multiple fragments are referenced, then comparisons
+	 * are made "between" each referenced fragment.
+	 *
+	 * D) When comparing "between" a set of fields and a referenced fragment, first
+	 * a comparison is made between each field in the original set of fields and
+	 * each field in the the referenced set of fields.
+	 *
+	 * E) Also, if any fragment is referenced in the referenced selection set,
+	 * then a comparison is made "between" the original set of fields and the
+	 * referenced fragment (recursively referring to step D).
+	 *
+	 * F) When comparing "between" two fragments, first a comparison is made between
+	 * each field in the first referenced set of fields and each field in the the
+	 * second referenced set of fields.
+	 *
+	 * G) Also, any fragments referenced by the first must be compared to the
+	 * second, and any fragments referenced by the second must be compared to the
+	 * first (recursively referring to step F).
+	 *
+	 * H) When comparing two fields, if both have selection sets, then a comparison
+	 * is made "between" both selection sets, first comparing the set of fields in
+	 * the first selection set with the set of fields in the second.
+	 *
+	 * I) Also, if any fragment is referenced in either selection set, then a
+	 * comparison is made "between" the other set of fields and the
+	 * referenced fragment.
+	 *
+	 * J) Also, if two fragments are referenced in both selection sets, then a
+	 * comparison is made "between" the two fragments.
+	 *
+	 */
+
+	// Find all conflicts found "within" a selection set, including those found
+	// via spreading in fragments. Called when visiting each SelectionSet in the
+	// GraphQL Document.
+	function findConflictsWithinSelectionSet(context, cachedFieldsAndFragmentNames, comparedFragments, parentType, selectionSet) {
+	  var conflicts = [];
+
+	  var _getFieldsAndFragment = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType, selectionSet);
+
+	  var fieldMap = _getFieldsAndFragment[0];
+	  var fragmentNames = _getFieldsAndFragment[1];
+
+	  // (A) Find find all conflicts "within" the fields of this selection set.
+	  // Note: this is the *only place* `collectConflictsWithin` is called.
+
+	  collectConflictsWithin(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, fieldMap);
+
+	  // (B) Then collect conflicts between these fields and those represented by
+	  // each spread fragment name found.
+	  for (var i = 0; i < fragmentNames.length; i++) {
+	    collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, false, fieldMap, fragmentNames[i]);
+	    // (C) Then compare this fragment with all other fragments found in this
+	    // selection set to collect conflicts between fragments spread together.
+	    // This compares each item in the list of fragment names to every other item
+	    // in that same list (except for itself).
+	    for (var j = i + 1; j < fragmentNames.length; j++) {
+	      collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, false, fragmentNames[i], fragmentNames[j]);
+	    }
+	  }
+	  return conflicts;
+	}
+
+	// Collect all conflicts found between a set of fields and a fragment reference
+	// including via spreading in any nested fragments.
+	function collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap, fragmentName) {
+	  var fragment = context.getFragment(fragmentName);
+	  if (!fragment) {
+	    return;
+	  }
+
+	  var _getReferencedFieldsA = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment);
+
+	  var fieldMap2 = _getReferencedFieldsA[0];
+	  var fragmentNames2 = _getReferencedFieldsA[1];
+
+	  // (D) First collect any conflicts between the provided collection of fields
+	  // and the collection of fields represented by the given fragment.
+
+	  collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap, fieldMap2);
+
+	  // (E) Then collect any conflicts between the provided collection of fields
+	  // and any fragment names found in the given fragment.
+	  for (var i = 0; i < fragmentNames2.length; i++) {
+	    collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap, fragmentNames2[i]);
+	  }
+	}
+
+	// Collect all conflicts found between two fragments, including via spreading in
+	// any nested fragments.
+	function collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fragmentName1, fragmentName2) {
+	  var fragment1 = context.getFragment(fragmentName1);
+	  var fragment2 = context.getFragment(fragmentName2);
+	  if (!fragment1 || !fragment2) {
+	    return;
+	  }
+
+	  // No need to compare a fragment to itself.
+	  if (fragment1 === fragment2) {
+	    return;
+	  }
+
+	  // Memoize so two fragments are not compared for conflicts more than once.
+	  if (comparedFragments.has(fragmentName1, fragmentName2, areMutuallyExclusive)) {
+	    return;
+	  }
+	  comparedFragments.add(fragmentName1, fragmentName2, areMutuallyExclusive);
+
+	  var _getReferencedFieldsA2 = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment1);
+
+	  var fieldMap1 = _getReferencedFieldsA2[0];
+	  var fragmentNames1 = _getReferencedFieldsA2[1];
+
+	  var _getReferencedFieldsA3 = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment2);
+
+	  var fieldMap2 = _getReferencedFieldsA3[0];
+	  var fragmentNames2 = _getReferencedFieldsA3[1];
+
+	  // (F) First, collect all conflicts between these two collections of fields
+	  // (not including any nested fragments).
+
+	  collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap1, fieldMap2);
+
+	  // (G) Then collect conflicts between the first fragment and any nested
+	  // fragments spread in the second fragment.
+	  for (var j = 0; j < fragmentNames2.length; j++) {
+	    collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fragmentName1, fragmentNames2[j]);
+	  }
+
+	  // (G) Then collect conflicts between the second fragment and any nested
+	  // fragments spread in the first fragment.
+	  for (var i = 0; i < fragmentNames1.length; i++) {
+	    collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fragmentNames1[i], fragmentName2);
+	  }
+	}
+
+	// Find all conflicts found between two selection sets, including those found
+	// via spreading in fragments. Called when determining if conflicts exist
+	// between the sub-fields of two overlapping fields.
+	function findConflictsBetweenSubSelectionSets(context, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, parentType1, selectionSet1, parentType2, selectionSet2) {
+	  var conflicts = [];
+
+	  var _getFieldsAndFragment2 = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType1, selectionSet1);
+
+	  var fieldMap1 = _getFieldsAndFragment2[0];
+	  var fragmentNames1 = _getFieldsAndFragment2[1];
+
+	  var _getFieldsAndFragment3 = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType2, selectionSet2);
+
+	  var fieldMap2 = _getFieldsAndFragment3[0];
+	  var fragmentNames2 = _getFieldsAndFragment3[1];
+
+	  // (H) First, collect all conflicts between these two collections of field.
+
+	  collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap1, fieldMap2);
+
+	  // (I) Then collect conflicts between the first collection of fields and
+	  // those referenced by each fragment name associated with the second.
+	  for (var j = 0; j < fragmentNames2.length; j++) {
+	    collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap1, fragmentNames2[j]);
+	  }
+
+	  // (I) Then collect conflicts between the second collection of fields and
+	  // those referenced by each fragment name associated with the first.
+	  for (var i = 0; i < fragmentNames1.length; i++) {
+	    collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap2, fragmentNames1[i]);
+	  }
+
+	  // (J) Also collect conflicts between any fragment names by the first and
+	  // fragment names by the second. This compares each item in the first set of
+	  // names to each item in the second set of names.
+	  for (var _i = 0; _i < fragmentNames1.length; _i++) {
+	    for (var _j = 0; _j < fragmentNames2.length; _j++) {
+	      collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fragmentNames1[_i], fragmentNames2[_j]);
+	    }
+	  }
+	  return conflicts;
+	}
+
+	// Collect all Conflicts "within" one collection of fields.
+	function collectConflictsWithin(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, fieldMap) {
+	  // A field map is a keyed collection, where each key represents a response
+	  // name and the value at that key is a list of all fields which provide that
+	  // response name. For every response name, if there are multiple fields, they
+	  // must be compared to find a potential conflict.
+	  Object.keys(fieldMap).forEach(function (responseName) {
+	    var fields = fieldMap[responseName];
+	    // This compares every field in the list to every other field in this list
+	    // (except to itself). If the list only has one item, nothing needs to
+	    // be compared.
+	    if (fields.length > 1) {
+	      for (var i = 0; i < fields.length; i++) {
+	        for (var j = i + 1; j < fields.length; j++) {
+	          var conflict = findConflict(context, cachedFieldsAndFragmentNames, comparedFragments, false, // within one collection is never mutually exclusive
+	          responseName, fields[i], fields[j]);
+	          if (conflict) {
+	            conflicts.push(conflict);
+	          }
+	        }
+	      }
+	    }
+	  });
+	}
+
+	// Collect all Conflicts between two collections of fields. This is similar to,
+	// but different from the `collectConflictsWithin` function above. This check
+	// assumes that `collectConflictsWithin` has already been called on each
+	// provided collection of fields. This is true because this validator traverses
+	// each individual selection set.
+	function collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, parentFieldsAreMutuallyExclusive, fieldMap1, fieldMap2) {
+	  // A field map is a keyed collection, where each key represents a response
+	  // name and the value at that key is a list of all fields which provide that
+	  // response name. For any response name which appears in both provided field
+	  // maps, each field from the first field map must be compared to every field
+	  // in the second field map to find potential conflicts.
+	  Object.keys(fieldMap1).forEach(function (responseName) {
+	    var fields2 = fieldMap2[responseName];
+	    if (fields2) {
+	      var fields1 = fieldMap1[responseName];
+	      for (var i = 0; i < fields1.length; i++) {
+	        for (var j = 0; j < fields2.length; j++) {
+	          var conflict = findConflict(context, cachedFieldsAndFragmentNames, comparedFragments, parentFieldsAreMutuallyExclusive, responseName, fields1[i], fields2[j]);
+	          if (conflict) {
+	            conflicts.push(conflict);
+	          }
+	        }
+	      }
+	    }
+	  });
+	}
+
+	// Determines if there is a conflict between two particular fields, including
+	// comparing their sub-fields.
+	function findConflict(context, cachedFieldsAndFragmentNames, comparedFragments, parentFieldsAreMutuallyExclusive, responseName, field1, field2) {
+	  var parentType1 = field1[0];
+	  var ast1 = field1[1];
+	  var def1 = field1[2];
+	  var parentType2 = field2[0];
+	  var ast2 = field2[1];
+	  var def2 = field2[2];
+
+	  // If it is known that two fields could not possibly apply at the same
+	  // time, due to the parent types, then it is safe to permit them to diverge
+	  // in aliased field or arguments used as they will not present any ambiguity
+	  // by differing.
+	  // It is known that two parent types could never overlap if they are
+	  // different Object types. Interface or Union types might overlap - if not
+	  // in the current state of the schema, then perhaps in some future version,
+	  // thus may not safely diverge.
+
+	  var areMutuallyExclusive = parentFieldsAreMutuallyExclusive || parentType1 !== parentType2 && parentType1 instanceof _definition.GraphQLObjectType && parentType2 instanceof _definition.GraphQLObjectType;
+
+	  // The return type for each field.
+	  var type1 = def1 && def1.type;
+	  var type2 = def2 && def2.type;
+
+	  if (!areMutuallyExclusive) {
+	    // Two aliases must refer to the same field.
+	    var name1 = ast1.name.value;
+	    var name2 = ast2.name.value;
+	    if (name1 !== name2) {
+	      return [[responseName, name1 + ' and ' + name2 + ' are different fields'], [ast1], [ast2]];
+	    }
+
+	    // Two field calls must have the same arguments.
+	    if (!sameArguments(ast1.arguments || [], ast2.arguments || [])) {
+	      return [[responseName, 'they have differing arguments'], [ast1], [ast2]];
+	    }
+	  }
+
+	  if (type1 && type2 && doTypesConflict(type1, type2)) {
+	    return [[responseName, 'they return conflicting types ' + String(type1) + ' and ' + String(type2)], [ast1], [ast2]];
+	  }
+
+	  // Collect and compare sub-fields. Use the same "visited fragment names" list
+	  // for both collections so fields in a fragment reference are never
+	  // compared to themselves.
+	  var selectionSet1 = ast1.selectionSet;
+	  var selectionSet2 = ast2.selectionSet;
+	  if (selectionSet1 && selectionSet2) {
+	    var conflicts = findConflictsBetweenSubSelectionSets(context, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, (0, _definition.getNamedType)(type1), selectionSet1, (0, _definition.getNamedType)(type2), selectionSet2);
+	    return subfieldConflicts(conflicts, responseName, ast1, ast2);
+	  }
+	}
+
+	function sameArguments(arguments1, arguments2) {
+	  if (arguments1.length !== arguments2.length) {
+	    return false;
+	  }
+	  return arguments1.every(function (argument1) {
+	    var argument2 = (0, _find2.default)(arguments2, function (argument) {
+	      return argument.name.value === argument1.name.value;
+	    });
+	    if (!argument2) {
+	      return false;
+	    }
+	    return sameValue(argument1.value, argument2.value);
+	  });
+	}
+
+	function sameValue(value1, value2) {
+	  return !value1 && !value2 || (0, _printer.print)(value1) === (0, _printer.print)(value2);
+	}
+
+	// Two types conflict if both types could not apply to a value simultaneously.
+	// Composite types are ignored as their individual field types will be compared
+	// later recursively. However List and Non-Null types must match.
+	function doTypesConflict(type1, type2) {
+	  if (type1 instanceof _definition.GraphQLList) {
+	    return type2 instanceof _definition.GraphQLList ? doTypesConflict(type1.ofType, type2.ofType) : true;
+	  }
+	  if (type2 instanceof _definition.GraphQLList) {
+	    return type1 instanceof _definition.GraphQLList ? doTypesConflict(type1.ofType, type2.ofType) : true;
+	  }
+	  if (type1 instanceof _definition.GraphQLNonNull) {
+	    return type2 instanceof _definition.GraphQLNonNull ? doTypesConflict(type1.ofType, type2.ofType) : true;
+	  }
+	  if (type2 instanceof _definition.GraphQLNonNull) {
+	    return type1 instanceof _definition.GraphQLNonNull ? doTypesConflict(type1.ofType, type2.ofType) : true;
+	  }
+	  if ((0, _definition.isLeafType)(type1) || (0, _definition.isLeafType)(type2)) {
+	    return type1 !== type2;
+	  }
+	  return false;
+	}
+
+	// Given a selection set, return the collection of fields (a mapping of response
+	// name to field ASTs and definitions) as well as a list of fragment names
+	// referenced via fragment spreads.
+	function getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType, selectionSet) {
+	  var cached = cachedFieldsAndFragmentNames.get(selectionSet);
+	  if (!cached) {
+	    var astAndDefs = {};
+	    var fragmentNames = {};
+	    _collectFieldsAndFragmentNames(context, parentType, selectionSet, astAndDefs, fragmentNames);
+	    cached = [astAndDefs, Object.keys(fragmentNames)];
+	    cachedFieldsAndFragmentNames.set(selectionSet, cached);
+	  }
+	  return cached;
+	}
+
+	// Given a reference to a fragment, return the represented collection of fields
+	// as well as a list of nested fragment names referenced via fragment spreads.
+	function getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment) {
+	  // Short-circuit building a type from the AST if possible.
+	  var cached = cachedFieldsAndFragmentNames.get(fragment.selectionSet);
+	  if (cached) {
+	    return cached;
+	  }
+
+	  var fragmentType = (0, _typeFromAST.typeFromAST)(context.getSchema(), fragment.typeCondition);
+	  return getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragmentType, fragment.selectionSet);
+	}
+
+	function _collectFieldsAndFragmentNames(context, parentType, selectionSet, astAndDefs, fragmentNames) {
+	  for (var i = 0; i < selectionSet.selections.length; i++) {
+	    var selection = selectionSet.selections[i];
+	    switch (selection.kind) {
+	      case _kinds.FIELD:
+	        var fieldName = selection.name.value;
+	        var fieldDef = void 0;
+	        if (parentType instanceof _definition.GraphQLObjectType || parentType instanceof _definition.GraphQLInterfaceType) {
+	          fieldDef = parentType.getFields()[fieldName];
+	        }
+	        var responseName = selection.alias ? selection.alias.value : fieldName;
+	        if (!astAndDefs[responseName]) {
+	          astAndDefs[responseName] = [];
+	        }
+	        astAndDefs[responseName].push([parentType, selection, fieldDef]);
+	        break;
+	      case _kinds.FRAGMENT_SPREAD:
+	        fragmentNames[selection.name.value] = true;
+	        break;
+	      case _kinds.INLINE_FRAGMENT:
+	        var typeCondition = selection.typeCondition;
+	        var inlineFragmentType = typeCondition ? (0, _typeFromAST.typeFromAST)(context.getSchema(), typeCondition) : parentType;
+	        _collectFieldsAndFragmentNames(context, inlineFragmentType, selection.selectionSet, astAndDefs, fragmentNames);
+	        break;
+	    }
+	  }
+	}
+
+	// Given a series of Conflicts which occurred between two sub-fields, generate
+	// a single Conflict.
+	function subfieldConflicts(conflicts, responseName, ast1, ast2) {
+	  if (conflicts.length > 0) {
+	    return [[responseName, conflicts.map(function (_ref3) {
+	      var reason = _ref3[0];
+	      return reason;
+	    })], conflicts.reduce(function (allFields, _ref4) {
+	      var fields1 = _ref4[1];
+	      return allFields.concat(fields1);
+	    }, [ast1]), conflicts.reduce(function (allFields, _ref5) {
+	      var fields2 = _ref5[2];
+	      return allFields.concat(fields2);
+	    }, [ast2])];
+	  }
+	}
+
+	/**
+	 * A way to keep track of pairs of things when the ordering of the pair does
+	 * not matter. We do this by maintaining a sort of double adjacency sets.
+	 */
+
+	var PairSet = function () {
+	  function PairSet() {
+	    _classCallCheck(this, PairSet);
+
+	    this._data = Object.create(null);
+	  }
+
+	  PairSet.prototype.has = function has(a, b, areMutuallyExclusive) {
+	    var first = this._data[a];
+	    var result = first && first[b];
+	    if (result === undefined) {
+	      return false;
+	    }
+	    // areMutuallyExclusive being false is a superset of being true,
+	    // hence if we want to know if this PairSet "has" these two with no
+	    // exclusivity, we have to ensure it was added as such.
+	    if (areMutuallyExclusive === false) {
+	      return result === false;
+	    }
+	    return true;
+	  };
+
+	  PairSet.prototype.add = function add(a, b, areMutuallyExclusive) {
+	    _pairSetAdd(this._data, a, b, areMutuallyExclusive);
+	    _pairSetAdd(this._data, b, a, areMutuallyExclusive);
+	  };
+
+	  return PairSet;
+	}();
+
+	function _pairSetAdd(data, a, b, areMutuallyExclusive) {
+	  var map = data[a];
+	  if (!map) {
+	    map = Object.create(null);
+	    data[a] = map;
+	  }
+	  map[b] = areMutuallyExclusive;
+	}
+
+/***/ },
+/* 243 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.duplicateInputFieldMessage = duplicateInputFieldMessage;
+	exports.UniqueInputFieldNames = UniqueInputFieldNames;
+
+	var _error = __webpack_require__(189);
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function duplicateInputFieldMessage(fieldName) {
+	  return 'There can be only one input field named "' + fieldName + '".';
+	}
+
+	/**
+	 * Unique input field names
+	 *
+	 * A GraphQL input object value is only valid if all supplied fields are
+	 * uniquely named.
+	 */
+	function UniqueInputFieldNames(context) {
+	  var knownNameStack = [];
+	  var knownNames = Object.create(null);
+
+	  return {
+	    ObjectValue: {
+	      enter: function enter() {
+	        knownNameStack.push(knownNames);
+	        knownNames = Object.create(null);
+	      },
+	      leave: function leave() {
+	        knownNames = knownNameStack.pop();
+	      }
+	    },
+	    ObjectField: function ObjectField(node) {
+	      var fieldName = node.name.value;
+	      if (knownNames[fieldName]) {
+	        context.reportError(new _error.GraphQLError(duplicateInputFieldMessage(fieldName), [knownNames[fieldName], node.name]));
+	      } else {
+	        knownNames[fieldName] = node.name;
+	      }
+	      return false;
+	    }
+	  };
+	}
+
+/***/ },
+/* 244 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.execute = execute;
+
+	var _iterall = __webpack_require__(210);
+
+	var _error = __webpack_require__(189);
+
+	var _find = __webpack_require__(211);
+
+	var _find2 = _interopRequireDefault(_find);
+
+	var _invariant = __webpack_require__(200);
+
+	var _invariant2 = _interopRequireDefault(_invariant);
+
+	var _isNullish = __webpack_require__(204);
+
+	var _isNullish2 = _interopRequireDefault(_isNullish);
+
+	var _typeFromAST = __webpack_require__(214);
+
+	var _kinds = __webpack_require__(196);
+
+	var Kind = _interopRequireWildcard(_kinds);
+
+	var _values = __webpack_require__(245);
+
+	var _definition = __webpack_require__(203);
+
+	var _schema = __webpack_require__(202);
+
+	var _introspection = __webpack_require__(208);
+
+	var _directives = __webpack_require__(206);
+
+	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 * Implements the "Evaluating requests" section of the GraphQL specification.
+	 *
+	 * Returns a Promise that will eventually be resolved and never rejected.
+	 *
+	 * If the arguments to this function do not result in a legal execution context,
+	 * a GraphQLError will be thrown immediately explaining the invalid input.
+	 */
+
+
+	/**
+	 * Terminology
+	 *
+	 * "Definitions" are the generic name for top-level statements in the document.
+	 * Examples of this include:
+	 * 1) Operations (such as a query)
+	 * 2) Fragments
+	 *
+	 * "Operations" are a generic name for requests in the document.
+	 * Examples of this include:
+	 * 1) query,
+	 * 2) mutation
+	 *
+	 * "Selections" are the definitions that can appear legally and at
+	 * single level of the query. These include:
+	 * 1) field references e.g "a"
+	 * 2) fragment "spreads" e.g. "...c"
+	 * 3) inline fragment "spreads" e.g. "...on Type { a }"
+	 */
+
+	/**
+	 * Data that must be available at all points during query execution.
+	 *
+	 * Namely, schema of the type system that is currently executing,
+	 * and the fragments defined in the query document
+	 */
+
+
+	/**
+	 * The result of execution. `data` is the result of executing the
+	 * query, `errors` is null if no errors occurred, and is a
+	 * non-empty array if an error occurred.
+	 */
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function execute(schema, documentAST, rootValue, contextValue, variableValues, operationName) {
+	  (0, _invariant2.default)(schema, 'Must provide schema');
+	  (0, _invariant2.default)(schema instanceof _schema.GraphQLSchema, 'Schema must be an instance of GraphQLSchema. Also ensure that there are ' + 'not multiple versions of GraphQL installed in your node_modules directory.');
+
+	  // Variables, if provided, must be an object.
+	  (0, _invariant2.default)(!variableValues || typeof variableValues === 'object', 'Variables must be provided as an Object where each property is a ' + 'variable value. Perhaps look to see if an unparsed JSON string ' + 'was provided.');
+
+	  // If a valid context cannot be created due to incorrect arguments,
+	  // this will throw an error.
+	  var context = buildExecutionContext(schema, documentAST, rootValue, contextValue, variableValues, operationName);
+
+	  // Return a Promise that will eventually resolve to the data described by
+	  // The "Response" section of the GraphQL specification.
+	  //
+	  // If errors are encountered while executing a GraphQL field, only that
+	  // field and its descendants will be omitted, and sibling fields will still
+	  // be executed. An execution which encounters errors will still result in a
+	  // resolved Promise.
+	  return new Promise(function (resolve) {
+	    resolve(executeOperation(context, context.operation, rootValue));
+	  }).then(undefined, function (error) {
+	    // Errors from sub-fields of a NonNull type may propagate to the top level,
+	    // at which point we still log the error and null the parent field, which
+	    // in this case is the entire response.
+	    context.errors.push(error);
+	    return null;
+	  }).then(function (data) {
+	    if (!context.errors.length) {
+	      return { data: data };
+	    }
+	    return { data: data, errors: context.errors };
+	  });
+	}
+
+	/**
+	 * Constructs a ExecutionContext object from the arguments passed to
+	 * execute, which we will pass throughout the other execution methods.
+	 *
+	 * Throws a GraphQLError if a valid execution context cannot be created.
+	 */
+	function buildExecutionContext(schema, documentAST, rootValue, contextValue, rawVariableValues, operationName) {
+	  var errors = [];
+	  var operation = void 0;
+	  var fragments = Object.create(null);
+	  documentAST.definitions.forEach(function (definition) {
+	    switch (definition.kind) {
+	      case Kind.OPERATION_DEFINITION:
+	        if (!operationName && operation) {
+	          throw new _error.GraphQLError('Must provide operation name if query contains multiple operations.');
+	        }
+	        if (!operationName || definition.name && definition.name.value === operationName) {
+	          operation = definition;
+	        }
+	        break;
+	      case Kind.FRAGMENT_DEFINITION:
+	        fragments[definition.name.value] = definition;
+	        break;
+	      default:
+	        throw new _error.GraphQLError('GraphQL cannot execute a request containing a ' + definition.kind + '.', [definition]);
+	    }
+	  });
+	  if (!operation) {
+	    if (operationName) {
+	      throw new _error.GraphQLError('Unknown operation named "' + operationName + '".');
+	    } else {
+	      throw new _error.GraphQLError('Must provide an operation.');
+	    }
+	  }
+	  var variableValues = (0, _values.getVariableValues)(schema, operation.variableDefinitions || [], rawVariableValues || {});
+
+	  return {
+	    schema: schema,
+	    fragments: fragments,
+	    rootValue: rootValue,
+	    contextValue: contextValue,
+	    operation: operation,
+	    variableValues: variableValues,
+	    errors: errors
+	  };
+	}
+
+	/**
+	 * Implements the "Evaluating operations" section of the spec.
+	 */
+	function executeOperation(exeContext, operation, rootValue) {
+	  var type = getOperationRootType(exeContext.schema, operation);
+	  var fields = collectFields(exeContext, type, operation.selectionSet, Object.create(null), Object.create(null));
+
+	  var path = [];
+
+	  if (operation.operation === 'mutation') {
+	    return executeFieldsSerially(exeContext, type, rootValue, path, fields);
+	  }
+	  return executeFields(exeContext, type, rootValue, path, fields);
+	}
+
+	/**
+	 * Extracts the root type of the operation from the schema.
+	 */
+	function getOperationRootType(schema, operation) {
+	  switch (operation.operation) {
+	    case 'query':
+	      return schema.getQueryType();
+	    case 'mutation':
+	      var mutationType = schema.getMutationType();
+	      if (!mutationType) {
+	        throw new _error.GraphQLError('Schema is not configured for mutations', [operation]);
+	      }
+	      return mutationType;
+	    case 'subscription':
+	      var subscriptionType = schema.getSubscriptionType();
+	      if (!subscriptionType) {
+	        throw new _error.GraphQLError('Schema is not configured for subscriptions', [operation]);
+	      }
+	      return subscriptionType;
+	    default:
+	      throw new _error.GraphQLError('Can only execute queries, mutations and subscriptions', [operation]);
+	  }
+	}
+
+	/**
+	 * Implements the "Evaluating selection sets" section of the spec
+	 * for "write" mode.
+	 */
+	function executeFieldsSerially(exeContext, parentType, sourceValue, path, fields) {
+	  return Object.keys(fields).reduce(function (prevPromise, responseName) {
+	    return prevPromise.then(function (results) {
+	      var fieldASTs = fields[responseName];
+	      var fieldPath = path.concat([responseName]);
+	      var result = resolveField(exeContext, parentType, sourceValue, fieldASTs, fieldPath);
+	      if (result === undefined) {
+	        return results;
+	      }
+	      if (isThenable(result)) {
+	        return result.then(function (resolvedResult) {
+	          results[responseName] = resolvedResult;
+	          return results;
+	        });
+	      }
+	      results[responseName] = result;
+	      return results;
+	    });
+	  }, Promise.resolve({}));
+	}
+
+	/**
+	 * Implements the "Evaluating selection sets" section of the spec
+	 * for "read" mode.
+	 */
+	function executeFields(exeContext, parentType, sourceValue, path, fields) {
+	  var containsPromise = false;
+
+	  var finalResults = Object.keys(fields).reduce(function (results, responseName) {
+	    var fieldASTs = fields[responseName];
+	    var fieldPath = path.concat([responseName]);
+	    var result = resolveField(exeContext, parentType, sourceValue, fieldASTs, fieldPath);
+	    if (result === undefined) {
+	      return results;
+	    }
+	    results[responseName] = result;
+	    if (isThenable(result)) {
+	      containsPromise = true;
+	    }
+	    return results;
+	  }, Object.create(null));
+
+	  // If there are no promises, we can just return the object
+	  if (!containsPromise) {
+	    return finalResults;
+	  }
+
+	  // Otherwise, results is a map from field name to the result
+	  // of resolving that field, which is possibly a promise. Return
+	  // a promise that will return this same map, but with any
+	  // promises replaced with the values they resolved to.
+	  return promiseForObject(finalResults);
+	}
+
+	/**
+	 * Given a selectionSet, adds all of the fields in that selection to
+	 * the passed in map of fields, and returns it at the end.
+	 *
+	 * CollectFields requires the "runtime type" of an object. For a field which
+	 * returns and Interface or Union type, the "runtime type" will be the actual
+	 * Object type returned by that field.
+	 */
+	function collectFields(exeContext, runtimeType, selectionSet, fields, visitedFragmentNames) {
+	  for (var i = 0; i < selectionSet.selections.length; i++) {
+	    var selection = selectionSet.selections[i];
+	    switch (selection.kind) {
+	      case Kind.FIELD:
+	        if (!shouldIncludeNode(exeContext, selection.directives)) {
+	          continue;
+	        }
+	        var _name = getFieldEntryKey(selection);
+	        if (!fields[_name]) {
+	          fields[_name] = [];
+	        }
+	        fields[_name].push(selection);
+	        break;
+	      case Kind.INLINE_FRAGMENT:
+	        if (!shouldIncludeNode(exeContext, selection.directives) || !doesFragmentConditionMatch(exeContext, selection, runtimeType)) {
+	          continue;
+	        }
+	        collectFields(exeContext, runtimeType, selection.selectionSet, fields, visitedFragmentNames);
+	        break;
+	      case Kind.FRAGMENT_SPREAD:
+	        var fragName = selection.name.value;
+	        if (visitedFragmentNames[fragName] || !shouldIncludeNode(exeContext, selection.directives)) {
+	          continue;
+	        }
+	        visitedFragmentNames[fragName] = true;
+	        var fragment = exeContext.fragments[fragName];
+	        if (!fragment || !doesFragmentConditionMatch(exeContext, fragment, runtimeType)) {
+	          continue;
+	        }
+	        collectFields(exeContext, runtimeType, fragment.selectionSet, fields, visitedFragmentNames);
+	        break;
+	    }
+	  }
+	  return fields;
+	}
+
+	/**
+	 * Determines if a field should be included based on the @include and @skip
+	 * directives, where @skip has higher precidence than @include.
+	 */
+	function shouldIncludeNode(exeContext, directives) {
+	  var skipAST = directives && (0, _find2.default)(directives, function (directive) {
+	    return directive.name.value === _directives.GraphQLSkipDirective.name;
+	  });
+	  if (skipAST) {
+	    var _getArgumentValues = (0, _values.getArgumentValues)(_directives.GraphQLSkipDirective.args, skipAST.arguments, exeContext.variableValues);
+
+	    var skipIf = _getArgumentValues.if;
+
+	    if (skipIf === true) {
+	      return false;
+	    }
+	  }
+
+	  var includeAST = directives && (0, _find2.default)(directives, function (directive) {
+	    return directive.name.value === _directives.GraphQLIncludeDirective.name;
+	  });
+	  if (includeAST) {
+	    var _getArgumentValues2 = (0, _values.getArgumentValues)(_directives.GraphQLIncludeDirective.args, includeAST.arguments, exeContext.variableValues);
+
+	    var includeIf = _getArgumentValues2.if;
+
+	    if (includeIf === false) {
+	      return false;
+	    }
+	  }
+
+	  return true;
+	}
+
+	/**
+	 * Determines if a fragment is applicable to the given type.
+	 */
+	function doesFragmentConditionMatch(exeContext, fragment, type) {
+	  var typeConditionAST = fragment.typeCondition;
+	  if (!typeConditionAST) {
+	    return true;
+	  }
+	  var conditionalType = (0, _typeFromAST.typeFromAST)(exeContext.schema, typeConditionAST);
+	  if (conditionalType === type) {
+	    return true;
+	  }
+	  if ((0, _definition.isAbstractType)(conditionalType)) {
+	    var abstractType = conditionalType;
+	    return exeContext.schema.isPossibleType(abstractType, type);
+	  }
+	  return false;
+	}
+
+	/**
+	 * This function transforms a JS object `{[key: string]: Promise<T>}` into
+	 * a `Promise<{[key: string]: T}>`
+	 *
+	 * This is akin to bluebird's `Promise.props`, but implemented only using
+	 * `Promise.all` so it will work with any implementation of ES6 promises.
+	 */
+	function promiseForObject(object) {
+	  var keys = Object.keys(object);
+	  var valuesAndPromises = keys.map(function (name) {
+	    return object[name];
+	  });
+	  return Promise.all(valuesAndPromises).then(function (values) {
+	    return values.reduce(function (resolvedObject, value, i) {
+	      resolvedObject[keys[i]] = value;
+	      return resolvedObject;
+	    }, Object.create(null));
+	  });
+	}
+
+	/**
+	 * Implements the logic to compute the key of a given field's entry
+	 */
+	function getFieldEntryKey(node) {
+	  return node.alias ? node.alias.value : node.name.value;
+	}
+
+	/**
+	 * Resolves the field on the given source object. In particular, this
+	 * figures out the value that the field returns by calling its resolve function,
+	 * then calls completeValue to complete promises, serialize scalars, or execute
+	 * the sub-selection-set for objects.
+	 */
+	function resolveField(exeContext, parentType, source, fieldASTs, path) {
+	  var fieldAST = fieldASTs[0];
+	  var fieldName = fieldAST.name.value;
+
+	  var fieldDef = getFieldDef(exeContext.schema, parentType, fieldName);
+	  if (!fieldDef) {
+	    return;
+	  }
+
+	  var returnType = fieldDef.type;
+	  var resolveFn = fieldDef.resolve || defaultResolveFn;
+
+	  // Build a JS object of arguments from the field.arguments AST, using the
+	  // variables scope to fulfill any variable references.
+	  // TODO: find a way to memoize, in case this field is within a List type.
+	  var args = (0, _values.getArgumentValues)(fieldDef.args, fieldAST.arguments, exeContext.variableValues);
+
+	  // The resolve function's optional third argument is a context value that
+	  // is provided to every resolve function within an execution. It is commonly
+	  // used to represent an authenticated user, or request-specific caches.
+	  var context = exeContext.contextValue;
+
+	  // The resolve function's optional fourth argument is a collection of
+	  // information about the current execution state.
+	  var info = {
+	    fieldName: fieldName,
+	    fieldASTs: fieldASTs,
+	    returnType: returnType,
+	    parentType: parentType,
+	    path: path,
+	    schema: exeContext.schema,
+	    fragments: exeContext.fragments,
+	    rootValue: exeContext.rootValue,
+	    operation: exeContext.operation,
+	    variableValues: exeContext.variableValues
+	  };
+
+	  // Get the resolve function, regardless of if its result is normal
+	  // or abrupt (error).
+	  var result = resolveOrError(resolveFn, source, args, context, info);
+
+	  return completeValueCatchingError(exeContext, returnType, fieldASTs, info, path, result);
+	}
+
+	// Isolates the "ReturnOrAbrupt" behavior to not de-opt the `resolveField`
+	// function. Returns the result of resolveFn or the abrupt-return Error object.
+	function resolveOrError(resolveFn, source, args, context, info) {
+	  try {
+	    return resolveFn(source, args, context, info);
+	  } catch (error) {
+	    // Sometimes a non-error is thrown, wrap it as an Error for a
+	    // consistent interface.
+	    return error instanceof Error ? error : new Error(error);
+	  }
+	}
+
+	// This is a small wrapper around completeValue which detects and logs errors
+	// in the execution context.
+	function completeValueCatchingError(exeContext, returnType, fieldASTs, info, path, result) {
+	  // If the field type is non-nullable, then it is resolved without any
+	  // protection from errors, however it still properly locates the error.
+	  if (returnType instanceof _definition.GraphQLNonNull) {
+	    return completeValueWithLocatedError(exeContext, returnType, fieldASTs, info, path, result);
+	  }
+
+	  // Otherwise, error protection is applied, logging the error and resolving
+	  // a null value for this field if one is encountered.
+	  try {
+	    var completed = completeValueWithLocatedError(exeContext, returnType, fieldASTs, info, path, result);
+	    if (isThenable(completed)) {
+	      // If `completeValueWithLocatedError` returned a rejected promise, log
+	      // the rejection error and resolve to null.
+	      // Note: we don't rely on a `catch` method, but we do expect "thenable"
+	      // to take a second callback for the error case.
+	      return completed.then(undefined, function (error) {
+	        exeContext.errors.push(error);
+	        return Promise.resolve(null);
+	      });
+	    }
+	    return completed;
+	  } catch (error) {
+	    // If `completeValueWithLocatedError` returned abruptly (threw an error),
+	    // log the error and return null.
+	    exeContext.errors.push(error);
+	    return null;
+	  }
+	}
+
+	// This is a small wrapper around completeValue which annotates errors with
+	// location information.
+	function completeValueWithLocatedError(exeContext, returnType, fieldASTs, info, path, result) {
+	  try {
+	    var completed = completeValue(exeContext, returnType, fieldASTs, info, path, result);
+	    if (isThenable(completed)) {
+	      return completed.then(undefined, function (error) {
+	        return Promise.reject((0, _error.locatedError)(error, fieldASTs, path));
+	      });
+	    }
+	    return completed;
+	  } catch (error) {
+	    throw (0, _error.locatedError)(error, fieldASTs, path);
+	  }
+	}
+
+	/**
+	 * Implements the instructions for completeValue as defined in the
+	 * "Field entries" section of the spec.
+	 *
+	 * If the field type is Non-Null, then this recursively completes the value
+	 * for the inner type. It throws a field error if that completion returns null,
+	 * as per the "Nullability" section of the spec.
+	 *
+	 * If the field type is a List, then this recursively completes the value
+	 * for the inner type on each item in the list.
+	 *
+	 * If the field type is a Scalar or Enum, ensures the completed value is a legal
+	 * value of the type by calling the `serialize` method of GraphQL type
+	 * definition.
+	 *
+	 * If the field is an abstract type, determine the runtime type of the value
+	 * and then complete based on that type
+	 *
+	 * Otherwise, the field type expects a sub-selection set, and will complete the
+	 * value by evaluating all sub-selections.
+	 */
+	function completeValue(exeContext, returnType, fieldASTs, info, path, result) {
+	  // If result is a Promise, apply-lift over completeValue.
+	  if (isThenable(result)) {
+	    return result.then(function (resolved) {
+	      return completeValue(exeContext, returnType, fieldASTs, info, path, resolved);
+	    });
+	  }
+
+	  // If result is an Error, throw a located error.
+	  if (result instanceof Error) {
+	    throw result;
+	  }
+
+	  // If field type is NonNull, complete for inner type, and throw field error
+	  // if result is null.
+	  if (returnType instanceof _definition.GraphQLNonNull) {
+	    var completed = completeValue(exeContext, returnType.ofType, fieldASTs, info, path, result);
+	    if (completed === null) {
+	      throw new Error('Cannot return null for non-nullable field ' + info.parentType.name + '.' + info.fieldName + '.');
+	    }
+	    return completed;
+	  }
+
+	  // If result value is null-ish (null, undefined, or NaN) then return null.
+	  if ((0, _isNullish2.default)(result)) {
+	    return null;
+	  }
+
+	  // If field type is List, complete each item in the list with the inner type
+	  if (returnType instanceof _definition.GraphQLList) {
+	    return completeListValue(exeContext, returnType, fieldASTs, info, path, result);
+	  }
+
+	  // If field type is a leaf type, Scalar or Enum, serialize to a valid value,
+	  // returning null if serialization is not possible.
+	  if (returnType instanceof _definition.GraphQLScalarType || returnType instanceof _definition.GraphQLEnumType) {
+	    return completeLeafValue(returnType, result);
+	  }
+
+	  // If field type is an abstract type, Interface or Union, determine the
+	  // runtime Object type and complete for that type.
+	  if (returnType instanceof _definition.GraphQLInterfaceType || returnType instanceof _definition.GraphQLUnionType) {
+	    return completeAbstractValue(exeContext, returnType, fieldASTs, info, path, result);
+	  }
+
+	  // If field type is Object, execute and complete all sub-selections.
+	  if (returnType instanceof _definition.GraphQLObjectType) {
+	    return completeObjectValue(exeContext, returnType, fieldASTs, info, path, result);
+	  }
+
+	  // Not reachable. All possible output types have been considered.
+	  throw new Error('Cannot complete value of unexpected type "' + String(returnType) + '".');
+	}
+
+	/**
+	 * Complete a list value by completing each item in the list with the
+	 * inner type
+	 */
+	function completeListValue(exeContext, returnType, fieldASTs, info, path, result) {
+	  (0, _invariant2.default)((0, _iterall.isCollection)(result), 'Expected Iterable, but did not find one for field ' + info.parentType.name + '.' + info.fieldName + '.');
+
+	  // This is specified as a simple map, however we're optimizing the path
+	  // where the list contains no Promises by avoiding creating another Promise.
+	  var itemType = returnType.ofType;
+	  var containsPromise = false;
+	  var completedResults = [];
+	  (0, _iterall.forEach)(result, function (item, index) {
+	    // No need to modify the info object containing the path,
+	    // since from here on it is not ever accessed by resolver functions.
+	    var fieldPath = path.concat([index]);
+	    var completedItem = completeValueCatchingError(exeContext, itemType, fieldASTs, info, fieldPath, item);
+
+	    if (!containsPromise && isThenable(completedItem)) {
+	      containsPromise = true;
+	    }
+	    completedResults.push(completedItem);
+	  });
+
+	  return containsPromise ? Promise.all(completedResults) : completedResults;
+	}
+
+	/**
+	 * Complete a Scalar or Enum by serializing to a valid value, returning
+	 * null if serialization is not possible.
+	 */
+	function completeLeafValue(returnType, result) {
+	  (0, _invariant2.default)(returnType.serialize, 'Missing serialize method on type');
+	  var serializedResult = returnType.serialize(result);
+	  if ((0, _isNullish2.default)(serializedResult)) {
+	    throw new Error('Expected a value of type "' + String(returnType) + '" but ' + ('received: ' + String(result)));
+	  }
+	  return serializedResult;
+	}
+
+	/**
+	 * Complete a value of an abstract type by determining the runtime object type
+	 * of that value, then complete the value for that type.
+	 */
+	function completeAbstractValue(exeContext, returnType, fieldASTs, info, path, result) {
+	  var runtimeType = returnType.resolveType ? returnType.resolveType(result, exeContext.contextValue, info) : defaultResolveTypeFn(result, exeContext.contextValue, info, returnType);
+
+	  // If resolveType returns a string, we assume it's a GraphQLObjectType name.
+	  if (typeof runtimeType === 'string') {
+	    runtimeType = exeContext.schema.getType(runtimeType);
+	  }
+
+	  if (!(runtimeType instanceof _definition.GraphQLObjectType)) {
+	    throw new _error.GraphQLError('Abstract type ' + returnType.name + ' must resolve to an Object type at ' + ('runtime for field ' + info.parentType.name + '.' + info.fieldName + ' with ') + ('value "' + String(result) + '", received "' + String(runtimeType) + '".'), fieldASTs);
+	  }
+
+	  if (!exeContext.schema.isPossibleType(returnType, runtimeType)) {
+	    throw new _error.GraphQLError('Runtime Object type "' + runtimeType.name + '" is not a possible type ' + ('for "' + returnType.name + '".'), fieldASTs);
+	  }
+
+	  return completeObjectValue(exeContext, runtimeType, fieldASTs, info, path, result);
+	}
+
+	/**
+	 * Complete an Object value by executing all sub-selections.
+	 */
+	function completeObjectValue(exeContext, returnType, fieldASTs, info, path, result) {
+	  // If there is an isTypeOf predicate function, call it with the
+	  // current result. If isTypeOf returns false, then raise an error rather
+	  // than continuing execution.
+	  if (returnType.isTypeOf && !returnType.isTypeOf(result, exeContext.contextValue, info)) {
+	    throw new _error.GraphQLError('Expected value of type "' + returnType.name + '" but got: ' + String(result) + '.', fieldASTs);
+	  }
+
+	  // Collect sub-fields to execute to complete this value.
+	  var subFieldASTs = Object.create(null);
+	  var visitedFragmentNames = Object.create(null);
+	  for (var i = 0; i < fieldASTs.length; i++) {
+	    var selectionSet = fieldASTs[i].selectionSet;
+	    if (selectionSet) {
+	      subFieldASTs = collectFields(exeContext, returnType, selectionSet, subFieldASTs, visitedFragmentNames);
+	    }
+	  }
+
+	  return executeFields(exeContext, returnType, result, path, subFieldASTs);
+	}
+
+	/**
+	 * If a resolveType function is not given, then a default resolve behavior is
+	 * used which tests each possible type for the abstract type by calling
+	 * isTypeOf for the object being coerced, returning the first type that matches.
+	 */
+	function defaultResolveTypeFn(value, context, info, abstractType) {
+	  var possibleTypes = info.schema.getPossibleTypes(abstractType);
+	  for (var i = 0; i < possibleTypes.length; i++) {
+	    var type = possibleTypes[i];
+	    if (type.isTypeOf && type.isTypeOf(value, context, info)) {
+	      return type;
+	    }
+	  }
+	}
+
+	/**
+	 * If a resolve function is not given, then a default resolve behavior is used
+	 * which takes the property of the source object of the same name as the field
+	 * and returns it as the result, or if it's a function, returns the result
+	 * of calling that function while passing along args and context.
+	 */
+	function defaultResolveFn(source, args, context, _ref) {
+	  var fieldName = _ref.fieldName;
+
+	  // ensure source is a value for which property access is acceptable.
+	  if (typeof source === 'object' || typeof source === 'function') {
+	    var property = source[fieldName];
+	    if (typeof property === 'function') {
+	      return source[fieldName](args, context);
+	    }
+	    return property;
+	  }
+	}
+
+	/**
+	 * Checks to see if this object acts like a Promise, i.e. has a "then"
+	 * function.
+	 */
+	function isThenable(value) {
+	  return typeof value === 'object' && value !== null && typeof value.then === 'function';
+	}
+
+	/**
+	 * This method looks up the field on the given type defintion.
+	 * It has special casing for the two introspection fields, __schema
+	 * and __typename. __typename is special because it can always be
+	 * queried as a field, even in situations where no other fields
+	 * are allowed, like on a Union. __schema could get automatically
+	 * added to the query type, but that would require mutating type
+	 * definitions, which would cause issues.
+	 */
+	function getFieldDef(schema, parentType, fieldName) {
+	  if (fieldName === _introspection.SchemaMetaFieldDef.name && schema.getQueryType() === parentType) {
+	    return _introspection.SchemaMetaFieldDef;
+	  } else if (fieldName === _introspection.TypeMetaFieldDef.name && schema.getQueryType() === parentType) {
+	    return _introspection.TypeMetaFieldDef;
+	  } else if (fieldName === _introspection.TypeNameMetaFieldDef.name) {
+	    return _introspection.TypeNameMetaFieldDef;
+	  }
+	  return parentType.getFields()[fieldName];
+	}
+
+/***/ },
+/* 245 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.getVariableValues = getVariableValues;
+	exports.getArgumentValues = getArgumentValues;
+
+	var _iterall = __webpack_require__(210);
+
+	var _error = __webpack_require__(189);
+
+	var _invariant = __webpack_require__(200);
+
+	var _invariant2 = _interopRequireDefault(_invariant);
+
+	var _isNullish = __webpack_require__(204);
+
+	var _isNullish2 = _interopRequireDefault(_isNullish);
+
+	var _keyMap = __webpack_require__(238);
+
+	var _keyMap2 = _interopRequireDefault(_keyMap);
+
+	var _typeFromAST = __webpack_require__(214);
+
+	var _valueFromAST = __webpack_require__(246);
+
+	var _isValidJSValue = __webpack_require__(247);
+
+	var _printer = __webpack_require__(194);
+
+	var _definition = __webpack_require__(203);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 * Prepares an object map of variableValues of the correct type based on the
+	 * provided variable definitions and arbitrary input. If the input cannot be
+	 * parsed to match the variable definitions, a GraphQLError will be thrown.
+	 */
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function getVariableValues(schema, definitionASTs, inputs) {
+	  return definitionASTs.reduce(function (values, defAST) {
+	    var varName = defAST.variable.name.value;
+	    values[varName] = getVariableValue(schema, defAST, inputs[varName]);
+	    return values;
+	  }, {});
+	}
+
+	/**
+	 * Prepares an object map of argument values given a list of argument
+	 * definitions and list of argument AST nodes.
+	 */
+	function getArgumentValues(argDefs, argASTs, variableValues) {
+	  if (!argDefs || !argASTs) {
+	    return {};
+	  }
+	  var argASTMap = (0, _keyMap2.default)(argASTs, function (arg) {
+	    return arg.name.value;
+	  });
+	  return argDefs.reduce(function (result, argDef) {
+	    var name = argDef.name;
+	    var valueAST = argASTMap[name] ? argASTMap[name].value : null;
+	    var value = (0, _valueFromAST.valueFromAST)(valueAST, argDef.type, variableValues);
+	    if ((0, _isNullish2.default)(value)) {
+	      value = argDef.defaultValue;
+	    }
+	    if (!(0, _isNullish2.default)(value)) {
+	      result[name] = value;
+	    }
+	    return result;
+	  }, {});
+	}
+
+	/**
+	 * Given a variable definition, and any value of input, return a value which
+	 * adheres to the variable definition, or throw an error.
+	 */
+	function getVariableValue(schema, definitionAST, input) {
+	  var type = (0, _typeFromAST.typeFromAST)(schema, definitionAST.type);
+	  var variable = definitionAST.variable;
+	  if (!type || !(0, _definition.isInputType)(type)) {
+	    throw new _error.GraphQLError('Variable "$' + variable.name.value + '" expected value of type ' + ('"' + (0, _printer.print)(definitionAST.type) + '" which cannot be used as an input type.'), [definitionAST]);
+	  }
+	  var inputType = type;
+	  var errors = (0, _isValidJSValue.isValidJSValue)(input, inputType);
+	  if (!errors.length) {
+	    if ((0, _isNullish2.default)(input)) {
+	      var defaultValue = definitionAST.defaultValue;
+	      if (defaultValue) {
+	        return (0, _valueFromAST.valueFromAST)(defaultValue, inputType);
+	      }
+	    }
+	    return coerceValue(inputType, input);
+	  }
+	  if ((0, _isNullish2.default)(input)) {
+	    throw new _error.GraphQLError('Variable "$' + variable.name.value + '" of required type ' + ('"' + (0, _printer.print)(definitionAST.type) + '" was not provided.'), [definitionAST]);
+	  }
+	  var message = errors ? '\n' + errors.join('\n') : '';
+	  throw new _error.GraphQLError('Variable "$' + variable.name.value + '" got invalid value ' + (JSON.stringify(input) + '.' + message), [definitionAST]);
+	}
+
+	/**
+	 * Given a type and any value, return a runtime value coerced to match the type.
+	 */
+	function coerceValue(type, value) {
+	  // Ensure flow knows that we treat function params as const.
+	  var _value = value;
+
+	  if (type instanceof _definition.GraphQLNonNull) {
+	    // Note: we're not checking that the result of coerceValue is non-null.
+	    // We only call this function after calling isValidJSValue.
+	    return coerceValue(type.ofType, _value);
+	  }
+
+	  if ((0, _isNullish2.default)(_value)) {
+	    return null;
+	  }
+
+	  if (type instanceof _definition.GraphQLList) {
+	    var _ret = function () {
+	      var itemType = type.ofType;
+	      if ((0, _iterall.isCollection)(_value)) {
+	        var _ret2 = function () {
+	          var coercedValues = [];
+	          (0, _iterall.forEach)(_value, function (item) {
+	            coercedValues.push(coerceValue(itemType, item));
+	          });
+	          return {
+	            v: {
+	              v: coercedValues
+	            }
+	          };
+	        }();
+
+	        if (typeof _ret2 === "object") return _ret2.v;
+	      }
+	      return {
+	        v: [coerceValue(itemType, _value)]
+	      };
+	    }();
+
+	    if (typeof _ret === "object") return _ret.v;
+	  }
+
+	  if (type instanceof _definition.GraphQLInputObjectType) {
+	    var _ret3 = function () {
+	      if (typeof _value !== 'object' || _value === null) {
+	        return {
+	          v: null
+	        };
+	      }
+	      var fields = type.getFields();
+	      return {
+	        v: Object.keys(fields).reduce(function (obj, fieldName) {
+	          var field = fields[fieldName];
+	          var fieldValue = coerceValue(field.type, _value[fieldName]);
+	          if ((0, _isNullish2.default)(fieldValue)) {
+	            fieldValue = field.defaultValue;
+	          }
+	          if (!(0, _isNullish2.default)(fieldValue)) {
+	            obj[fieldName] = fieldValue;
+	          }
+	          return obj;
+	        }, {})
+	      };
+	    }();
+
+	    if (typeof _ret3 === "object") return _ret3.v;
+	  }
+
+	  (0, _invariant2.default)(type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType, 'Must be input type');
+
+	  var parsed = type.parseValue(_value);
+	  if (!(0, _isNullish2.default)(parsed)) {
+	    return parsed;
+	  }
+	}
+
+/***/ },
+/* 246 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.valueFromAST = valueFromAST;
+
+	var _keyMap = __webpack_require__(238);
+
+	var _keyMap2 = _interopRequireDefault(_keyMap);
+
+	var _invariant = __webpack_require__(200);
+
+	var _invariant2 = _interopRequireDefault(_invariant);
+
+	var _isNullish = __webpack_require__(204);
+
+	var _isNullish2 = _interopRequireDefault(_isNullish);
+
+	var _kinds = __webpack_require__(196);
+
+	var Kind = _interopRequireWildcard(_kinds);
+
+	var _definition = __webpack_require__(203);
+
+	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 * Produces a JavaScript value given a GraphQL Value AST.
+	 *
+	 * A GraphQL type must be provided, which will be used to interpret different
+	 * GraphQL Value literals.
+	 *
+	 * | GraphQL Value        | JSON Value    |
+	 * | -------------------- | ------------- |
+	 * | Input Object         | Object        |
+	 * | List                 | Array         |
+	 * | Boolean              | Boolean       |
+	 * | String               | String        |
+	 * | Int / Float          | Number        |
+	 * | Enum Value           | Mixed         |
+	 *
+	 */
+	function valueFromAST(valueAST, type, variables) {
+	  if (type instanceof _definition.GraphQLNonNull) {
+	    // Note: we're not checking that the result of valueFromAST is non-null.
+	    // We're assuming that this query has been validated and the value used
+	    // here is of the correct type.
+	    return valueFromAST(valueAST, type.ofType, variables);
+	  }
+
+	  if (!valueAST) {
+	    return null;
+	  }
+
+	  if (valueAST.kind === Kind.VARIABLE) {
+	    var variableName = valueAST.name.value;
+	    if (!variables || !variables.hasOwnProperty(variableName)) {
+	      return null;
+	    }
+	    // Note: we're not doing any checking that this variable is correct. We're
+	    // assuming that this query has been validated and the variable usage here
+	    // is of the correct type.
+	    return variables[variableName];
+	  }
+
+	  if (type instanceof _definition.GraphQLList) {
+	    var _ret = function () {
+	      var itemType = type.ofType;
+	      if (valueAST.kind === Kind.LIST) {
+	        return {
+	          v: valueAST.values.map(function (itemAST) {
+	            return valueFromAST(itemAST, itemType, variables);
+	          })
+	        };
+	      }
+	      return {
+	        v: [valueFromAST(valueAST, itemType, variables)]
+	      };
+	    }();
+
+	    if (typeof _ret === "object") return _ret.v;
+	  }
+
+	  if (type instanceof _definition.GraphQLInputObjectType) {
+	    var _ret2 = function () {
+	      if (valueAST.kind !== Kind.OBJECT) {
+	        return {
+	          v: null
+	        };
+	      }
+	      var fields = type.getFields();
+	      var fieldASTs = (0, _keyMap2.default)(valueAST.fields, function (field) {
+	        return field.name.value;
+	      });
+	      return {
+	        v: Object.keys(fields).reduce(function (obj, fieldName) {
+	          var field = fields[fieldName];
+	          var fieldAST = fieldASTs[fieldName];
+	          var fieldValue = valueFromAST(fieldAST && fieldAST.value, field.type, variables);
+	          if ((0, _isNullish2.default)(fieldValue)) {
+	            fieldValue = field.defaultValue;
+	          }
+	          if (!(0, _isNullish2.default)(fieldValue)) {
+	            obj[fieldName] = fieldValue;
+	          }
+	          return obj;
+	        }, {})
+	      };
+	    }();
+
+	    if (typeof _ret2 === "object") return _ret2.v;
+	  }
+
+	  (0, _invariant2.default)(type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType, 'Must be input type');
+
+	  var parsed = type.parseLiteral(valueAST);
+	  if (!(0, _isNullish2.default)(parsed)) {
+	    return parsed;
+	  }
+	}
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+/***/ },
+/* 247 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.isValidJSValue = isValidJSValue;
+
+	var _iterall = __webpack_require__(210);
+
+	var _invariant = __webpack_require__(200);
+
+	var _invariant2 = _interopRequireDefault(_invariant);
+
+	var _isNullish = __webpack_require__(204);
+
+	var _isNullish2 = _interopRequireDefault(_isNullish);
+
+	var _definition = __webpack_require__(203);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 * Given a JavaScript value and a GraphQL type, determine if the value will be
+	 * accepted for that type. This is primarily useful for validating the
+	 * runtime values of query variables.
+	 */
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function isValidJSValue(value, type) {
+	  // A value must be provided if the type is non-null.
+	  if (type instanceof _definition.GraphQLNonNull) {
+	    if ((0, _isNullish2.default)(value)) {
+	      if (type.ofType.name) {
+	        return ['Expected "' + String(type.ofType.name) + '!", found null.'];
+	      }
+	      return ['Expected non-null value, found null.'];
+	    }
+	    return isValidJSValue(value, type.ofType);
+	  }
+
+	  if ((0, _isNullish2.default)(value)) {
+	    return [];
+	  }
+
+	  // Lists accept a non-list value as a list of one.
+	  if (type instanceof _definition.GraphQLList) {
+	    var _ret = function () {
+	      var itemType = type.ofType;
+	      if ((0, _iterall.isCollection)(value)) {
+	        var _ret2 = function () {
+	          var errors = [];
+	          (0, _iterall.forEach)(value, function (item, index) {
+	            errors.push.apply(errors, isValidJSValue(item, itemType).map(function (error) {
+	              return 'In element #' + index + ': ' + error;
+	            }));
+	          });
+	          return {
+	            v: {
+	              v: errors
+	            }
+	          };
+	        }();
+
+	        if (typeof _ret2 === "object") return _ret2.v;
+	      }
+	      return {
+	        v: isValidJSValue(value, itemType)
+	      };
+	    }();
+
+	    if (typeof _ret === "object") return _ret.v;
+	  }
+
+	  // Input objects check each defined field.
+	  if (type instanceof _definition.GraphQLInputObjectType) {
+	    var _ret3 = function () {
+	      if (typeof value !== 'object' || value === null) {
+	        return {
+	          v: ['Expected "' + type.name + '", found not an object.']
+	        };
+	      }
+	      var fields = type.getFields();
+
+	      var errors = [];
+
+	      // Ensure every provided field is defined.
+	      Object.keys(value).forEach(function (providedField) {
+	        if (!fields[providedField]) {
+	          errors.push('In field "' + providedField + '": Unknown field.');
+	        }
+	      });
+
+	      // Ensure every defined field is valid.
+	      Object.keys(fields).forEach(function (fieldName) {
+	        var newErrors = isValidJSValue(value[fieldName], fields[fieldName].type);
+	        errors.push.apply(errors, newErrors.map(function (error) {
+	          return 'In field "' + fieldName + '": ' + error;
+	        }));
+	      });
+
+	      return {
+	        v: errors
+	      };
+	    }();
+
+	    if (typeof _ret3 === "object") return _ret3.v;
+	  }
+
+	  (0, _invariant2.default)(type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType, 'Must be input type');
+
+	  // Scalar/Enum input checks to ensure the type can parse the value to
+	  // a non-null value.
+	  var parseResult = type.parseValue(value);
+	  if ((0, _isNullish2.default)(parseResult)) {
+	    return ['Expected type "' + type.name + '", found ' + JSON.stringify(value) + '.'];
+	  }
+
+	  return [];
+	}
+
+/***/ },
+/* 248 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _schema = __webpack_require__(202);
+
+	Object.defineProperty(exports, 'GraphQLSchema', {
+	  enumerable: true,
+	  get: function get() {
+	    return _schema.GraphQLSchema;
+	  }
+	});
+
+	var _definition = __webpack_require__(203);
+
+	Object.defineProperty(exports, 'isType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _definition.isType;
+	  }
+	});
+	Object.defineProperty(exports, 'isInputType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _definition.isInputType;
+	  }
+	});
+	Object.defineProperty(exports, 'isOutputType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _definition.isOutputType;
+	  }
+	});
+	Object.defineProperty(exports, 'isLeafType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _definition.isLeafType;
+	  }
+	});
+	Object.defineProperty(exports, 'isCompositeType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _definition.isCompositeType;
+	  }
+	});
+	Object.defineProperty(exports, 'isAbstractType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _definition.isAbstractType;
+	  }
+	});
+	Object.defineProperty(exports, 'getNullableType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _definition.getNullableType;
+	  }
+	});
+	Object.defineProperty(exports, 'getNamedType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _definition.getNamedType;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLScalarType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _definition.GraphQLScalarType;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLObjectType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _definition.GraphQLObjectType;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLInterfaceType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _definition.GraphQLInterfaceType;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLUnionType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _definition.GraphQLUnionType;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLEnumType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _definition.GraphQLEnumType;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLInputObjectType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _definition.GraphQLInputObjectType;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLList', {
+	  enumerable: true,
+	  get: function get() {
+	    return _definition.GraphQLList;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLNonNull', {
+	  enumerable: true,
+	  get: function get() {
+	    return _definition.GraphQLNonNull;
+	  }
+	});
+
+	var _directives = __webpack_require__(206);
+
+	Object.defineProperty(exports, 'DirectiveLocation', {
+	  enumerable: true,
+	  get: function get() {
+	    return _directives.DirectiveLocation;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLDirective', {
+	  enumerable: true,
+	  get: function get() {
+	    return _directives.GraphQLDirective;
+	  }
+	});
+	Object.defineProperty(exports, 'specifiedDirectives', {
+	  enumerable: true,
+	  get: function get() {
+	    return _directives.specifiedDirectives;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLIncludeDirective', {
+	  enumerable: true,
+	  get: function get() {
+	    return _directives.GraphQLIncludeDirective;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLSkipDirective', {
+	  enumerable: true,
+	  get: function get() {
+	    return _directives.GraphQLSkipDirective;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLDeprecatedDirective', {
+	  enumerable: true,
+	  get: function get() {
+	    return _directives.GraphQLDeprecatedDirective;
+	  }
+	});
+	Object.defineProperty(exports, 'DEFAULT_DEPRECATION_REASON', {
+	  enumerable: true,
+	  get: function get() {
+	    return _directives.DEFAULT_DEPRECATION_REASON;
+	  }
+	});
+
+	var _scalars = __webpack_require__(207);
+
+	Object.defineProperty(exports, 'GraphQLInt', {
+	  enumerable: true,
+	  get: function get() {
+	    return _scalars.GraphQLInt;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLFloat', {
+	  enumerable: true,
+	  get: function get() {
+	    return _scalars.GraphQLFloat;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLString', {
+	  enumerable: true,
+	  get: function get() {
+	    return _scalars.GraphQLString;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLBoolean', {
+	  enumerable: true,
+	  get: function get() {
+	    return _scalars.GraphQLBoolean;
+	  }
+	});
+	Object.defineProperty(exports, 'GraphQLID', {
+	  enumerable: true,
+	  get: function get() {
+	    return _scalars.GraphQLID;
+	  }
+	});
+
+	var _introspection = __webpack_require__(208);
+
+	Object.defineProperty(exports, 'TypeKind', {
+	  enumerable: true,
+	  get: function get() {
+	    return _introspection.TypeKind;
+	  }
+	});
+	Object.defineProperty(exports, '__Schema', {
+	  enumerable: true,
+	  get: function get() {
+	    return _introspection.__Schema;
+	  }
+	});
+	Object.defineProperty(exports, '__Directive', {
+	  enumerable: true,
+	  get: function get() {
+	    return _introspection.__Directive;
+	  }
+	});
+	Object.defineProperty(exports, '__DirectiveLocation', {
+	  enumerable: true,
+	  get: function get() {
+	    return _introspection.__DirectiveLocation;
+	  }
+	});
+	Object.defineProperty(exports, '__Type', {
+	  enumerable: true,
+	  get: function get() {
+	    return _introspection.__Type;
+	  }
+	});
+	Object.defineProperty(exports, '__Field', {
+	  enumerable: true,
+	  get: function get() {
+	    return _introspection.__Field;
+	  }
+	});
+	Object.defineProperty(exports, '__InputValue', {
+	  enumerable: true,
+	  get: function get() {
+	    return _introspection.__InputValue;
+	  }
+	});
+	Object.defineProperty(exports, '__EnumValue', {
+	  enumerable: true,
+	  get: function get() {
+	    return _introspection.__EnumValue;
+	  }
+	});
+	Object.defineProperty(exports, '__TypeKind', {
+	  enumerable: true,
+	  get: function get() {
+	    return _introspection.__TypeKind;
+	  }
+	});
+	Object.defineProperty(exports, 'SchemaMetaFieldDef', {
+	  enumerable: true,
+	  get: function get() {
+	    return _introspection.SchemaMetaFieldDef;
+	  }
+	});
+	Object.defineProperty(exports, 'TypeMetaFieldDef', {
+	  enumerable: true,
+	  get: function get() {
+	    return _introspection.TypeMetaFieldDef;
+	  }
+	});
+	Object.defineProperty(exports, 'TypeNameMetaFieldDef', {
+	  enumerable: true,
+	  get: function get() {
+	    return _introspection.TypeNameMetaFieldDef;
+	  }
+	});
+
+/***/ },
+/* 249 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _execute = __webpack_require__(244);
+
+	Object.defineProperty(exports, 'execute', {
+	  enumerable: true,
+	  get: function get() {
+	    return _execute.execute;
+	  }
+	});
+
+/***/ },
+/* 250 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _validate = __webpack_require__(201);
+
+	Object.defineProperty(exports, 'validate', {
+	  enumerable: true,
+	  get: function get() {
+	    return _validate.validate;
+	  }
+	});
+
+	var _specifiedRules = __webpack_require__(215);
+
+	Object.defineProperty(exports, 'specifiedRules', {
+	  enumerable: true,
+	  get: function get() {
+	    return _specifiedRules.specifiedRules;
+	  }
+	});
+
+/***/ },
+/* 251 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _introspectionQuery = __webpack_require__(252);
+
+	Object.defineProperty(exports, 'introspectionQuery', {
+	  enumerable: true,
+	  get: function get() {
+	    return _introspectionQuery.introspectionQuery;
+	  }
+	});
+
+	var _getOperationAST = __webpack_require__(253);
+
+	Object.defineProperty(exports, 'getOperationAST', {
+	  enumerable: true,
+	  get: function get() {
+	    return _getOperationAST.getOperationAST;
+	  }
+	});
+
+	var _buildClientSchema = __webpack_require__(254);
+
+	Object.defineProperty(exports, 'buildClientSchema', {
+	  enumerable: true,
+	  get: function get() {
+	    return _buildClientSchema.buildClientSchema;
+	  }
+	});
+
+	var _buildASTSchema = __webpack_require__(256);
+
+	Object.defineProperty(exports, 'buildASTSchema', {
+	  enumerable: true,
+	  get: function get() {
+	    return _buildASTSchema.buildASTSchema;
+	  }
+	});
+	Object.defineProperty(exports, 'buildSchema', {
+	  enumerable: true,
+	  get: function get() {
+	    return _buildASTSchema.buildSchema;
+	  }
+	});
+
+	var _extendSchema = __webpack_require__(257);
+
+	Object.defineProperty(exports, 'extendSchema', {
+	  enumerable: true,
+	  get: function get() {
+	    return _extendSchema.extendSchema;
+	  }
+	});
+
+	var _schemaPrinter = __webpack_require__(258);
+
+	Object.defineProperty(exports, 'printSchema', {
+	  enumerable: true,
+	  get: function get() {
+	    return _schemaPrinter.printSchema;
+	  }
+	});
+	Object.defineProperty(exports, 'printIntrospectionSchema', {
+	  enumerable: true,
+	  get: function get() {
+	    return _schemaPrinter.printIntrospectionSchema;
+	  }
+	});
+
+	var _typeFromAST = __webpack_require__(214);
+
+	Object.defineProperty(exports, 'typeFromAST', {
+	  enumerable: true,
+	  get: function get() {
+	    return _typeFromAST.typeFromAST;
+	  }
+	});
+
+	var _valueFromAST = __webpack_require__(246);
+
+	Object.defineProperty(exports, 'valueFromAST', {
+	  enumerable: true,
+	  get: function get() {
+	    return _valueFromAST.valueFromAST;
+	  }
+	});
+
+	var _astFromValue = __webpack_require__(209);
+
+	Object.defineProperty(exports, 'astFromValue', {
+	  enumerable: true,
+	  get: function get() {
+	    return _astFromValue.astFromValue;
+	  }
+	});
+
+	var _TypeInfo = __webpack_require__(213);
+
+	Object.defineProperty(exports, 'TypeInfo', {
+	  enumerable: true,
+	  get: function get() {
+	    return _TypeInfo.TypeInfo;
+	  }
+	});
+
+	var _isValidJSValue = __webpack_require__(247);
+
+	Object.defineProperty(exports, 'isValidJSValue', {
+	  enumerable: true,
+	  get: function get() {
+	    return _isValidJSValue.isValidJSValue;
+	  }
+	});
+
+	var _isValidLiteralValue = __webpack_require__(237);
+
+	Object.defineProperty(exports, 'isValidLiteralValue', {
+	  enumerable: true,
+	  get: function get() {
+	    return _isValidLiteralValue.isValidLiteralValue;
+	  }
+	});
+
+	var _concatAST = __webpack_require__(259);
+
+	Object.defineProperty(exports, 'concatAST', {
+	  enumerable: true,
+	  get: function get() {
+	    return _concatAST.concatAST;
+	  }
+	});
+
+	var _separateOperations = __webpack_require__(260);
+
+	Object.defineProperty(exports, 'separateOperations', {
+	  enumerable: true,
+	  get: function get() {
+	    return _separateOperations.separateOperations;
+	  }
+	});
+
+	var _typeComparators = __webpack_require__(212);
+
+	Object.defineProperty(exports, 'isEqualType', {
+	  enumerable: true,
+	  get: function get() {
+	    return _typeComparators.isEqualType;
+	  }
+	});
+	Object.defineProperty(exports, 'isTypeSubTypeOf', {
+	  enumerable: true,
+	  get: function get() {
+	    return _typeComparators.isTypeSubTypeOf;
+	  }
+	});
+	Object.defineProperty(exports, 'doTypesOverlap', {
+	  enumerable: true,
+	  get: function get() {
+	    return _typeComparators.doTypesOverlap;
+	  }
+	});
+
+	var _assertValidName = __webpack_require__(205);
+
+	Object.defineProperty(exports, 'assertValidName', {
+	  enumerable: true,
+	  get: function get() {
+	    return _assertValidName.assertValidName;
+	  }
+	});
+
+	var _findBreakingChanges = __webpack_require__(261);
+
+	Object.defineProperty(exports, 'findBreakingChanges', {
+	  enumerable: true,
+	  get: function get() {
+	    return _findBreakingChanges.findBreakingChanges;
+	  }
+	});
+
+/***/ },
+/* 252 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	var introspectionQuery = exports.introspectionQuery = '\n  query IntrospectionQuery {\n    __schema {\n      queryType { name }\n      mutationType { name }\n      subscriptionType { name }\n      types {\n        ...FullType\n      }\n      directives {\n        name\n        description\n        locations\n        args {\n          ...InputValue\n        }\n      }\n    }\n  }\n\n  fragment FullType on __Type {\n    kind\n    name\n    description\n    fields(includeDeprecated: true) {\n      name\n      description\n      args {\n        ...InputValue\n      }\n      type {\n        ...TypeRef\n      }\n      isDeprecated\n      deprecationReason\n    }\n    inputFields {\n      ...InputValue\n    }\n    interfaces {\n      ...TypeRef\n    }\n    enumValues(includeDeprecated: true) {\n      name\n      description\n      isDeprecated\n      deprecationReason\n    }\n    possibleTypes {\n      ...TypeRef\n    }\n  }\n\n  fragment InputValue on __InputValue {\n    name\n    description\n    type { ...TypeRef }\n    defaultValue\n  }\n\n  fragment TypeRef on __Type {\n    kind\n    name\n    ofType {\n      kind\n      name\n      ofType {\n        kind\n        name\n        ofType {\n          kind\n          name\n          ofType {\n            kind\n            name\n            ofType {\n              kind\n              name\n              ofType {\n                kind\n                name\n                ofType {\n                  kind\n                  name\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n';
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+/***/ },
+/* 253 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.getOperationAST = getOperationAST;
+
+	var _kinds = __webpack_require__(196);
+
+	/**
+	 * Returns an operation AST given a document AST and optionally an operation
+	 * name. If a name is not provided, an operation is only returned if only one is
+	 * provided in the document.
+	 */
+	function getOperationAST(documentAST, operationName) {
+	  var operation = null;
+	  for (var i = 0; i < documentAST.definitions.length; i++) {
+	    var definition = documentAST.definitions[i];
+	    if (definition.kind === _kinds.OPERATION_DEFINITION) {
+	      if (!operationName) {
+	        // If no operation name was provided, only return an Operation if there
+	        // is one defined in the document. Upon encountering the second, return
+	        // null.
+	        if (operation) {
+	          return null;
+	        }
+	        operation = definition;
+	      } else if (definition.name && definition.name.value === operationName) {
+	        return definition;
+	      }
+	    }
+	  }
+	  return operation;
+	}
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+/***/ },
+/* 254 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.buildClientSchema = buildClientSchema;
+
+	var _invariant = __webpack_require__(200);
+
+	var _invariant2 = _interopRequireDefault(_invariant);
+
+	var _keyMap = __webpack_require__(238);
+
+	var _keyMap2 = _interopRequireDefault(_keyMap);
+
+	var _keyValMap = __webpack_require__(255);
+
+	var _keyValMap2 = _interopRequireDefault(_keyValMap);
+
+	var _valueFromAST = __webpack_require__(246);
+
+	var _parser = __webpack_require__(188);
+
+	var _schema = __webpack_require__(202);
+
+	var _definition = __webpack_require__(203);
+
+	var _introspection = __webpack_require__(208);
+
+	var _scalars = __webpack_require__(207);
+
+	var _directives = __webpack_require__(206);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 * Build a GraphQLSchema for use by client tools.
+	 *
+	 * Given the result of a client running the introspection query, creates and
+	 * returns a GraphQLSchema instance which can be then used with all graphql-js
+	 * tools, but cannot be used to execute a query, as introspection does not
+	 * represent the "resolver", "parse" or "serialize" functions or any other
+	 * server-internal mechanisms.
+	 */
+	function buildClientSchema(introspection) {
+
+	  // Get the schema from the introspection result.
+	  var schemaIntrospection = introspection.__schema;
+
+	  // Converts the list of types into a keyMap based on the type names.
+	  var typeIntrospectionMap = (0, _keyMap2.default)(schemaIntrospection.types, function (type) {
+	    return type.name;
+	  });
+
+	  // A cache to use to store the actual GraphQLType definition objects by name.
+	  // Initialize to the GraphQL built in scalars. All functions below are inline
+	  // so that this type def cache is within the scope of the closure.
+	  var typeDefCache = {
+	    String: _scalars.GraphQLString,
+	    Int: _scalars.GraphQLInt,
+	    Float: _scalars.GraphQLFloat,
+	    Boolean: _scalars.GraphQLBoolean,
+	    ID: _scalars.GraphQLID,
+	    __Schema: _introspection.__Schema,
+	    __Directive: _introspection.__Directive,
+	    __DirectiveLocation: _introspection.__DirectiveLocation,
+	    __Type: _introspection.__Type,
+	    __Field: _introspection.__Field,
+	    __InputValue: _introspection.__InputValue,
+	    __EnumValue: _introspection.__EnumValue,
+	    __TypeKind: _introspection.__TypeKind
+	  };
+
+	  // Given a type reference in introspection, return the GraphQLType instance.
+	  // preferring cached instances before building new instances.
+	  function getType(typeRef) {
+	    if (typeRef.kind === _introspection.TypeKind.LIST) {
+	      var itemRef = typeRef.ofType;
+	      if (!itemRef) {
+	        throw new Error('Decorated type deeper than introspection query.');
+	      }
+	      return new _definition.GraphQLList(getType(itemRef));
+	    }
+	    if (typeRef.kind === _introspection.TypeKind.NON_NULL) {
+	      var nullableRef = typeRef.ofType;
+	      if (!nullableRef) {
+	        throw new Error('Decorated type deeper than introspection query.');
+	      }
+	      var nullableType = getType(nullableRef);
+	      (0, _invariant2.default)(!(nullableType instanceof _definition.GraphQLNonNull), 'No nesting nonnull.');
+	      return new _definition.GraphQLNonNull(nullableType);
+	    }
+	    return getNamedType(typeRef.name);
+	  }
+
+	  function getNamedType(typeName) {
+	    if (typeDefCache[typeName]) {
+	      return typeDefCache[typeName];
+	    }
+	    var typeIntrospection = typeIntrospectionMap[typeName];
+	    if (!typeIntrospection) {
+	      throw new Error('Invalid or incomplete schema, unknown type: ' + typeName + '. Ensure ' + 'that a full introspection query is used in order to build a ' + 'client schema.');
+	    }
+	    var typeDef = buildType(typeIntrospection);
+	    typeDefCache[typeName] = typeDef;
+	    return typeDef;
+	  }
+
+	  function getInputType(typeRef) {
+	    var type = getType(typeRef);
+	    (0, _invariant2.default)((0, _definition.isInputType)(type), 'Introspection must provide input type for arguments.');
+	    return type;
+	  }
+
+	  function getOutputType(typeRef) {
+	    var type = getType(typeRef);
+	    (0, _invariant2.default)((0, _definition.isOutputType)(type), 'Introspection must provide output type for fields.');
+	    return type;
+	  }
+
+	  function getObjectType(typeRef) {
+	    var type = getType(typeRef);
+	    (0, _invariant2.default)(type instanceof _definition.GraphQLObjectType, 'Introspection must provide object type for possibleTypes.');
+	    return type;
+	  }
+
+	  function getInterfaceType(typeRef) {
+	    var type = getType(typeRef);
+	    (0, _invariant2.default)(type instanceof _definition.GraphQLInterfaceType, 'Introspection must provide interface type for interfaces.');
+	    return type;
+	  }
+
+	  // Given a type's introspection result, construct the correct
+	  // GraphQLType instance.
+	  function buildType(type) {
+	    switch (type.kind) {
+	      case _introspection.TypeKind.SCALAR:
+	        return buildScalarDef(type);
+	      case _introspection.TypeKind.OBJECT:
+	        return buildObjectDef(type);
+	      case _introspection.TypeKind.INTERFACE:
+	        return buildInterfaceDef(type);
+	      case _introspection.TypeKind.UNION:
+	        return buildUnionDef(type);
+	      case _introspection.TypeKind.ENUM:
+	        return buildEnumDef(type);
+	      case _introspection.TypeKind.INPUT_OBJECT:
+	        return buildInputObjectDef(type);
+	      default:
+	        throw new Error('Invalid or incomplete schema, unknown kind: ' + type.kind + '. Ensure ' + 'that a full introspection query is used in order to build a ' + 'client schema.');
+	    }
+	  }
+
+	  function buildScalarDef(scalarIntrospection) {
+	    return new _definition.GraphQLScalarType({
+	      name: scalarIntrospection.name,
+	      description: scalarIntrospection.description,
+	      serialize: function serialize(id) {
+	        return id;
+	      },
+	      // Note: validation calls the parse functions to determine if a
+	      // literal value is correct. Returning null would cause use of custom
+	      // scalars to always fail validation. Returning false causes them to
+	      // always pass validation.
+	      parseValue: function parseValue() {
+	        return false;
+	      },
+	      parseLiteral: function parseLiteral() {
+	        return false;
+	      }
+	    });
+	  }
+
+	  function buildObjectDef(objectIntrospection) {
+	    return new _definition.GraphQLObjectType({
+	      name: objectIntrospection.name,
+	      description: objectIntrospection.description,
+	      interfaces: objectIntrospection.interfaces.map(getInterfaceType),
+	      fields: function fields() {
+	        return buildFieldDefMap(objectIntrospection);
+	      }
+	    });
+	  }
+
+	  function buildInterfaceDef(interfaceIntrospection) {
+	    return new _definition.GraphQLInterfaceType({
+	      name: interfaceIntrospection.name,
+	      description: interfaceIntrospection.description,
+	      fields: function fields() {
+	        return buildFieldDefMap(interfaceIntrospection);
+	      },
+	      resolveType: cannotExecuteClientSchema
+	    });
+	  }
+
+	  function buildUnionDef(unionIntrospection) {
+	    return new _definition.GraphQLUnionType({
+	      name: unionIntrospection.name,
+	      description: unionIntrospection.description,
+	      types: unionIntrospection.possibleTypes.map(getObjectType),
+	      resolveType: cannotExecuteClientSchema
+	    });
+	  }
+
+	  function buildEnumDef(enumIntrospection) {
+	    return new _definition.GraphQLEnumType({
+	      name: enumIntrospection.name,
+	      description: enumIntrospection.description,
+	      values: (0, _keyValMap2.default)(enumIntrospection.enumValues, function (valueIntrospection) {
+	        return valueIntrospection.name;
+	      }, function (valueIntrospection) {
+	        return {
+	          description: valueIntrospection.description,
+	          deprecationReason: valueIntrospection.deprecationReason
+	        };
+	      })
+	    });
+	  }
+
+	  function buildInputObjectDef(inputObjectIntrospection) {
+	    return new _definition.GraphQLInputObjectType({
+	      name: inputObjectIntrospection.name,
+	      description: inputObjectIntrospection.description,
+	      fields: function fields() {
+	        return buildInputValueDefMap(inputObjectIntrospection.inputFields);
+	      }
+	    });
+	  }
+
+	  function buildFieldDefMap(typeIntrospection) {
+	    return (0, _keyValMap2.default)(typeIntrospection.fields, function (fieldIntrospection) {
+	      return fieldIntrospection.name;
+	    }, function (fieldIntrospection) {
+	      return {
+	        description: fieldIntrospection.description,
+	        deprecationReason: fieldIntrospection.deprecationReason,
+	        type: getOutputType(fieldIntrospection.type),
+	        args: buildInputValueDefMap(fieldIntrospection.args)
+	      };
+	    });
+	  }
+
+	  function buildInputValueDefMap(inputValueIntrospections) {
+	    return (0, _keyValMap2.default)(inputValueIntrospections, function (inputValue) {
+	      return inputValue.name;
+	    }, buildInputValue);
+	  }
+
+	  function buildInputValue(inputValueIntrospection) {
+	    var type = getInputType(inputValueIntrospection.type);
+	    var defaultValue = inputValueIntrospection.defaultValue ? (0, _valueFromAST.valueFromAST)((0, _parser.parseValue)(inputValueIntrospection.defaultValue), type) : null;
+	    return {
+	      name: inputValueIntrospection.name,
+	      description: inputValueIntrospection.description,
+	      type: type,
+	      defaultValue: defaultValue
+	    };
+	  }
+
+	  function buildDirective(directiveIntrospection) {
+	    // Support deprecated `on****` fields for building `locations`, as this
+	    // is used by GraphiQL which may need to support outdated servers.
+	    var locations = directiveIntrospection.locations ? directiveIntrospection.locations.slice() : [].concat(!directiveIntrospection.onField ? [] : [_directives.DirectiveLocation.FIELD], !directiveIntrospection.onOperation ? [] : [_directives.DirectiveLocation.QUERY, _directives.DirectiveLocation.MUTATION, _directives.DirectiveLocation.SUBSCRIPTION], !directiveIntrospection.onFragment ? [] : [_directives.DirectiveLocation.FRAGMENT_DEFINITION, _directives.DirectiveLocation.FRAGMENT_SPREAD, _directives.DirectiveLocation.INLINE_FRAGMENT]);
+	    return new _directives.GraphQLDirective({
+	      name: directiveIntrospection.name,
+	      description: directiveIntrospection.description,
+	      locations: locations,
+	      args: buildInputValueDefMap(directiveIntrospection.args)
+	    });
+	  }
+
+	  // Iterate through all types, getting the type definition for each, ensuring
+	  // that any type not directly referenced by a field will get created.
+	  var types = schemaIntrospection.types.map(function (typeIntrospection) {
+	    return getNamedType(typeIntrospection.name);
+	  });
+
+	  // Get the root Query, Mutation, and Subscription types.
+	  var queryType = getObjectType(schemaIntrospection.queryType);
+
+	  var mutationType = schemaIntrospection.mutationType ? getObjectType(schemaIntrospection.mutationType) : null;
+
+	  var subscriptionType = schemaIntrospection.subscriptionType ? getObjectType(schemaIntrospection.subscriptionType) : null;
+
+	  // Get the directives supported by Introspection, assuming empty-set if
+	  // directives were not queried for.
+	  var directives = schemaIntrospection.directives ? schemaIntrospection.directives.map(buildDirective) : [];
+
+	  // Then produce and return a Schema with these types.
+	  return new _schema.GraphQLSchema({
+	    query: queryType,
+	    mutation: mutationType,
+	    subscription: subscriptionType,
+	    types: types,
+	    directives: directives
+	  });
+	}
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function cannotExecuteClientSchema() {
+	  throw new Error('Client Schema cannot use Interface or Union types for execution.');
+	}
+
+/***/ },
+/* 255 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = keyValMap;
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	/**
+	 * Creates a keyed JS object from an array, given a function to produce the keys
+	 * and a function to produce the values from each item in the array.
+	 *
+	 *     const phoneBook = [
+	 *       { name: 'Jon', num: '555-1234' },
+	 *       { name: 'Jenny', num: '867-5309' }
+	 *     ]
+	 *
+	 *     // { Jon: '555-1234', Jenny: '867-5309' }
+	 *     const phonesByName = keyValMap(
+	 *       phoneBook,
+	 *       entry => entry.name,
+	 *       entry => entry.num
+	 *     )
+	 *
+	 */
+	function keyValMap(list, keyFn, valFn) {
+	  return list.reduce(function (map, item) {
+	    return map[keyFn(item)] = valFn(item), map;
+	  }, {});
+	}
+
+/***/ },
+/* 256 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.buildASTSchema = buildASTSchema;
+	exports.getDescription = getDescription;
+	exports.buildSchema = buildSchema;
+
+	var _find = __webpack_require__(211);
+
+	var _find2 = _interopRequireDefault(_find);
+
+	var _invariant = __webpack_require__(200);
+
+	var _invariant2 = _interopRequireDefault(_invariant);
+
+	var _keyValMap = __webpack_require__(255);
+
+	var _keyValMap2 = _interopRequireDefault(_keyValMap);
+
+	var _valueFromAST = __webpack_require__(246);
+
+	var _lexer = __webpack_require__(193);
+
+	var _parser = __webpack_require__(188);
+
+	var _values = __webpack_require__(245);
+
+	var _kinds = __webpack_require__(196);
+
+	var _schema = __webpack_require__(202);
+
+	var _scalars = __webpack_require__(207);
+
+	var _definition = __webpack_require__(203);
+
+	var _directives = __webpack_require__(206);
+
+	var _introspection = __webpack_require__(208);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function buildWrappedType(innerType, inputTypeAST) {
+	  if (inputTypeAST.kind === _kinds.LIST_TYPE) {
+	    return new _definition.GraphQLList(buildWrappedType(innerType, inputTypeAST.type));
+	  }
+	  if (inputTypeAST.kind === _kinds.NON_NULL_TYPE) {
+	    var wrappedType = buildWrappedType(innerType, inputTypeAST.type);
+	    (0, _invariant2.default)(!(wrappedType instanceof _definition.GraphQLNonNull), 'No nesting nonnull.');
+	    return new _definition.GraphQLNonNull(wrappedType);
+	  }
+	  return innerType;
+	}
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function getNamedTypeAST(typeAST) {
+	  var namedType = typeAST;
+	  while (namedType.kind === _kinds.LIST_TYPE || namedType.kind === _kinds.NON_NULL_TYPE) {
+	    namedType = namedType.type;
+	  }
+	  return namedType;
+	}
+
+	/**
+	 * This takes the ast of a schema document produced by the parse function in
+	 * src/language/parser.js.
+	 *
+	 * If no schema definition is provided, then it will look for types named Query
+	 * and Mutation.
+	 *
+	 * Given that AST it constructs a GraphQLSchema. The resulting schema
+	 * has no resolve methods, so execution will use default resolvers.
+	 */
+	function buildASTSchema(ast) {
+	  if (!ast || ast.kind !== _kinds.DOCUMENT) {
+	    throw new Error('Must provide a document ast.');
+	  }
+
+	  var schemaDef = void 0;
+
+	  var typeDefs = [];
+	  var astMap = Object.create(null);
+	  var directiveDefs = [];
+	  for (var i = 0; i < ast.definitions.length; i++) {
+	    var d = ast.definitions[i];
+	    switch (d.kind) {
+	      case _kinds.SCHEMA_DEFINITION:
+	        if (schemaDef) {
+	          throw new Error('Must provide only one schema definition.');
+	        }
+	        schemaDef = d;
+	        break;
+	      case _kinds.SCALAR_TYPE_DEFINITION:
+	      case _kinds.OBJECT_TYPE_DEFINITION:
+	      case _kinds.INTERFACE_TYPE_DEFINITION:
+	      case _kinds.ENUM_TYPE_DEFINITION:
+	      case _kinds.UNION_TYPE_DEFINITION:
+	      case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
+	        typeDefs.push(d);
+	        astMap[d.name.value] = d;
+	        break;
+	      case _kinds.DIRECTIVE_DEFINITION:
+	        directiveDefs.push(d);
+	        break;
+	    }
+	  }
+
+	  var queryTypeName = void 0;
+	  var mutationTypeName = void 0;
+	  var subscriptionTypeName = void 0;
+	  if (schemaDef) {
+	    schemaDef.operationTypes.forEach(function (operationType) {
+	      var typeName = operationType.type.name.value;
+	      if (operationType.operation === 'query') {
+	        if (queryTypeName) {
+	          throw new Error('Must provide only one query type in schema.');
+	        }
+	        if (!astMap[typeName]) {
+	          throw new Error('Specified query type "' + typeName + '" not found in document.');
+	        }
+	        queryTypeName = typeName;
+	      } else if (operationType.operation === 'mutation') {
+	        if (mutationTypeName) {
+	          throw new Error('Must provide only one mutation type in schema.');
+	        }
+	        if (!astMap[typeName]) {
+	          throw new Error('Specified mutation type "' + typeName + '" not found in document.');
+	        }
+	        mutationTypeName = typeName;
+	      } else if (operationType.operation === 'subscription') {
+	        if (subscriptionTypeName) {
+	          throw new Error('Must provide only one subscription type in schema.');
+	        }
+	        if (!astMap[typeName]) {
+	          throw new Error('Specified subscription type "' + typeName + '" not found in document.');
+	        }
+	        subscriptionTypeName = typeName;
+	      }
+	    });
+	  } else {
+	    if (astMap.Query) {
+	      queryTypeName = 'Query';
+	    }
+	    if (astMap.Mutation) {
+	      mutationTypeName = 'Mutation';
+	    }
+	    if (astMap.Subscription) {
+	      subscriptionTypeName = 'Subscription';
+	    }
+	  }
+
+	  if (!queryTypeName) {
+	    throw new Error('Must provide schema definition with query type or a type named Query.');
+	  }
+
+	  var innerTypeMap = {
+	    String: _scalars.GraphQLString,
+	    Int: _scalars.GraphQLInt,
+	    Float: _scalars.GraphQLFloat,
+	    Boolean: _scalars.GraphQLBoolean,
+	    ID: _scalars.GraphQLID,
+	    __Schema: _introspection.__Schema,
+	    __Directive: _introspection.__Directive,
+	    __DirectiveLocation: _introspection.__DirectiveLocation,
+	    __Type: _introspection.__Type,
+	    __Field: _introspection.__Field,
+	    __InputValue: _introspection.__InputValue,
+	    __EnumValue: _introspection.__EnumValue,
+	    __TypeKind: _introspection.__TypeKind
+	  };
+
+	  var types = typeDefs.map(function (def) {
+	    return typeDefNamed(def.name.value);
+	  });
+
+	  var directives = directiveDefs.map(getDirective);
+
+	  // If specified directives were not explicitly declared, add them.
+	  if (!directives.some(function (directive) {
+	    return directive.name === 'skip';
+	  })) {
+	    directives.push(_directives.GraphQLSkipDirective);
+	  }
+
+	  if (!directives.some(function (directive) {
+	    return directive.name === 'include';
+	  })) {
+	    directives.push(_directives.GraphQLIncludeDirective);
+	  }
+
+	  if (!directives.some(function (directive) {
+	    return directive.name === 'deprecated';
+	  })) {
+	    directives.push(_directives.GraphQLDeprecatedDirective);
+	  }
+
+	  return new _schema.GraphQLSchema({
+	    query: getObjectType(astMap[queryTypeName]),
+	    mutation: mutationTypeName ? getObjectType(astMap[mutationTypeName]) : null,
+	    subscription: subscriptionTypeName ? getObjectType(astMap[subscriptionTypeName]) : null,
+	    types: types,
+	    directives: directives
+	  });
+
+	  function getDirective(directiveAST) {
+	    return new _directives.GraphQLDirective({
+	      name: directiveAST.name.value,
+	      description: getDescription(directiveAST),
+	      locations: directiveAST.locations.map(function (node) {
+	        return node.value;
+	      }),
+	      args: directiveAST.arguments && makeInputValues(directiveAST.arguments)
+	    });
+	  }
+
+	  function getObjectType(typeAST) {
+	    var type = typeDefNamed(typeAST.name.value);
+	    (0, _invariant2.default)(type instanceof _definition.GraphQLObjectType, 'AST must provide object type.');
+	    return type;
+	  }
+
+	  function produceType(typeAST) {
+	    var typeName = getNamedTypeAST(typeAST).name.value;
+	    var typeDef = typeDefNamed(typeName);
+	    return buildWrappedType(typeDef, typeAST);
+	  }
+
+	  function produceInputType(typeAST) {
+	    var type = produceType(typeAST);
+	    (0, _invariant2.default)((0, _definition.isInputType)(type), 'Expected Input type.');
+	    return type;
+	  }
+
+	  function produceOutputType(typeAST) {
+	    var type = produceType(typeAST);
+	    (0, _invariant2.default)((0, _definition.isOutputType)(type), 'Expected Output type.');
+	    return type;
+	  }
+
+	  function produceObjectType(typeAST) {
+	    var type = produceType(typeAST);
+	    (0, _invariant2.default)(type instanceof _definition.GraphQLObjectType, 'Expected Object type.');
+	    return type;
+	  }
+
+	  function produceInterfaceType(typeAST) {
+	    var type = produceType(typeAST);
+	    (0, _invariant2.default)(type instanceof _definition.GraphQLInterfaceType, 'Expected Object type.');
+	    return type;
+	  }
+
+	  function typeDefNamed(typeName) {
+	    if (innerTypeMap[typeName]) {
+	      return innerTypeMap[typeName];
+	    }
+
+	    if (!astMap[typeName]) {
+	      throw new Error('Type "' + typeName + '" not found in document.');
+	    }
+
+	    var innerTypeDef = makeSchemaDef(astMap[typeName]);
+	    if (!innerTypeDef) {
+	      throw new Error('Nothing constructed for "' + typeName + '".');
+	    }
+	    innerTypeMap[typeName] = innerTypeDef;
+	    return innerTypeDef;
+	  }
+
+	  function makeSchemaDef(def) {
+	    if (!def) {
+	      throw new Error('def must be defined');
+	    }
+	    switch (def.kind) {
+	      case _kinds.OBJECT_TYPE_DEFINITION:
+	        return makeTypeDef(def);
+	      case _kinds.INTERFACE_TYPE_DEFINITION:
+	        return makeInterfaceDef(def);
+	      case _kinds.ENUM_TYPE_DEFINITION:
+	        return makeEnumDef(def);
+	      case _kinds.UNION_TYPE_DEFINITION:
+	        return makeUnionDef(def);
+	      case _kinds.SCALAR_TYPE_DEFINITION:
+	        return makeScalarDef(def);
+	      case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
+	        return makeInputObjectDef(def);
+	      default:
+	        throw new Error('Type kind "' + def.kind + '" not supported.');
+	    }
+	  }
+
+	  function makeTypeDef(def) {
+	    var typeName = def.name.value;
+	    return new _definition.GraphQLObjectType({
+	      name: typeName,
+	      description: getDescription(def),
+	      fields: function fields() {
+	        return makeFieldDefMap(def);
+	      },
+	      interfaces: function interfaces() {
+	        return makeImplementedInterfaces(def);
+	      }
+	    });
+	  }
+
+	  function makeFieldDefMap(def) {
+	    return (0, _keyValMap2.default)(def.fields, function (field) {
+	      return field.name.value;
+	    }, function (field) {
+	      return {
+	        type: produceOutputType(field.type),
+	        description: getDescription(field),
+	        args: makeInputValues(field.arguments),
+	        deprecationReason: getDeprecationReason(field.directives)
+	      };
+	    });
+	  }
+
+	  function makeImplementedInterfaces(def) {
+	    return def.interfaces && def.interfaces.map(function (iface) {
+	      return produceInterfaceType(iface);
+	    });
+	  }
+
+	  function makeInputValues(values) {
+	    return (0, _keyValMap2.default)(values, function (value) {
+	      return value.name.value;
+	    }, function (value) {
+	      var type = produceInputType(value.type);
+	      return {
+	        type: type,
+	        description: getDescription(value),
+	        defaultValue: (0, _valueFromAST.valueFromAST)(value.defaultValue, type)
+	      };
+	    });
+	  }
+
+	  function makeInterfaceDef(def) {
+	    var typeName = def.name.value;
+	    return new _definition.GraphQLInterfaceType({
+	      name: typeName,
+	      description: getDescription(def),
+	      fields: function fields() {
+	        return makeFieldDefMap(def);
+	      },
+	      resolveType: cannotExecuteSchema
+	    });
+	  }
+
+	  function makeEnumDef(def) {
+	    var enumType = new _definition.GraphQLEnumType({
+	      name: def.name.value,
+	      description: getDescription(def),
+	      values: (0, _keyValMap2.default)(def.values, function (enumValue) {
+	        return enumValue.name.value;
+	      }, function (enumValue) {
+	        return {
+	          description: getDescription(enumValue),
+	          deprecationReason: getDeprecationReason(enumValue.directives)
+	        };
+	      })
+	    });
+
+	    return enumType;
+	  }
+
+	  function makeUnionDef(def) {
+	    return new _definition.GraphQLUnionType({
+	      name: def.name.value,
+	      description: getDescription(def),
+	      types: def.types.map(function (t) {
+	        return produceObjectType(t);
+	      }),
+	      resolveType: cannotExecuteSchema
+	    });
+	  }
+
+	  function makeScalarDef(def) {
+	    return new _definition.GraphQLScalarType({
+	      name: def.name.value,
+	      description: getDescription(def),
+	      serialize: function serialize() {
+	        return null;
+	      },
+	      // Note: validation calls the parse functions to determine if a
+	      // literal value is correct. Returning null would cause use of custom
+	      // scalars to always fail validation. Returning false causes them to
+	      // always pass validation.
+	      parseValue: function parseValue() {
+	        return false;
+	      },
+	      parseLiteral: function parseLiteral() {
+	        return false;
+	      }
+	    });
+	  }
+
+	  function makeInputObjectDef(def) {
+	    return new _definition.GraphQLInputObjectType({
+	      name: def.name.value,
+	      description: getDescription(def),
+	      fields: function fields() {
+	        return makeInputValues(def.fields);
+	      }
+	    });
+	  }
+	}
+
+	function getDeprecationReason(directives) {
+	  var deprecatedAST = directives && (0, _find2.default)(directives, function (directive) {
+	    return directive.name.value === _directives.GraphQLDeprecatedDirective.name;
+	  });
+	  if (!deprecatedAST) {
+	    return;
+	  }
+
+	  var _getArgumentValues = (0, _values.getArgumentValues)(_directives.GraphQLDeprecatedDirective.args, deprecatedAST.arguments);
+
+	  var reason = _getArgumentValues.reason;
+
+	  return reason;
+	}
+
+	/**
+	 * Given an ast node, returns its string description based on a contiguous
+	 * block full-line of comments preceding it.
+	 */
+	function getDescription(node) {
+	  var loc = node.loc;
+	  if (!loc) {
+	    return;
+	  }
+	  var comments = [];
+	  var minSpaces = void 0;
+	  var token = loc.startToken.prev;
+	  while (token && token.kind === _lexer.TokenKind.COMMENT && token.next && token.prev && token.line + 1 === token.next.line && token.line !== token.prev.line) {
+	    var value = String(token.value);
+	    var spaces = leadingSpaces(value);
+	    if (minSpaces === undefined || spaces < minSpaces) {
+	      minSpaces = spaces;
+	    }
+	    comments.push(value);
+	    token = token.prev;
+	  }
+	  return comments.reverse().map(function (comment) {
+	    return comment.slice(minSpaces);
+	  }).join('\n');
+	}
+
+	/**
+	 * A helper function to build a GraphQLSchema directly from a source
+	 * document.
+	 */
+	function buildSchema(source) {
+	  return buildASTSchema((0, _parser.parse)(source));
+	}
+
+	// Count the number of spaces on the starting side of a string.
+	function leadingSpaces(str) {
+	  var i = 0;
+	  for (; i < str.length; i++) {
+	    if (str[i] !== ' ') {
+	      break;
+	    }
+	  }
+	  return i;
+	}
+
+	function cannotExecuteSchema() {
+	  throw new Error('Generated Schema cannot use Interface or Union types for execution.');
+	}
+
+/***/ },
+/* 257 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.extendSchema = extendSchema;
+
+	var _invariant = __webpack_require__(200);
+
+	var _invariant2 = _interopRequireDefault(_invariant);
+
+	var _keyMap = __webpack_require__(238);
+
+	var _keyMap2 = _interopRequireDefault(_keyMap);
+
+	var _keyValMap = __webpack_require__(255);
+
+	var _keyValMap2 = _interopRequireDefault(_keyValMap);
+
+	var _buildASTSchema = __webpack_require__(256);
+
+	var _valueFromAST = __webpack_require__(246);
+
+	var _GraphQLError = __webpack_require__(190);
+
+	var _schema = __webpack_require__(202);
+
+	var _definition = __webpack_require__(203);
+
+	var _directives = __webpack_require__(206);
+
+	var _introspection = __webpack_require__(208);
+
+	var _scalars = __webpack_require__(207);
+
+	var _kinds = __webpack_require__(196);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 * Produces a new schema given an existing schema and a document which may
+	 * contain GraphQL type extensions and definitions. The original schema will
+	 * remain unaltered.
+	 *
+	 * Because a schema represents a graph of references, a schema cannot be
+	 * extended without effectively making an entire copy. We do not know until it's
+	 * too late if subgraphs remain unchanged.
+	 *
+	 * This algorithm copies the provided schema, applying extensions while
+	 * producing the copy. The original schema remains unaltered.
+	 */
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function extendSchema(schema, documentAST) {
+	  (0, _invariant2.default)(schema instanceof _schema.GraphQLSchema, 'Must provide valid GraphQLSchema');
+
+	  (0, _invariant2.default)(documentAST && documentAST.kind === _kinds.DOCUMENT, 'Must provide valid Document AST');
+
+	  // Collect the type definitions and extensions found in the document.
+	  var typeDefinitionMap = {};
+	  var typeExtensionsMap = {};
+
+	  // New directives and types are separate because a directives and types can
+	  // have the same name. For example, a type named "skip".
+	  var directiveDefinitions = [];
+
+	  for (var i = 0; i < documentAST.definitions.length; i++) {
+	    var def = documentAST.definitions[i];
+	    switch (def.kind) {
+	      case _kinds.OBJECT_TYPE_DEFINITION:
+	      case _kinds.INTERFACE_TYPE_DEFINITION:
+	      case _kinds.ENUM_TYPE_DEFINITION:
+	      case _kinds.UNION_TYPE_DEFINITION:
+	      case _kinds.SCALAR_TYPE_DEFINITION:
+	      case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
+	        // Sanity check that none of the defined types conflict with the
+	        // schema's existing types.
+	        var typeName = def.name.value;
+	        if (schema.getType(typeName)) {
+	          throw new _GraphQLError.GraphQLError('Type "' + typeName + '" already exists in the schema. It cannot also ' + 'be defined in this type definition.', [def]);
+	        }
+	        typeDefinitionMap[typeName] = def;
+	        break;
+	      case _kinds.TYPE_EXTENSION_DEFINITION:
+	        // Sanity check that this type extension exists within the
+	        // schema's existing types.
+	        var extendedTypeName = def.definition.name.value;
+	        var existingType = schema.getType(extendedTypeName);
+	        if (!existingType) {
+	          throw new _GraphQLError.GraphQLError('Cannot extend type "' + extendedTypeName + '" because it does not ' + 'exist in the existing schema.', [def.definition]);
+	        }
+	        if (!(existingType instanceof _definition.GraphQLObjectType)) {
+	          throw new _GraphQLError.GraphQLError('Cannot extend non-object type "' + extendedTypeName + '".', [def.definition]);
+	        }
+	        var extensions = typeExtensionsMap[extendedTypeName];
+	        if (extensions) {
+	          extensions.push(def);
+	        } else {
+	          extensions = [def];
+	        }
+	        typeExtensionsMap[extendedTypeName] = extensions;
+	        break;
+	      case _kinds.DIRECTIVE_DEFINITION:
+	        var directiveName = def.name.value;
+	        var existingDirective = schema.getDirective(directiveName);
+	        if (existingDirective) {
+	          throw new _GraphQLError.GraphQLError('Directive "' + directiveName + '" already exists in the schema. It ' + 'cannot be redefined.', [def]);
+	        }
+	        directiveDefinitions.push(def);
+	        break;
+	    }
+	  }
+
+	  // If this document contains no new types, extensions, or directives then
+	  // return the same unmodified GraphQLSchema instance.
+	  if (Object.keys(typeExtensionsMap).length === 0 && Object.keys(typeDefinitionMap).length === 0 && directiveDefinitions.length === 0) {
+	    return schema;
+	  }
+
+	  // A cache to use to store the actual GraphQLType definition objects by name.
+	  // Initialize to the GraphQL built in scalars and introspection types. All
+	  // functions below are inline so that this type def cache is within the scope
+	  // of the closure.
+	  var typeDefCache = {
+	    String: _scalars.GraphQLString,
+	    Int: _scalars.GraphQLInt,
+	    Float: _scalars.GraphQLFloat,
+	    Boolean: _scalars.GraphQLBoolean,
+	    ID: _scalars.GraphQLID,
+	    __Schema: _introspection.__Schema,
+	    __Directive: _introspection.__Directive,
+	    __DirectiveLocation: _introspection.__DirectiveLocation,
+	    __Type: _introspection.__Type,
+	    __Field: _introspection.__Field,
+	    __InputValue: _introspection.__InputValue,
+	    __EnumValue: _introspection.__EnumValue,
+	    __TypeKind: _introspection.__TypeKind
+	  };
+
+	  // Get the root Query, Mutation, and Subscription object types.
+	  var queryType = getTypeFromDef(schema.getQueryType());
+
+	  var existingMutationType = schema.getMutationType();
+	  var mutationType = existingMutationType ? getTypeFromDef(existingMutationType) : null;
+
+	  var existingSubscriptionType = schema.getSubscriptionType();
+	  var subscriptionType = existingSubscriptionType ? getTypeFromDef(existingSubscriptionType) : null;
+
+	  // Iterate through all types, getting the type definition for each, ensuring
+	  // that any type not directly referenced by a field will get created.
+	  var typeMap = schema.getTypeMap();
+	  var types = Object.keys(typeMap).map(function (typeName) {
+	    return getTypeFromDef(typeMap[typeName]);
+	  });
+
+	  // Do the same with new types, appending to the list of defined types.
+	  Object.keys(typeDefinitionMap).forEach(function (typeName) {
+	    types.push(getTypeFromAST(typeDefinitionMap[typeName]));
+	  });
+
+	  // Then produce and return a Schema with these types.
+	  return new _schema.GraphQLSchema({
+	    query: queryType,
+	    mutation: mutationType,
+	    subscription: subscriptionType,
+	    types: types,
+	    directives: getMergedDirectives()
+	  });
+
+	  // Below are functions used for producing this schema that have closed over
+	  // this scope and have access to the schema, cache, and newly defined types.
+
+	  function getMergedDirectives() {
+	    var existingDirectives = schema.getDirectives();
+	    (0, _invariant2.default)(existingDirectives, 'schema must have default directives');
+
+	    var newDirectives = directiveDefinitions.map(function (directiveAST) {
+	      return getDirective(directiveAST);
+	    });
+	    return existingDirectives.concat(newDirectives);
+	  }
+
+	  function getTypeFromDef(typeDef) {
+	    var type = _getNamedType(typeDef.name);
+	    (0, _invariant2.default)(type, 'Missing type from schema');
+	    return type;
+	  }
+
+	  function getTypeFromAST(astNode) {
+	    var type = _getNamedType(astNode.name.value);
+	    if (!type) {
+	      throw new _GraphQLError.GraphQLError('Unknown type: "' + astNode.name.value + '". Ensure that this type exists ' + 'either in the original schema, or is added in a type definition.', [astNode]);
+	    }
+	    return type;
+	  }
+
+	  function getObjectTypeFromAST(astNode) {
+	    var type = getTypeFromAST(astNode);
+	    (0, _invariant2.default)(type instanceof _definition.GraphQLObjectType, 'Must be Object type.');
+	    return type;
+	  }
+
+	  function getInterfaceTypeFromAST(astNode) {
+	    var type = getTypeFromAST(astNode);
+	    (0, _invariant2.default)(type instanceof _definition.GraphQLInterfaceType, 'Must be Interface type.');
+	    return type;
+	  }
+
+	  function getInputTypeFromAST(astNode) {
+	    var type = getTypeFromAST(astNode);
+	    (0, _invariant2.default)((0, _definition.isInputType)(type), 'Must be Input type.');
+	    return type;
+	  }
+
+	  function getOutputTypeFromAST(astNode) {
+	    var type = getTypeFromAST(astNode);
+	    (0, _invariant2.default)((0, _definition.isOutputType)(type), 'Must be Output type.');
+	    return type;
+	  }
+
+	  // Given a name, returns a type from either the existing schema or an
+	  // added type.
+	  function _getNamedType(typeName) {
+	    var cachedTypeDef = typeDefCache[typeName];
+	    if (cachedTypeDef) {
+	      return cachedTypeDef;
+	    }
+
+	    var existingType = schema.getType(typeName);
+	    if (existingType) {
+	      var typeDef = extendType(existingType);
+	      typeDefCache[typeName] = typeDef;
+	      return typeDef;
+	    }
+
+	    var typeAST = typeDefinitionMap[typeName];
+	    if (typeAST) {
+	      var _typeDef = buildType(typeAST);
+	      typeDefCache[typeName] = _typeDef;
+	      return _typeDef;
+	    }
+	  }
+
+	  // Given a type's introspection result, construct the correct
+	  // GraphQLType instance.
+	  function extendType(type) {
+	    if (type instanceof _definition.GraphQLObjectType) {
+	      return extendObjectType(type);
+	    }
+	    if (type instanceof _definition.GraphQLInterfaceType) {
+	      return extendInterfaceType(type);
+	    }
+	    if (type instanceof _definition.GraphQLUnionType) {
+	      return extendUnionType(type);
+	    }
+	    return type;
+	  }
+
+	  function extendObjectType(type) {
+	    return new _definition.GraphQLObjectType({
+	      name: type.name,
+	      description: type.description,
+	      interfaces: function interfaces() {
+	        return extendImplementedInterfaces(type);
+	      },
+	      fields: function fields() {
+	        return extendFieldMap(type);
+	      },
+	      isTypeOf: type.isTypeOf
+	    });
+	  }
+
+	  function extendInterfaceType(type) {
+	    return new _definition.GraphQLInterfaceType({
+	      name: type.name,
+	      description: type.description,
+	      fields: function fields() {
+	        return extendFieldMap(type);
+	      },
+	      resolveType: type.resolveType
+	    });
+	  }
+
+	  function extendUnionType(type) {
+	    return new _definition.GraphQLUnionType({
+	      name: type.name,
+	      description: type.description,
+	      types: type.getTypes().map(getTypeFromDef),
+	      resolveType: type.resolveType
+	    });
+	  }
+
+	  function extendImplementedInterfaces(type) {
+	    var interfaces = type.getInterfaces().map(getTypeFromDef);
+
+	    // If there are any extensions to the interfaces, apply those here.
+	    var extensions = typeExtensionsMap[type.name];
+	    if (extensions) {
+	      extensions.forEach(function (extension) {
+	        extension.definition.interfaces.forEach(function (namedType) {
+	          var interfaceName = namedType.name.value;
+	          if (interfaces.some(function (def) {
+	            return def.name === interfaceName;
+	          })) {
+	            throw new _GraphQLError.GraphQLError('Type "' + type.name + '" already implements "' + interfaceName + '". ' + 'It cannot also be implemented in this type extension.', [namedType]);
+	          }
+	          interfaces.push(getInterfaceTypeFromAST(namedType));
+	        });
+	      });
+	    }
+
+	    return interfaces;
+	  }
+
+	  function extendFieldMap(type) {
+	    var newFieldMap = {};
+	    var oldFieldMap = type.getFields();
+	    Object.keys(oldFieldMap).forEach(function (fieldName) {
+	      var field = oldFieldMap[fieldName];
+	      newFieldMap[fieldName] = {
+	        description: field.description,
+	        deprecationReason: field.deprecationReason,
+	        type: extendFieldType(field.type),
+	        args: (0, _keyMap2.default)(field.args, function (arg) {
+	          return arg.name;
+	        }),
+	        resolve: field.resolve
+	      };
+	    });
+
+	    // If there are any extensions to the fields, apply those here.
+	    var extensions = typeExtensionsMap[type.name];
+	    if (extensions) {
+	      extensions.forEach(function (extension) {
+	        extension.definition.fields.forEach(function (field) {
+	          var fieldName = field.name.value;
+	          if (oldFieldMap[fieldName]) {
+	            throw new _GraphQLError.GraphQLError('Field "' + type.name + '.' + fieldName + '" already exists in the ' + 'schema. It cannot also be defined in this type extension.', [field]);
+	          }
+	          newFieldMap[fieldName] = {
+	            description: (0, _buildASTSchema.getDescription)(field),
+	            type: buildOutputFieldType(field.type),
+	            args: buildInputValues(field.arguments)
+	          };
+	        });
+	      });
+	    }
+
+	    return newFieldMap;
+	  }
+
+	  function extendFieldType(typeDef) {
+	    if (typeDef instanceof _definition.GraphQLList) {
+	      return new _definition.GraphQLList(extendFieldType(typeDef.ofType));
+	    }
+	    if (typeDef instanceof _definition.GraphQLNonNull) {
+	      return new _definition.GraphQLNonNull(extendFieldType(typeDef.ofType));
+	    }
+	    return getTypeFromDef(typeDef);
+	  }
+
+	  function buildType(typeAST) {
+	    switch (typeAST.kind) {
+	      case _kinds.OBJECT_TYPE_DEFINITION:
+	        return buildObjectType(typeAST);
+	      case _kinds.INTERFACE_TYPE_DEFINITION:
+	        return buildInterfaceType(typeAST);
+	      case _kinds.UNION_TYPE_DEFINITION:
+	        return buildUnionType(typeAST);
+	      case _kinds.SCALAR_TYPE_DEFINITION:
+	        return buildScalarType(typeAST);
+	      case _kinds.ENUM_TYPE_DEFINITION:
+	        return buildEnumType(typeAST);
+	      case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
+	        return buildInputObjectType(typeAST);
+	    }
+	    throw new TypeError('Unknown type kind ' + typeAST.kind);
+	  }
+
+	  function buildObjectType(typeAST) {
+	    return new _definition.GraphQLObjectType({
+	      name: typeAST.name.value,
+	      description: (0, _buildASTSchema.getDescription)(typeAST),
+	      interfaces: function interfaces() {
+	        return buildImplementedInterfaces(typeAST);
+	      },
+	      fields: function fields() {
+	        return buildFieldMap(typeAST);
+	      }
+	    });
+	  }
+
+	  function buildInterfaceType(typeAST) {
+	    return new _definition.GraphQLInterfaceType({
+	      name: typeAST.name.value,
+	      description: (0, _buildASTSchema.getDescription)(typeAST),
+	      fields: function fields() {
+	        return buildFieldMap(typeAST);
+	      },
+	      resolveType: cannotExecuteExtendedSchema
+	    });
+	  }
+
+	  function buildUnionType(typeAST) {
+	    return new _definition.GraphQLUnionType({
+	      name: typeAST.name.value,
+	      description: (0, _buildASTSchema.getDescription)(typeAST),
+	      types: typeAST.types.map(getObjectTypeFromAST),
+	      resolveType: cannotExecuteExtendedSchema
+	    });
+	  }
+
+	  function buildScalarType(typeAST) {
+	    return new _definition.GraphQLScalarType({
+	      name: typeAST.name.value,
+	      description: (0, _buildASTSchema.getDescription)(typeAST),
+	      serialize: function serialize(id) {
+	        return id;
+	      },
+	      // Note: validation calls the parse functions to determine if a
+	      // literal value is correct. Returning null would cause use of custom
+	      // scalars to always fail validation. Returning false causes them to
+	      // always pass validation.
+	      parseValue: function parseValue() {
+	        return false;
+	      },
+	      parseLiteral: function parseLiteral() {
+	        return false;
+	      }
+	    });
+	  }
+
+	  function buildEnumType(typeAST) {
+	    return new _definition.GraphQLEnumType({
+	      name: typeAST.name.value,
+	      description: (0, _buildASTSchema.getDescription)(typeAST),
+	      values: (0, _keyValMap2.default)(typeAST.values, function (v) {
+	        return v.name.value;
+	      }, function () {
+	        return {};
+	      })
+	    });
+	  }
+
+	  function buildInputObjectType(typeAST) {
+	    return new _definition.GraphQLInputObjectType({
+	      name: typeAST.name.value,
+	      description: (0, _buildASTSchema.getDescription)(typeAST),
+	      fields: function fields() {
+	        return buildInputValues(typeAST.fields);
+	      }
+	    });
+	  }
+
+	  function getDirective(directiveAST) {
+	    return new _directives.GraphQLDirective({
+	      name: directiveAST.name.value,
+	      locations: directiveAST.locations.map(function (node) {
+	        return node.value;
+	      }),
+	      args: directiveAST.arguments && buildInputValues(directiveAST.arguments)
+	    });
+	  }
+
+	  function buildImplementedInterfaces(typeAST) {
+	    return typeAST.interfaces && typeAST.interfaces.map(getInterfaceTypeFromAST);
+	  }
+
+	  function buildFieldMap(typeAST) {
+	    return (0, _keyValMap2.default)(typeAST.fields, function (field) {
+	      return field.name.value;
+	    }, function (field) {
+	      return {
+	        type: buildOutputFieldType(field.type),
+	        description: (0, _buildASTSchema.getDescription)(field),
+	        args: buildInputValues(field.arguments)
+	      };
+	    });
+	  }
+
+	  function buildInputValues(values) {
+	    return (0, _keyValMap2.default)(values, function (value) {
+	      return value.name.value;
+	    }, function (value) {
+	      var type = buildInputFieldType(value.type);
+	      return {
+	        type: type,
+	        description: (0, _buildASTSchema.getDescription)(value),
+	        defaultValue: (0, _valueFromAST.valueFromAST)(value.defaultValue, type)
+	      };
+	    });
+	  }
+
+	  function buildInputFieldType(typeAST) {
+	    if (typeAST.kind === _kinds.LIST_TYPE) {
+	      return new _definition.GraphQLList(buildInputFieldType(typeAST.type));
+	    }
+	    if (typeAST.kind === _kinds.NON_NULL_TYPE) {
+	      var nullableType = buildInputFieldType(typeAST.type);
+	      (0, _invariant2.default)(!(nullableType instanceof _definition.GraphQLNonNull), 'Must be nullable');
+	      return new _definition.GraphQLNonNull(nullableType);
+	    }
+	    return getInputTypeFromAST(typeAST);
+	  }
+
+	  function buildOutputFieldType(typeAST) {
+	    if (typeAST.kind === _kinds.LIST_TYPE) {
+	      return new _definition.GraphQLList(buildOutputFieldType(typeAST.type));
+	    }
+	    if (typeAST.kind === _kinds.NON_NULL_TYPE) {
+	      var nullableType = buildOutputFieldType(typeAST.type);
+	      (0, _invariant2.default)(!(nullableType instanceof _definition.GraphQLNonNull), 'Must be nullable');
+	      return new _definition.GraphQLNonNull(nullableType);
+	    }
+	    return getOutputTypeFromAST(typeAST);
+	  }
+	}
+
+	function cannotExecuteExtendedSchema() {
+	  throw new Error('Extended Schema cannot use Interface or Union types for execution.');
+	}
+
+/***/ },
+/* 258 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.printSchema = printSchema;
+	exports.printIntrospectionSchema = printIntrospectionSchema;
+
+	var _invariant = __webpack_require__(200);
+
+	var _invariant2 = _interopRequireDefault(_invariant);
+
+	var _isNullish = __webpack_require__(204);
+
+	var _isNullish2 = _interopRequireDefault(_isNullish);
+
+	var _astFromValue = __webpack_require__(209);
+
+	var _printer = __webpack_require__(194);
+
+	var _definition = __webpack_require__(203);
+
+	var _scalars = __webpack_require__(207);
+
+	var _directives = __webpack_require__(206);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function printSchema(schema) {
+	  return printFilteredSchema(schema, function (n) {
+	    return !isSpecDirective(n);
+	  }, isDefinedType);
+	}
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function printIntrospectionSchema(schema) {
+	  return printFilteredSchema(schema, isSpecDirective, isIntrospectionType);
+	}
+
+	function isSpecDirective(directiveName) {
+	  return directiveName === 'skip' || directiveName === 'include' || directiveName === 'deprecated';
+	}
+
+	function isDefinedType(typename) {
+	  return !isIntrospectionType(typename) && !isBuiltInScalar(typename);
+	}
+
+	function isIntrospectionType(typename) {
+	  return typename.indexOf('__') === 0;
+	}
+
+	function isBuiltInScalar(typename) {
+	  return typename === 'String' || typename === 'Boolean' || typename === 'Int' || typename === 'Float' || typename === 'ID';
+	}
+
+	function printFilteredSchema(schema, directiveFilter, typeFilter) {
+	  var directives = schema.getDirectives().filter(function (directive) {
+	    return directiveFilter(directive.name);
+	  });
+	  var typeMap = schema.getTypeMap();
+	  var types = Object.keys(typeMap).filter(typeFilter).sort(function (name1, name2) {
+	    return name1.localeCompare(name2);
+	  }).map(function (typeName) {
+	    return typeMap[typeName];
+	  });
+
+	  return [printSchemaDefinition(schema)].concat(directives.map(printDirective), types.map(printType)).filter(Boolean).join('\n\n') + '\n';
+	}
+
+	function printSchemaDefinition(schema) {
+	  if (isSchemaOfCommonNames(schema)) {
+	    return;
+	  }
+
+	  var operationTypes = [];
+
+	  var queryType = schema.getQueryType();
+	  if (queryType) {
+	    operationTypes.push('  query: ' + queryType.name);
+	  }
+
+	  var mutationType = schema.getMutationType();
+	  if (mutationType) {
+	    operationTypes.push('  mutation: ' + mutationType.name);
+	  }
+
+	  var subscriptionType = schema.getSubscriptionType();
+	  if (subscriptionType) {
+	    operationTypes.push('  subscription: ' + subscriptionType.name);
+	  }
+
+	  return 'schema {\n' + operationTypes.join('\n') + '\n}';
+	}
+
+	/**
+	 * GraphQL schema define root types for each type of operation. These types are
+	 * the same as any other type and can be named in any manner, however there is
+	 * a common naming convention:
+	 *
+	 *   schema {
+	 *     query: Query
+	 *     mutation: Mutation
+	 *   }
+	 *
+	 * When using this naming convention, the schema description can be omitted.
+	 */
+	function isSchemaOfCommonNames(schema) {
+	  var queryType = schema.getQueryType();
+	  if (queryType && queryType.name !== 'Query') {
+	    return false;
+	  }
+
+	  var mutationType = schema.getMutationType();
+	  if (mutationType && mutationType.name !== 'Mutation') {
+	    return false;
+	  }
+
+	  var subscriptionType = schema.getSubscriptionType();
+	  if (subscriptionType && subscriptionType.name !== 'Subscription') {
+	    return false;
+	  }
+
+	  return true;
+	}
+
+	function printType(type) {
+	  if (type instanceof _definition.GraphQLScalarType) {
+	    return printScalar(type);
+	  } else if (type instanceof _definition.GraphQLObjectType) {
+	    return printObject(type);
+	  } else if (type instanceof _definition.GraphQLInterfaceType) {
+	    return printInterface(type);
+	  } else if (type instanceof _definition.GraphQLUnionType) {
+	    return printUnion(type);
+	  } else if (type instanceof _definition.GraphQLEnumType) {
+	    return printEnum(type);
+	  }
+	  (0, _invariant2.default)(type instanceof _definition.GraphQLInputObjectType);
+	  return printInputObject(type);
+	}
+
+	function printScalar(type) {
+	  return printDescription(type) + ('scalar ' + type.name);
+	}
+
+	function printObject(type) {
+	  var interfaces = type.getInterfaces();
+	  var implementedInterfaces = interfaces.length ? ' implements ' + interfaces.map(function (i) {
+	    return i.name;
+	  }).join(', ') : '';
+	  return printDescription(type) + ('type ' + type.name + implementedInterfaces + ' {\n') + printFields(type) + '\n' + '}';
+	}
+
+	function printInterface(type) {
+	  return printDescription(type) + ('interface ' + type.name + ' {\n') + printFields(type) + '\n' + '}';
+	}
+
+	function printUnion(type) {
+	  return printDescription(type) + ('union ' + type.name + ' = ' + type.getTypes().join(' | '));
+	}
+
+	function printEnum(type) {
+	  return printDescription(type) + ('enum ' + type.name + ' {\n') + printEnumValues(type.getValues()) + '\n' + '}';
+	}
+
+	function printEnumValues(values) {
+	  return values.map(function (value, i) {
+	    return printDescription(value, '  ', !i) + '  ' + value.name + printDeprecated(value);
+	  }).join('\n');
+	}
+
+	function printInputObject(type) {
+	  var fieldMap = type.getFields();
+	  var fields = Object.keys(fieldMap).map(function (fieldName) {
+	    return fieldMap[fieldName];
+	  });
+	  return printDescription(type) + ('input ' + type.name + ' {\n') + fields.map(function (f, i) {
+	    return printDescription(f, '  ', !i) + '  ' + printInputValue(f);
+	  }).join('\n') + '\n' + '}';
+	}
+
+	function printFields(type) {
+	  var fieldMap = type.getFields();
+	  var fields = Object.keys(fieldMap).map(function (fieldName) {
+	    return fieldMap[fieldName];
+	  });
+	  return fields.map(function (f, i) {
+	    return printDescription(f, '  ', !i) + '  ' + f.name + printArgs(f.args, '  ') + ': ' + String(f.type) + printDeprecated(f);
+	  }).join('\n');
+	}
+
+	function printArgs(args) {
+	  var indentation = arguments.length <= 1 || arguments[1] === undefined ? '' : arguments[1];
+
+	  if (args.length === 0) {
+	    return '';
+	  }
+
+	  // If every arg does not have a description, print them on one line.
+	  if (args.every(function (arg) {
+	    return !arg.description;
+	  })) {
+	    return '(' + args.map(printInputValue).join(', ') + ')';
+	  }
+
+	  return '(\n' + args.map(function (arg, i) {
+	    return printDescription(arg, '  ' + indentation, !i) + '  ' + indentation + printInputValue(arg);
+	  }).join('\n') + '\n' + indentation + ')';
+	}
+
+	function printInputValue(arg) {
+	  var argDecl = arg.name + ': ' + String(arg.type);
+	  if (!(0, _isNullish2.default)(arg.defaultValue)) {
+	    argDecl += ' = ' + (0, _printer.print)((0, _astFromValue.astFromValue)(arg.defaultValue, arg.type));
+	  }
+	  return argDecl;
+	}
+
+	function printDirective(directive) {
+	  return printDescription(directive) + 'directive @' + directive.name + printArgs(directive.args) + ' on ' + directive.locations.join(' | ');
+	}
+
+	function printDeprecated(fieldOrEnumVal) {
+	  var reason = fieldOrEnumVal.deprecationReason;
+	  if ((0, _isNullish2.default)(reason)) {
+	    return '';
+	  }
+	  if (reason === '' || reason === _directives.DEFAULT_DEPRECATION_REASON) {
+	    return ' @deprecated';
+	  }
+	  return ' @deprecated(reason: ' + (0, _printer.print)((0, _astFromValue.astFromValue)(reason, _scalars.GraphQLString)) + ')';
+	}
+
+	function printDescription(def) {
+	  var indentation = arguments.length <= 1 || arguments[1] === undefined ? '' : arguments[1];
+	  var firstInBlock = arguments.length <= 2 || arguments[2] === undefined ? true : arguments[2];
+
+	  if (!def.description) {
+	    return '';
+	  }
+	  var lines = def.description.split('\n');
+	  var description = indentation && !firstInBlock ? '\n' : '';
+	  for (var i = 0; i < lines.length; i++) {
+	    if (lines[i] === '') {
+	      description += indentation + '#\n';
+	    } else {
+	      // For > 120 character long lines, cut at space boundaries into sublines
+	      // of ~80 chars.
+	      var sublines = breakLine(lines[i], 120 - indentation.length);
+	      for (var j = 0; j < sublines.length; j++) {
+	        description += indentation + '# ' + sublines[j] + '\n';
+	      }
+	    }
+	  }
+	  return description;
+	}
+
+	function breakLine(line, len) {
+	  if (line.length < len + 5) {
+	    return [line];
+	  }
+	  var parts = line.split(new RegExp('((?: |^).{15,' + (len - 40) + '}(?= |$))'));
+	  if (parts.length < 4) {
+	    return [line];
+	  }
+	  var sublines = [parts[0] + parts[1] + parts[2]];
+	  for (var i = 3; i < parts.length; i += 2) {
+	    sublines.push(parts[i].slice(1) + parts[i + 1]);
+	  }
+	  return sublines;
+	}
+
+/***/ },
+/* 259 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.concatAST = concatAST;
+
+
+	/**
+	 * Provided a collection of ASTs, presumably each from different files,
+	 * concatenate the ASTs together into batched AST, useful for validating many
+	 * GraphQL source files which together represent one conceptual application.
+	 */
+	function concatAST(asts) {
+	  var batchDefinitions = [];
+	  for (var i = 0; i < asts.length; i++) {
+	    var definitions = asts[i].definitions;
+	    for (var j = 0; j < definitions.length; j++) {
+	      batchDefinitions.push(definitions[j]);
+	    }
+	  }
+	  return {
+	    kind: 'Document',
+	    definitions: batchDefinitions
+	  };
+	}
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+/***/ },
+/* 260 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.separateOperations = separateOperations;
+
+	var _visitor = __webpack_require__(195);
+
+	/**
+	 * separateOperations accepts a single AST document which may contain many
+	 * operations and fragments and returns a collection of AST documents each of
+	 * which contains a single operation as well the fragment definitions it
+	 * refers to.
+	 */
+	function separateOperations(documentAST) {
+
+	  var operations = [];
+	  var depGraph = Object.create(null);
+	  var fromName = void 0;
+
+	  // Populate the list of operations and build a dependency graph.
+	  (0, _visitor.visit)(documentAST, {
+	    OperationDefinition: function OperationDefinition(node) {
+	      operations.push(node);
+	      fromName = opName(node);
+	    },
+	    FragmentDefinition: function FragmentDefinition(node) {
+	      fromName = node.name.value;
+	    },
+	    FragmentSpread: function FragmentSpread(node) {
+	      var toName = node.name.value;
+	      (depGraph[fromName] || (depGraph[fromName] = Object.create(null)))[toName] = true;
+	    }
+	  });
+
+	  // For each operation, produce a new synthesized AST which includes only what
+	  // is necessary for completing that operation.
+	  var separatedDocumentASTs = Object.create(null);
+	  operations.forEach(function (operation) {
+	    var operationName = opName(operation);
+	    var dependencies = Object.create(null);
+	    collectTransitiveDependencies(dependencies, depGraph, operationName);
+
+	    separatedDocumentASTs[operationName] = {
+	      kind: 'Document',
+	      definitions: documentAST.definitions.filter(function (def) {
+	        return def === operation || def.kind === 'FragmentDefinition' && dependencies[def.name.value];
+	      })
+	    };
+	  });
+
+	  return separatedDocumentASTs;
+	}
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	// Provides the empty string for anonymous operations.
+	function opName(operation) {
+	  return operation.name ? operation.name.value : '';
+	}
+
+	// From a dependency graph, collects a list of transitive dependencies by
+	// recursing through a dependency graph.
+	function collectTransitiveDependencies(collected, depGraph, fromName) {
+	  var immediateDeps = depGraph[fromName];
+	  if (immediateDeps) {
+	    Object.keys(immediateDeps).forEach(function (toName) {
+	      if (!collected[toName]) {
+	        collected[toName] = true;
+	        collectTransitiveDependencies(collected, depGraph, toName);
+	      }
+	    });
+	  }
+	}
+
+/***/ },
+/* 261 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.BreakingChangeType = undefined;
+	exports.findBreakingChanges = findBreakingChanges;
+	exports.findRemovedTypes = findRemovedTypes;
+	exports.findTypesThatChangedKind = findTypesThatChangedKind;
+	exports.findFieldsThatChangedType = findFieldsThatChangedType;
+	exports.findTypesRemovedFromUnions = findTypesRemovedFromUnions;
+	exports.findValuesRemovedFromEnums = findValuesRemovedFromEnums;
+
+	var _definition = __webpack_require__(203);
+
+	var _schema = __webpack_require__(202);
+
+	/**
+	 *  Copyright (c) 2016, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	var BreakingChangeType = exports.BreakingChangeType = {
+	  FIELD_CHANGED_KIND: 'FIELD_CHANGED_KIND',
+	  FIELD_REMOVED: 'FIELD_REMOVED',
+	  TYPE_CHANGED_KIND: 'TYPE_CHANGED_KIND',
+	  TYPE_REMOVED: 'TYPE_REMOVED',
+	  TYPE_REMOVED_FROM_UNION: 'TYPE_REMOVED_FROM_UNION',
+	  VALUE_REMOVED_FROM_ENUM: 'VALUE_REMOVED_FROM_ENUM'
+	};
+
+	/**
+	 * Given two schemas, returns an Array containing descriptions of all the types
+	 * of breaking changes covered by the other functions down below.
+	 */
+	function findBreakingChanges(oldSchema, newSchema) {
+	  return [].concat(findRemovedTypes(oldSchema, newSchema), findTypesThatChangedKind(oldSchema, newSchema), findFieldsThatChangedType(oldSchema, newSchema), findTypesRemovedFromUnions(oldSchema, newSchema), findValuesRemovedFromEnums(oldSchema, newSchema));
+	}
+
+	/**
+	 * Given two schemas, returns an Array containing descriptions of any breaking
+	 * changes in the newSchema related to removing an entire type.
+	 */
+	function findRemovedTypes(oldSchema, newSchema) {
+	  var oldTypeMap = oldSchema.getTypeMap();
+	  var newTypeMap = newSchema.getTypeMap();
+
+	  var breakingChanges = [];
+	  Object.keys(oldTypeMap).forEach(function (typeName) {
+	    if (!newTypeMap[typeName]) {
+	      breakingChanges.push({
+	        type: BreakingChangeType.TYPE_REMOVED,
+	        description: typeName + ' was removed.'
+	      });
+	    }
+	  });
+	  return breakingChanges;
+	}
+
+	/**
+	 * Given two schemas, returns an Array containing descriptions of any breaking
+	 * changes in the newSchema related to changing the type of a type.
+	 */
+	function findTypesThatChangedKind(oldSchema, newSchema) {
+	  var oldTypeMap = oldSchema.getTypeMap();
+	  var newTypeMap = newSchema.getTypeMap();
+
+	  var breakingChanges = [];
+	  Object.keys(oldTypeMap).forEach(function (typeName) {
+	    if (!newTypeMap[typeName]) {
+	      return;
+	    }
+	    var oldType = oldTypeMap[typeName];
+	    var newType = newTypeMap[typeName];
+	    if (!(oldType instanceof newType.constructor)) {
+	      breakingChanges.push({
+	        type: BreakingChangeType.TYPE_CHANGED_KIND,
+	        description: typeName + ' changed from ' + (typeKindName(oldType) + ' to ' + typeKindName(newType) + '.')
+	      });
+	    }
+	  });
+	  return breakingChanges;
+	}
+
+	function typeKindName(type) {
+	  if (type instanceof _definition.GraphQLScalarType) {
+	    return 'a Scalar type';
+	  }
+	  if (type instanceof _definition.GraphQLObjectType) {
+	    return 'an Object type';
+	  }
+	  if (type instanceof _definition.GraphQLInterfaceType) {
+	    return 'an Interface type';
+	  }
+	  if (type instanceof _definition.GraphQLUnionType) {
+	    return 'a Union type';
+	  }
+	  if (type instanceof _definition.GraphQLEnumType) {
+	    return 'an Enum type';
+	  }
+	  if (type instanceof _definition.GraphQLInputObjectType) {
+	    return 'an Input type';
+	  }
+	  throw new TypeError('Unknown type ' + type.constructor.name);
+	}
+
+	/**
+	 * Given two schemas, returns an Array containing descriptions of any breaking
+	 * changes in the newSchema related to the fields on a type. This includes if
+	 * a field has been removed from a type or if a field has changed type.
+	 */
+	function findFieldsThatChangedType(oldSchema, newSchema) {
+	  var oldTypeMap = oldSchema.getTypeMap();
+	  var newTypeMap = newSchema.getTypeMap();
+
+	  var breakingFieldChanges = [];
+	  Object.keys(oldTypeMap).forEach(function (typeName) {
+	    var oldType = oldTypeMap[typeName];
+	    var newType = newTypeMap[typeName];
+	    if (!(oldType instanceof _definition.GraphQLObjectType || oldType instanceof _definition.GraphQLInterfaceType || oldType instanceof _definition.GraphQLInputObjectType) || !(newType instanceof oldType.constructor)) {
+	      return;
+	    }
+
+	    var oldTypeFieldsDef = oldType.getFields();
+	    var newTypeFieldsDef = newType.getFields();
+	    Object.keys(oldTypeFieldsDef).forEach(function (fieldName) {
+	      // Check if the field is missing on the type in the new schema.
+	      if (!(fieldName in newTypeFieldsDef)) {
+	        breakingFieldChanges.push({
+	          type: BreakingChangeType.FIELD_REMOVED,
+	          description: typeName + '.' + fieldName + ' was removed.'
+	        });
+	      } else {
+	        // Check if the field's type has changed in the new schema.
+	        var oldFieldType = (0, _definition.getNamedType)(oldTypeFieldsDef[fieldName].type);
+	        var newFieldType = (0, _definition.getNamedType)(newTypeFieldsDef[fieldName].type);
+	        if (oldFieldType && newFieldType && oldFieldType.name !== newFieldType.name) {
+	          breakingFieldChanges.push({
+	            type: BreakingChangeType.FIELD_CHANGED_KIND,
+	            description: typeName + '.' + fieldName + ' changed type from ' + (oldFieldType.name + ' to ' + newFieldType.name + '.')
+	          });
+	        }
+	      }
+	    });
+	  });
+	  return breakingFieldChanges;
+	}
+
+	/**
+	 * Given two schemas, returns an Array containing descriptions of any breaking
+	 * changes in the newSchema related to removing types from a union type.
+	 */
+	function findTypesRemovedFromUnions(oldSchema, newSchema) {
+	  var oldTypeMap = oldSchema.getTypeMap();
+	  var newTypeMap = newSchema.getTypeMap();
+
+	  var typesRemovedFromUnion = [];
+	  Object.keys(oldTypeMap).forEach(function (typeName) {
+	    var oldType = oldTypeMap[typeName];
+	    var newType = newTypeMap[typeName];
+	    if (!(oldType instanceof _definition.GraphQLUnionType) || !(newType instanceof _definition.GraphQLUnionType)) {
+	      return;
+	    }
+	    var typeNamesInNewUnion = Object.create(null);
+	    newType.getTypes().forEach(function (type) {
+	      typeNamesInNewUnion[type.name] = true;
+	    });
+	    oldType.getTypes().forEach(function (type) {
+	      if (!typeNamesInNewUnion[type.name]) {
+	        typesRemovedFromUnion.push({
+	          type: BreakingChangeType.TYPE_REMOVED_FROM_UNION,
+	          description: type.name + ' was removed from union type ' + typeName + '.'
+	        });
+	      }
+	    });
+	  });
+	  return typesRemovedFromUnion;
+	}
+
+	/**
+	 * Given two schemas, returns an Array containing descriptions of any breaking
+	 * changes in the newSchema related to removing values from an enum type.
+	 */
+	function findValuesRemovedFromEnums(oldSchema, newSchema) {
+	  var oldTypeMap = oldSchema.getTypeMap();
+	  var newTypeMap = newSchema.getTypeMap();
+
+	  var valuesRemovedFromEnums = [];
+	  Object.keys(oldTypeMap).forEach(function (typeName) {
+	    var oldType = oldTypeMap[typeName];
+	    var newType = newTypeMap[typeName];
+	    if (!(oldType instanceof _definition.GraphQLEnumType) || !(newType instanceof _definition.GraphQLEnumType)) {
+	      return;
+	    }
+	    var valuesInNewEnum = Object.create(null);
+	    newType.getValues().forEach(function (value) {
+	      valuesInNewEnum[value.name] = true;
+	    });
+	    oldType.getValues().forEach(function (value) {
+	      if (!valuesInNewEnum[value.name]) {
+	        valuesRemovedFromEnums.push({
+	          type: BreakingChangeType.VALUE_REMOVED_FROM_ENUM,
+	          description: value.name + ' was removed from enum type ' + typeName + '.'
+	        });
+	      }
+	    });
+	  });
+	  return valuesRemovedFromEnums;
+	}
+
+/***/ },
+/* 262 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.ExecuteButton = undefined;
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _react = __webpack_require__(1);
+
+	var _react2 = _interopRequireDefault(_react);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /**
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  Copyright (c) 2015, Facebook, Inc.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  All rights reserved.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  This source code is licensed under the license found in the
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  LICENSE-examples file in the root directory of this source tree.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
+
+	/**
+	 * ExecuteButton
+	 *
+	 * What a nice round shiny button. Shows a drop-down when there are multiple
+	 * queries to run.
+	 */
+	var ExecuteButton = exports.ExecuteButton = function (_React$Component) {
+	  _inherits(ExecuteButton, _React$Component);
+
+	  function ExecuteButton(props) {
+	    _classCallCheck(this, ExecuteButton);
+
+	    var _this = _possibleConstructorReturn(this, (ExecuteButton.__proto__ || Object.getPrototypeOf(ExecuteButton)).call(this, props));
+
+	    _this._onClick = function () {
+	      if (_this.props.isRunning) {
+	        _this.props.onStop();
+	      } else {
+	        _this.props.onRun();
+	      }
+	    };
+
+	    _this._onOptionSelected = function (operation) {
+	      _this.setState({ optionsOpen: false });
+	      _this.props.onRun(operation.name && operation.name.value);
+	    };
+
+	    _this._onOptionsOpen = function (downEvent) {
+	      var initialPress = true;
+	      var downTarget = downEvent.target;
+	      _this.setState({ highlight: null, optionsOpen: true });
+
+	      var _onMouseUp = function onMouseUp(upEvent) {
+	        if (initialPress && upEvent.target === downTarget) {
+	          initialPress = false;
+	        } else {
+	          document.removeEventListener('mouseup', _onMouseUp);
+	          _onMouseUp = null;
+	          var isOptionsMenuClicked = downTarget.parentNode.compareDocumentPosition(upEvent.target) & Node.DOCUMENT_POSITION_CONTAINED_BY;
+	          if (!isOptionsMenuClicked) {
+	            // menu calls setState if it was clicked
+	            _this.setState({ optionsOpen: false });
+	          }
+	        }
+	      };
+
+	      document.addEventListener('mouseup', _onMouseUp);
+	    };
+
+	    _this.state = {
+	      optionsOpen: false,
+	      highlight: null
+	    };
+	    return _this;
+	  }
+
+	  _createClass(ExecuteButton, [{
+	    key: 'render',
+	    value: function render() {
+	      var _this2 = this;
+
+	      var operations = this.props.operations;
+	      var optionsOpen = this.state.optionsOpen;
+	      var hasOptions = operations && operations.length > 1;
+
+	      var options = null;
+	      if (hasOptions && optionsOpen) {
+	        (function () {
+	          var highlight = _this2.state.highlight;
+	          options = _react2.default.createElement(
+	            'ul',
+	            { className: 'execute-options' },
+	            operations.map(function (operation) {
+	              return _react2.default.createElement(
+	                'li',
+	                {
+	                  key: operation.name ? operation.name.value : '*',
+	                  className: operation === highlight && 'selected',
+	                  onMouseOver: function onMouseOver() {
+	                    return _this2.setState({ highlight: operation });
+	                  },
+	                  onMouseOut: function onMouseOut() {
+	                    return _this2.setState({ highlight: null });
+	                  },
+	                  onMouseUp: function onMouseUp() {
+	                    return _this2._onOptionSelected(operation);
+	                  } },
+	                operation.name ? operation.name.value : '<Unnamed>'
+	              );
+	            })
+	          );
+	        })();
+	      }
+
+	      // Allow click event if there is a running query or if there are not options
+	      // for which operation to run.
+	      var onClick = void 0;
+	      if (this.props.isRunning || !hasOptions) {
+	        onClick = this._onClick;
+	      }
+
+	      // Allow mouse down if there is no running query, there are options for
+	      // which operation to run, and the dropdown is currently closed.
+	      var onMouseDown = void 0;
+	      if (!this.props.isRunning && hasOptions && !optionsOpen) {
+	        onMouseDown = this._onOptionsOpen;
+	      }
+
+	      var pathJSX = this.props.isRunning ? _react2.default.createElement('path', { d: 'M 10 10 L 23 10 L 23 23 L 10 23 z' }) : _react2.default.createElement('path', { d: 'M 11 9 L 24 16 L 11 23 z' });
+
+	      return _react2.default.createElement(
+	        'div',
+	        { className: 'execute-button-wrap' },
+	        _react2.default.createElement(
+	          'button',
+	          {
+	            className: 'execute-button',
+	            onMouseDown: onMouseDown,
+	            onClick: onClick,
+	            title: 'Execute Query (Ctrl-Enter)' },
+	          _react2.default.createElement(
+	            'svg',
+	            { width: '34', height: '34' },
+	            pathJSX
+	          )
+	        ),
+	        options
+	      );
+	    }
+	  }]);
+
+	  return ExecuteButton;
+	}(_react2.default.Component);
+
+	ExecuteButton.propTypes = {
+	  onRun: _react.PropTypes.func,
+	  onStop: _react.PropTypes.func,
+	  isRunning: _react.PropTypes.bool,
+	  operations: _react.PropTypes.array
+	};
+
+/***/ },
+/* 263 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.ToolbarButton = undefined;
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _react = __webpack_require__(1);
+
+	var _react2 = _interopRequireDefault(_react);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /**
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  Copyright (c) 2015, Facebook, Inc.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  All rights reserved.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  This source code is licensed under the license found in the
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  LICENSE-examples file in the root directory of this source tree.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
+
+	/**
+	 * ToolbarButton
+	 *
+	 * A button to use within the Toolbar.
+	 */
+	var ToolbarButton = exports.ToolbarButton = function (_React$Component) {
+	  _inherits(ToolbarButton, _React$Component);
+
+	  function ToolbarButton(props) {
+	    _classCallCheck(this, ToolbarButton);
+
+	    var _this = _possibleConstructorReturn(this, (ToolbarButton.__proto__ || Object.getPrototypeOf(ToolbarButton)).call(this, props));
+
+	    _this.handleClick = function (e) {
+	      e.preventDefault();
+	      try {
+	        _this.props.onClick();
+	        _this.setState({ error: null });
+	      } catch (error) {
+	        _this.setState({ error: error });
+	      }
+	    };
+
+	    _this.state = { error: null };
+	    return _this;
+	  }
+
+	  _createClass(ToolbarButton, [{
+	    key: 'render',
+	    value: function render() {
+	      var error = this.state.error;
+
+	      return _react2.default.createElement(
+	        'a',
+	        {
+	          className: 'toolbar-button' + (error ? ' error' : ''),
+	          onClick: this.handleClick,
+	          title: error ? error.message : this.props.title },
+	        this.props.label
+	      );
+	    }
+	  }]);
+
+	  return ToolbarButton;
+	}(_react2.default.Component);
+
+	ToolbarButton.propTypes = {
+	  onClick: _react.PropTypes.func,
+	  title: _react.PropTypes.string,
+	  label: _react.PropTypes.string
+	};
+
+/***/ },
+/* 264 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.QueryEditor = undefined;
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _react = __webpack_require__(1);
+
+	var _react2 = _interopRequireDefault(_react);
+
+	var _reactDom = __webpack_require__(32);
+
+	var _reactDom2 = _interopRequireDefault(_reactDom);
+
+	var _graphql = __webpack_require__(185);
+
+	var _onHasCompletion = __webpack_require__(265);
+
+	var _onHasCompletion2 = _interopRequireDefault(_onHasCompletion);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /**
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  Copyright (c) 2015, Facebook, Inc.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  All rights reserved.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  This source code is licensed under the license found in the
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  LICENSE-examples file in the root directory of this source tree.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
+
+	/**
+	 * QueryEditor
+	 *
+	 * Maintains an instance of CodeMirror responsible for editing a GraphQL query.
+	 *
+	 * Props:
+	 *
+	 *   - schema: A GraphQLSchema instance enabling editor linting and hinting.
+	 *   - value: The text of the editor.
+	 *   - onEdit: A function called when the editor changes, given the edited text.
+	 *
+	 */
+	var QueryEditor = exports.QueryEditor = function (_React$Component) {
+	  _inherits(QueryEditor, _React$Component);
+
+	  function QueryEditor(props) {
+	    _classCallCheck(this, QueryEditor);
+
+	    // Keep a cached version of the value, this cache will be updated when the
+	    // editor is updated, which can later be used to protect the editor from
+	    // unnecessary updates during the update lifecycle.
+	    var _this = _possibleConstructorReturn(this, (QueryEditor.__proto__ || Object.getPrototypeOf(QueryEditor)).call(this));
+
+	    _this._onKeyUp = function (cm, event) {
+	      var code = event.keyCode;
+	      if (code >= 65 && code <= 90 || // letters
+	      !event.shiftKey && code >= 48 && code <= 57 || // numbers
+	      event.shiftKey && code === 189 || // underscore
+	      event.shiftKey && code === 50 || // @
+	      event.shiftKey && code === 57 // (
+	      ) {
+	          _this.editor.execCommand('autocomplete');
+	        }
+	    };
+
+	    _this._onEdit = function () {
+	      if (!_this.ignoreChangeEvent) {
+	        _this.cachedValue = _this.editor.getValue();
+	        if (_this.props.onEdit) {
+	          _this.props.onEdit(_this.cachedValue);
+	        }
+	      }
+	    };
+
+	    _this._onHasCompletion = function (cm, data) {
+	      (0, _onHasCompletion2.default)(cm, data, _this.props.onHintInformationRender);
+	    };
+
+	    _this.cachedValue = props.value || '';
+	    return _this;
+	  }
+
+	  _createClass(QueryEditor, [{
+	    key: 'componentDidMount',
+	    value: function componentDidMount() {
+	      var _this2 = this;
+
+	      // Lazily require to ensure requiring GraphiQL outside of a Browser context
+	      // does not produce an error.
+	      var CodeMirror = __webpack_require__(267);
+	      __webpack_require__(268);
+	      __webpack_require__(269);
+	      __webpack_require__(270);
+	      __webpack_require__(271);
+	      __webpack_require__(272);
+	      __webpack_require__(274);
+	      __webpack_require__(275);
+	      __webpack_require__(276);
+	      __webpack_require__(278);
+	      __webpack_require__(288);
+	      __webpack_require__(289);
+
+	      this.editor = CodeMirror(_reactDom2.default.findDOMNode(this), {
+	        value: this.props.value || '',
+	        lineNumbers: true,
+	        tabSize: 2,
+	        mode: 'graphql',
+	        theme: 'graphiql',
+	        keyMap: 'sublime',
+	        autoCloseBrackets: true,
+	        matchBrackets: true,
+	        showCursorWhenSelecting: true,
+	        foldGutter: {
+	          minFoldSize: 4
+	        },
+	        lint: {
+	          schema: this.props.schema
+	        },
+	        hintOptions: {
+	          schema: this.props.schema,
+	          closeOnUnfocus: false,
+	          completeSingle: false
+	        },
+	        gutters: ['CodeMirror-linenumbers', 'CodeMirror-foldgutter'],
+	        extraKeys: {
+	          'Cmd-Space': function CmdSpace() {
+	            return _this2.editor.showHint({ completeSingle: true });
+	          },
+	          'Ctrl-Space': function CtrlSpace() {
+	            return _this2.editor.showHint({ completeSingle: true });
+	          },
+	          'Alt-Space': function AltSpace() {
+	            return _this2.editor.showHint({ completeSingle: true });
+	          },
+	          'Shift-Space': function ShiftSpace() {
+	            return _this2.editor.showHint({ completeSingle: true });
+	          },
+
+	          'Cmd-Enter': function CmdEnter() {
+	            if (_this2.props.onRunQuery) {
+	              _this2.props.onRunQuery();
+	            }
+	          },
+	          'Ctrl-Enter': function CtrlEnter() {
+	            if (_this2.props.onRunQuery) {
+	              _this2.props.onRunQuery();
+	            }
+	          },
+
+	          // Editor improvements
+	          'Ctrl-Left': 'goSubwordLeft',
+	          'Ctrl-Right': 'goSubwordRight',
+	          'Alt-Left': 'goGroupLeft',
+	          'Alt-Right': 'goGroupRight'
+	        }
+	      });
+
+	      this.editor.on('change', this._onEdit);
+	      this.editor.on('keyup', this._onKeyUp);
+	      this.editor.on('hasCompletion', this._onHasCompletion);
+	    }
+	  }, {
+	    key: 'componentDidUpdate',
+	    value: function componentDidUpdate(prevProps) {
+	      var CodeMirror = __webpack_require__(267);
+
+	      // Ensure the changes caused by this update are not interpretted as
+	      // user-input changes which could otherwise result in an infinite
+	      // event loop.
+	      this.ignoreChangeEvent = true;
+	      if (this.props.schema !== prevProps.schema) {
+	        this.editor.options.lint.schema = this.props.schema;
+	        this.editor.options.hintOptions.schema = this.props.schema;
+	        CodeMirror.signal(this.editor, 'change', this.editor);
+	      }
+	      if (this.props.value !== prevProps.value && this.props.value !== this.cachedValue) {
+	        this.cachedValue = this.props.value;
+	        this.editor.setValue(this.props.value);
+	      }
+	      this.ignoreChangeEvent = false;
+	    }
+	  }, {
+	    key: 'componentWillUnmount',
+	    value: function componentWillUnmount() {
+	      this.editor.off('change', this._onEdit);
+	      this.editor.off('keyup', this._onKeyUp);
+	      this.editor.off('hasCompletion', this._onHasCompletion);
+	      this.editor = null;
+	    }
+	  }, {
+	    key: 'render',
+	    value: function render() {
+	      return _react2.default.createElement('div', { className: 'query-editor' });
+	    }
+
+	    /**
+	     * Public API for retrieving the CodeMirror instance from this
+	     * React component.
+	     */
+
+	  }, {
+	    key: 'getCodeMirror',
+	    value: function getCodeMirror() {
+	      return this.editor;
+	    }
+
+	    /**
+	     * Render a custom UI for CodeMirror's hint which includes additional info
+	     * about the type and description for the selected context.
+	     */
+
+	  }]);
+
+	  return QueryEditor;
+	}(_react2.default.Component);
+
+	QueryEditor.propTypes = {
+	  schema: _react.PropTypes.instanceOf(_graphql.GraphQLSchema),
+	  value: _react.PropTypes.string,
+	  onEdit: _react.PropTypes.func,
+	  onHintInformationRender: _react.PropTypes.func,
+	  onRunQuery: _react.PropTypes.func
+	};
+
+/***/ },
+/* 265 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = onHasCompletion;
+
+	var _graphql = __webpack_require__(185);
+
+	var _marked = __webpack_require__(266);
+
+	var _marked2 = _interopRequireDefault(_marked);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 * Render a custom UI for CodeMirror's hint which includes additional info
+	 * about the type and description for the selected context.
+	 */
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function onHasCompletion(cm, data, onHintInformationRender) {
+	  var CodeMirror = __webpack_require__(267);
+
+	  var wrapper = void 0;
+	  var information = void 0;
+
+	  // When a hint result is selected, we touch the UI.
+	  CodeMirror.on(data, 'select', function (ctx, el) {
+	    // Only the first time (usually when the hint UI is first displayed)
+	    // do we create the wrapping node.
+	    if (!wrapper) {
+	      (function () {
+	        // Wrap the existing hint UI, so we have a place to put information.
+	        var hintsUl = el.parentNode;
+	        var container = hintsUl.parentNode;
+	        wrapper = document.createElement('div');
+	        container.appendChild(wrapper);
+
+	        // CodeMirror vertically inverts the hint UI if there is not enough
+	        // space below the cursor. Since this modified UI appends to the bottom
+	        // of CodeMirror's existing UI, it could cover the cursor. This adjusts
+	        // the positioning of the hint UI to accomodate.
+	        var top = hintsUl.style.top;
+	        var bottom = '';
+	        var cursorTop = cm.cursorCoords().top;
+	        if (parseInt(top, 10) < cursorTop) {
+	          top = '';
+	          bottom = window.innerHeight - cursorTop + 3 + 'px';
+	        }
+
+	        // Style the wrapper, remove positioning from hints. Note that usage
+	        // of this option will need to specify CSS to remove some styles from
+	        // the existing hint UI.
+	        wrapper.className = 'CodeMirror-hints-wrapper';
+	        wrapper.style.left = hintsUl.style.left;
+	        wrapper.style.top = top;
+	        wrapper.style.bottom = bottom;
+	        hintsUl.style.left = '';
+	        hintsUl.style.top = '';
+
+	        // This "information" node will contain the additional info about the
+	        // highlighted typeahead option.
+	        information = document.createElement('div');
+	        information.className = 'CodeMirror-hint-information';
+	        if (bottom) {
+	          wrapper.appendChild(information);
+	          wrapper.appendChild(hintsUl);
+	        } else {
+	          wrapper.appendChild(hintsUl);
+	          wrapper.appendChild(information);
+	        }
+
+	        // When CodeMirror attempts to remove the hint UI, we detect that it was
+	        // removed from our wrapper and in turn remove the wrapper from the
+	        // original container.
+	        var _onRemoveFn = void 0;
+	        wrapper.addEventListener('DOMNodeRemoved', _onRemoveFn = function onRemoveFn(event) {
+	          if (event.target === hintsUl) {
+	            wrapper.removeEventListener('DOMNodeRemoved', _onRemoveFn);
+	            wrapper.parentNode.removeChild(wrapper);
+	            wrapper = null;
+	            information = null;
+	            _onRemoveFn = null;
+	          }
+	        });
+	      })();
+	    }
+
+	    // Now that the UI has been set up, add info to information.
+	    var description = ctx.description ? (0, _marked2.default)(ctx.description, { smartypants: true }) : 'Self descriptive.';
+	    var type = ctx.type ? '<span class="infoType">' + renderType(ctx.type) + '</span>' : '';
+
+	    information.innerHTML = '<div class="content">' + (description.slice(0, 3) === '<p>' ? '<p>' + type + description.slice(3) : type + description) + '</div>';
+
+	    // Additional rendering?
+	    if (onHintInformationRender) {
+	      onHintInformationRender(information);
+	    }
+	  });
+	}
+
+	function renderType(type) {
+	  if (type instanceof _graphql.GraphQLNonNull) {
+	    return renderType(type.ofType) + '!';
+	  }
+	  if (type instanceof _graphql.GraphQLList) {
+	    return '[' + renderType(type.ofType) + ']';
+	  }
+	  return '<a class="typeName">' + type.name + '</a>';
+	}
+
+/***/ },
+/* 266 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(global) {/**
+	 * marked - a markdown parser
+	 * Copyright (c) 2011-2014, Christopher Jeffrey. (MIT Licensed)
+	 * https://github.com/chjj/marked
+	 */
+
+	;(function() {
+
+	/**
+	 * Block-Level Grammar
+	 */
+
+	var block = {
+	  newline: /^\n+/,
+	  code: /^( {4}[^\n]+\n*)+/,
+	  fences: noop,
+	  hr: /^( *[-*_]){3,} *(?:\n+|$)/,
+	  heading: /^ *(#{1,6}) *([^\n]+?) *#* *(?:\n+|$)/,
+	  nptable: noop,
+	  lheading: /^([^\n]+)\n *(=|-){2,} *(?:\n+|$)/,
+	  blockquote: /^( *>[^\n]+(\n(?!def)[^\n]+)*\n*)+/,
+	  list: /^( *)(bull) [\s\S]+?(?:hr|def|\n{2,}(?! )(?!\1bull )\n*|\s*$)/,
+	  html: /^ *(?:comment *(?:\n|\s*$)|closed *(?:\n{2,}|\s*$)|closing *(?:\n{2,}|\s*$))/,
+	  def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +["(]([^\n]+)[")])? *(?:\n+|$)/,
+	  table: noop,
+	  paragraph: /^((?:[^\n]+\n?(?!hr|heading|lheading|blockquote|tag|def))+)\n*/,
+	  text: /^[^\n]+/
+	};
+
+	block.bullet = /(?:[*+-]|\d+\.)/;
+	block.item = /^( *)(bull) [^\n]*(?:\n(?!\1bull )[^\n]*)*/;
+	block.item = replace(block.item, 'gm')
+	  (/bull/g, block.bullet)
+	  ();
+
+	block.list = replace(block.list)
+	  (/bull/g, block.bullet)
+	  ('hr', '\\n+(?=\\1?(?:[-*_] *){3,}(?:\\n+|$))')
+	  ('def', '\\n+(?=' + block.def.source + ')')
+	  ();
+
+	block.blockquote = replace(block.blockquote)
+	  ('def', block.def)
+	  ();
+
+	block._tag = '(?!(?:'
+	  + 'a|em|strong|small|s|cite|q|dfn|abbr|data|time|code'
+	  + '|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo'
+	  + '|span|br|wbr|ins|del|img)\\b)\\w+(?!:/|[^\\w\\s@]*@)\\b';
+
+	block.html = replace(block.html)
+	  ('comment', /<!--[\s\S]*?-->/)
+	  ('closed', /<(tag)[\s\S]+?<\/\1>/)
+	  ('closing', /<tag(?:"[^"]*"|'[^']*'|[^'">])*?>/)
+	  (/tag/g, block._tag)
+	  ();
+
+	block.paragraph = replace(block.paragraph)
+	  ('hr', block.hr)
+	  ('heading', block.heading)
+	  ('lheading', block.lheading)
+	  ('blockquote', block.blockquote)
+	  ('tag', '<' + block._tag)
+	  ('def', block.def)
+	  ();
+
+	/**
+	 * Normal Block Grammar
+	 */
+
+	block.normal = merge({}, block);
+
+	/**
+	 * GFM Block Grammar
+	 */
+
+	block.gfm = merge({}, block.normal, {
+	  fences: /^ *(`{3,}|~{3,})[ \.]*(\S+)? *\n([\s\S]*?)\s*\1 *(?:\n+|$)/,
+	  paragraph: /^/,
+	  heading: /^ *(#{1,6}) +([^\n]+?) *#* *(?:\n+|$)/
+	});
+
+	block.gfm.paragraph = replace(block.paragraph)
+	  ('(?!', '(?!'
+	    + block.gfm.fences.source.replace('\\1', '\\2') + '|'
+	    + block.list.source.replace('\\1', '\\3') + '|')
+	  ();
+
+	/**
+	 * GFM + Tables Block Grammar
+	 */
+
+	block.tables = merge({}, block.gfm, {
+	  nptable: /^ *(\S.*\|.*)\n *([-:]+ *\|[-| :]*)\n((?:.*\|.*(?:\n|$))*)\n*/,
+	  table: /^ *\|(.+)\n *\|( *[-:]+[-| :]*)\n((?: *\|.*(?:\n|$))*)\n*/
+	});
+
+	/**
+	 * Block Lexer
+	 */
+
+	function Lexer(options) {
+	  this.tokens = [];
+	  this.tokens.links = {};
+	  this.options = options || marked.defaults;
+	  this.rules = block.normal;
+
+	  if (this.options.gfm) {
+	    if (this.options.tables) {
+	      this.rules = block.tables;
+	    } else {
+	      this.rules = block.gfm;
+	    }
+	  }
+	}
+
+	/**
+	 * Expose Block Rules
+	 */
+
+	Lexer.rules = block;
+
+	/**
+	 * Static Lex Method
+	 */
+
+	Lexer.lex = function(src, options) {
+	  var lexer = new Lexer(options);
+	  return lexer.lex(src);
+	};
+
+	/**
+	 * Preprocessing
+	 */
+
+	Lexer.prototype.lex = function(src) {
+	  src = src
+	    .replace(/\r\n|\r/g, '\n')
+	    .replace(/\t/g, '    ')
+	    .replace(/\u00a0/g, ' ')
+	    .replace(/\u2424/g, '\n');
+
+	  return this.token(src, true);
+	};
+
+	/**
+	 * Lexing
+	 */
+
+	Lexer.prototype.token = function(src, top, bq) {
+	  var src = src.replace(/^ +$/gm, '')
+	    , next
+	    , loose
+	    , cap
+	    , bull
+	    , b
+	    , item
+	    , space
+	    , i
+	    , l;
+
+	  while (src) {
+	    // newline
+	    if (cap = this.rules.newline.exec(src)) {
+	      src = src.substring(cap[0].length);
+	      if (cap[0].length > 1) {
+	        this.tokens.push({
+	          type: 'space'
+	        });
+	      }
+	    }
+
+	    // code
+	    if (cap = this.rules.code.exec(src)) {
+	      src = src.substring(cap[0].length);
+	      cap = cap[0].replace(/^ {4}/gm, '');
+	      this.tokens.push({
+	        type: 'code',
+	        text: !this.options.pedantic
+	          ? cap.replace(/\n+$/, '')
+	          : cap
+	      });
+	      continue;
+	    }
+
+	    // fences (gfm)
+	    if (cap = this.rules.fences.exec(src)) {
+	      src = src.substring(cap[0].length);
+	      this.tokens.push({
+	        type: 'code',
+	        lang: cap[2],
+	        text: cap[3] || ''
+	      });
+	      continue;
+	    }
+
+	    // heading
+	    if (cap = this.rules.heading.exec(src)) {
+	      src = src.substring(cap[0].length);
+	      this.tokens.push({
+	        type: 'heading',
+	        depth: cap[1].length,
+	        text: cap[2]
+	      });
+	      continue;
+	    }
+
+	    // table no leading pipe (gfm)
+	    if (top && (cap = this.rules.nptable.exec(src))) {
+	      src = src.substring(cap[0].length);
+
+	      item = {
+	        type: 'table',
+	        header: cap[1].replace(/^ *| *\| *$/g, '').split(/ *\| */),
+	        align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
+	        cells: cap[3].replace(/\n$/, '').split('\n')
+	      };
+
+	      for (i = 0; i < item.align.length; i++) {
+	        if (/^ *-+: *$/.test(item.align[i])) {
+	          item.align[i] = 'right';
+	        } else if (/^ *:-+: *$/.test(item.align[i])) {
+	          item.align[i] = 'center';
+	        } else if (/^ *:-+ *$/.test(item.align[i])) {
+	          item.align[i] = 'left';
+	        } else {
+	          item.align[i] = null;
+	        }
+	      }
+
+	      for (i = 0; i < item.cells.length; i++) {
+	        item.cells[i] = item.cells[i].split(/ *\| */);
+	      }
+
+	      this.tokens.push(item);
+
+	      continue;
+	    }
+
+	    // lheading
+	    if (cap = this.rules.lheading.exec(src)) {
+	      src = src.substring(cap[0].length);
+	      this.tokens.push({
+	        type: 'heading',
+	        depth: cap[2] === '=' ? 1 : 2,
+	        text: cap[1]
+	      });
+	      continue;
+	    }
+
+	    // hr
+	    if (cap = this.rules.hr.exec(src)) {
+	      src = src.substring(cap[0].length);
+	      this.tokens.push({
+	        type: 'hr'
+	      });
+	      continue;
+	    }
+
+	    // blockquote
+	    if (cap = this.rules.blockquote.exec(src)) {
+	      src = src.substring(cap[0].length);
+
+	      this.tokens.push({
+	        type: 'blockquote_start'
+	      });
+
+	      cap = cap[0].replace(/^ *> ?/gm, '');
+
+	      // Pass `top` to keep the current
+	      // "toplevel" state. This is exactly
+	      // how markdown.pl works.
+	      this.token(cap, top, true);
+
+	      this.tokens.push({
+	        type: 'blockquote_end'
+	      });
+
+	      continue;
+	    }
+
+	    // list
+	    if (cap = this.rules.list.exec(src)) {
+	      src = src.substring(cap[0].length);
+	      bull = cap[2];
+
+	      this.tokens.push({
+	        type: 'list_start',
+	        ordered: bull.length > 1
+	      });
+
+	      // Get each top-level item.
+	      cap = cap[0].match(this.rules.item);
+
+	      next = false;
+	      l = cap.length;
+	      i = 0;
+
+	      for (; i < l; i++) {
+	        item = cap[i];
+
+	        // Remove the list item's bullet
+	        // so it is seen as the next token.
+	        space = item.length;
+	        item = item.replace(/^ *([*+-]|\d+\.) +/, '');
+
+	        // Outdent whatever the
+	        // list item contains. Hacky.
+	        if (~item.indexOf('\n ')) {
+	          space -= item.length;
+	          item = !this.options.pedantic
+	            ? item.replace(new RegExp('^ {1,' + space + '}', 'gm'), '')
+	            : item.replace(/^ {1,4}/gm, '');
+	        }
+
+	        // Determine whether the next list item belongs here.
+	        // Backpedal if it does not belong in this list.
+	        if (this.options.smartLists && i !== l - 1) {
+	          b = block.bullet.exec(cap[i + 1])[0];
+	          if (bull !== b && !(bull.length > 1 && b.length > 1)) {
+	            src = cap.slice(i + 1).join('\n') + src;
+	            i = l - 1;
+	          }
+	        }
+
+	        // Determine whether item is loose or not.
+	        // Use: /(^|\n)(?! )[^\n]+\n\n(?!\s*$)/
+	        // for discount behavior.
+	        loose = next || /\n\n(?!\s*$)/.test(item);
+	        if (i !== l - 1) {
+	          next = item.charAt(item.length - 1) === '\n';
+	          if (!loose) loose = next;
+	        }
+
+	        this.tokens.push({
+	          type: loose
+	            ? 'loose_item_start'
+	            : 'list_item_start'
+	        });
+
+	        // Recurse.
+	        this.token(item, false, bq);
+
+	        this.tokens.push({
+	          type: 'list_item_end'
+	        });
+	      }
+
+	      this.tokens.push({
+	        type: 'list_end'
+	      });
+
+	      continue;
+	    }
+
+	    // html
+	    if (cap = this.rules.html.exec(src)) {
+	      src = src.substring(cap[0].length);
+	      this.tokens.push({
+	        type: this.options.sanitize
+	          ? 'paragraph'
+	          : 'html',
+	        pre: !this.options.sanitizer
+	          && (cap[1] === 'pre' || cap[1] === 'script' || cap[1] === 'style'),
+	        text: cap[0]
+	      });
+	      continue;
+	    }
+
+	    // def
+	    if ((!bq && top) && (cap = this.rules.def.exec(src))) {
+	      src = src.substring(cap[0].length);
+	      this.tokens.links[cap[1].toLowerCase()] = {
+	        href: cap[2],
+	        title: cap[3]
+	      };
+	      continue;
+	    }
+
+	    // table (gfm)
+	    if (top && (cap = this.rules.table.exec(src))) {
+	      src = src.substring(cap[0].length);
+
+	      item = {
+	        type: 'table',
+	        header: cap[1].replace(/^ *| *\| *$/g, '').split(/ *\| */),
+	        align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
+	        cells: cap[3].replace(/(?: *\| *)?\n$/, '').split('\n')
+	      };
+
+	      for (i = 0; i < item.align.length; i++) {
+	        if (/^ *-+: *$/.test(item.align[i])) {
+	          item.align[i] = 'right';
+	        } else if (/^ *:-+: *$/.test(item.align[i])) {
+	          item.align[i] = 'center';
+	        } else if (/^ *:-+ *$/.test(item.align[i])) {
+	          item.align[i] = 'left';
+	        } else {
+	          item.align[i] = null;
+	        }
+	      }
+
+	      for (i = 0; i < item.cells.length; i++) {
+	        item.cells[i] = item.cells[i]
+	          .replace(/^ *\| *| *\| *$/g, '')
+	          .split(/ *\| */);
+	      }
+
+	      this.tokens.push(item);
+
+	      continue;
+	    }
+
+	    // top-level paragraph
+	    if (top && (cap = this.rules.paragraph.exec(src))) {
+	      src = src.substring(cap[0].length);
+	      this.tokens.push({
+	        type: 'paragraph',
+	        text: cap[1].charAt(cap[1].length - 1) === '\n'
+	          ? cap[1].slice(0, -1)
+	          : cap[1]
+	      });
+	      continue;
+	    }
+
+	    // text
+	    if (cap = this.rules.text.exec(src)) {
+	      // Top-level should never reach here.
+	      src = src.substring(cap[0].length);
+	      this.tokens.push({
+	        type: 'text',
+	        text: cap[0]
+	      });
+	      continue;
+	    }
+
+	    if (src) {
+	      throw new
+	        Error('Infinite loop on byte: ' + src.charCodeAt(0));
+	    }
+	  }
+
+	  return this.tokens;
+	};
+
+	/**
+	 * Inline-Level Grammar
+	 */
+
+	var inline = {
+	  escape: /^\\([\\`*{}\[\]()#+\-.!_>])/,
+	  autolink: /^<([^ >]+(@|:\/)[^ >]+)>/,
+	  url: noop,
+	  tag: /^<!--[\s\S]*?-->|^<\/?\w+(?:"[^"]*"|'[^']*'|[^'">])*?>/,
+	  link: /^!?\[(inside)\]\(href\)/,
+	  reflink: /^!?\[(inside)\]\s*\[([^\]]*)\]/,
+	  nolink: /^!?\[((?:\[[^\]]*\]|[^\[\]])*)\]/,
+	  strong: /^__([\s\S]+?)__(?!_)|^\*\*([\s\S]+?)\*\*(?!\*)/,
+	  em: /^\b_((?:[^_]|__)+?)_\b|^\*((?:\*\*|[\s\S])+?)\*(?!\*)/,
+	  code: /^(`+)\s*([\s\S]*?[^`])\s*\1(?!`)/,
+	  br: /^ {2,}\n(?!\s*$)/,
+	  del: noop,
+	  text: /^[\s\S]+?(?=[\\<!\[_*`]| {2,}\n|$)/
+	};
+
+	inline._inside = /(?:\[[^\]]*\]|[^\[\]]|\](?=[^\[]*\]))*/;
+	inline._href = /\s*<?([\s\S]*?)>?(?:\s+['"]([\s\S]*?)['"])?\s*/;
+
+	inline.link = replace(inline.link)
+	  ('inside', inline._inside)
+	  ('href', inline._href)
+	  ();
+
+	inline.reflink = replace(inline.reflink)
+	  ('inside', inline._inside)
+	  ();
+
+	/**
+	 * Normal Inline Grammar
+	 */
+
+	inline.normal = merge({}, inline);
+
+	/**
+	 * Pedantic Inline Grammar
+	 */
+
+	inline.pedantic = merge({}, inline.normal, {
+	  strong: /^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,
+	  em: /^_(?=\S)([\s\S]*?\S)_(?!_)|^\*(?=\S)([\s\S]*?\S)\*(?!\*)/
+	});
+
+	/**
+	 * GFM Inline Grammar
+	 */
+
+	inline.gfm = merge({}, inline.normal, {
+	  escape: replace(inline.escape)('])', '~|])')(),
+	  url: /^(https?:\/\/[^\s<]+[^<.,:;"')\]\s])/,
+	  del: /^~~(?=\S)([\s\S]*?\S)~~/,
+	  text: replace(inline.text)
+	    (']|', '~]|')
+	    ('|', '|https?://|')
+	    ()
+	});
+
+	/**
+	 * GFM + Line Breaks Inline Grammar
+	 */
+
+	inline.breaks = merge({}, inline.gfm, {
+	  br: replace(inline.br)('{2,}', '*')(),
+	  text: replace(inline.gfm.text)('{2,}', '*')()
+	});
+
+	/**
+	 * Inline Lexer & Compiler
+	 */
+
+	function InlineLexer(links, options) {
+	  this.options = options || marked.defaults;
+	  this.links = links;
+	  this.rules = inline.normal;
+	  this.renderer = this.options.renderer || new Renderer;
+	  this.renderer.options = this.options;
+
+	  if (!this.links) {
+	    throw new
+	      Error('Tokens array requires a `links` property.');
+	  }
+
+	  if (this.options.gfm) {
+	    if (this.options.breaks) {
+	      this.rules = inline.breaks;
+	    } else {
+	      this.rules = inline.gfm;
+	    }
+	  } else if (this.options.pedantic) {
+	    this.rules = inline.pedantic;
+	  }
+	}
+
+	/**
+	 * Expose Inline Rules
+	 */
+
+	InlineLexer.rules = inline;
+
+	/**
+	 * Static Lexing/Compiling Method
+	 */
+
+	InlineLexer.output = function(src, links, options) {
+	  var inline = new InlineLexer(links, options);
+	  return inline.output(src);
+	};
+
+	/**
+	 * Lexing/Compiling
+	 */
+
+	InlineLexer.prototype.output = function(src) {
+	  var out = ''
+	    , link
+	    , text
+	    , href
+	    , cap;
+
+	  while (src) {
+	    // escape
+	    if (cap = this.rules.escape.exec(src)) {
+	      src = src.substring(cap[0].length);
+	      out += cap[1];
+	      continue;
+	    }
+
+	    // autolink
+	    if (cap = this.rules.autolink.exec(src)) {
+	      src = src.substring(cap[0].length);
+	      if (cap[2] === '@') {
+	        text = cap[1].charAt(6) === ':'
+	          ? this.mangle(cap[1].substring(7))
+	          : this.mangle(cap[1]);
+	        href = this.mangle('mailto:') + text;
+	      } else {
+	        text = escape(cap[1]);
+	        href = text;
+	      }
+	      out += this.renderer.link(href, null, text);
+	      continue;
+	    }
+
+	    // url (gfm)
+	    if (!this.inLink && (cap = this.rules.url.exec(src))) {
+	      src = src.substring(cap[0].length);
+	      text = escape(cap[1]);
+	      href = text;
+	      out += this.renderer.link(href, null, text);
+	      continue;
+	    }
+
+	    // tag
+	    if (cap = this.rules.tag.exec(src)) {
+	      if (!this.inLink && /^<a /i.test(cap[0])) {
+	        this.inLink = true;
+	      } else if (this.inLink && /^<\/a>/i.test(cap[0])) {
+	        this.inLink = false;
+	      }
+	      src = src.substring(cap[0].length);
+	      out += this.options.sanitize
+	        ? this.options.sanitizer
+	          ? this.options.sanitizer(cap[0])
+	          : escape(cap[0])
+	        : cap[0]
+	      continue;
+	    }
+
+	    // link
+	    if (cap = this.rules.link.exec(src)) {
+	      src = src.substring(cap[0].length);
+	      this.inLink = true;
+	      out += this.outputLink(cap, {
+	        href: cap[2],
+	        title: cap[3]
+	      });
+	      this.inLink = false;
+	      continue;
+	    }
+
+	    // reflink, nolink
+	    if ((cap = this.rules.reflink.exec(src))
+	        || (cap = this.rules.nolink.exec(src))) {
+	      src = src.substring(cap[0].length);
+	      link = (cap[2] || cap[1]).replace(/\s+/g, ' ');
+	      link = this.links[link.toLowerCase()];
+	      if (!link || !link.href) {
+	        out += cap[0].charAt(0);
+	        src = cap[0].substring(1) + src;
+	        continue;
+	      }
+	      this.inLink = true;
+	      out += this.outputLink(cap, link);
+	      this.inLink = false;
+	      continue;
+	    }
+
+	    // strong
+	    if (cap = this.rules.strong.exec(src)) {
+	      src = src.substring(cap[0].length);
+	      out += this.renderer.strong(this.output(cap[2] || cap[1]));
+	      continue;
+	    }
+
+	    // em
+	    if (cap = this.rules.em.exec(src)) {
+	      src = src.substring(cap[0].length);
+	      out += this.renderer.em(this.output(cap[2] || cap[1]));
+	      continue;
+	    }
+
+	    // code
+	    if (cap = this.rules.code.exec(src)) {
+	      src = src.substring(cap[0].length);
+	      out += this.renderer.codespan(escape(cap[2], true));
+	      continue;
+	    }
+
+	    // br
+	    if (cap = this.rules.br.exec(src)) {
+	      src = src.substring(cap[0].length);
+	      out += this.renderer.br();
+	      continue;
+	    }
+
+	    // del (gfm)
+	    if (cap = this.rules.del.exec(src)) {
+	      src = src.substring(cap[0].length);
+	      out += this.renderer.del(this.output(cap[1]));
+	      continue;
+	    }
+
+	    // text
+	    if (cap = this.rules.text.exec(src)) {
+	      src = src.substring(cap[0].length);
+	      out += this.renderer.text(escape(this.smartypants(cap[0])));
+	      continue;
+	    }
+
+	    if (src) {
+	      throw new
+	        Error('Infinite loop on byte: ' + src.charCodeAt(0));
+	    }
+	  }
+
+	  return out;
+	};
+
+	/**
+	 * Compile Link
+	 */
+
+	InlineLexer.prototype.outputLink = function(cap, link) {
+	  var href = escape(link.href)
+	    , title = link.title ? escape(link.title) : null;
+
+	  return cap[0].charAt(0) !== '!'
+	    ? this.renderer.link(href, title, this.output(cap[1]))
+	    : this.renderer.image(href, title, escape(cap[1]));
+	};
+
+	/**
+	 * Smartypants Transformations
+	 */
+
+	InlineLexer.prototype.smartypants = function(text) {
+	  if (!this.options.smartypants) return text;
+	  return text
+	    // em-dashes
+	    .replace(/---/g, '\u2014')
+	    // en-dashes
+	    .replace(/--/g, '\u2013')
+	    // opening singles
+	    .replace(/(^|[-\u2014/(\[{"\s])'/g, '$1\u2018')
+	    // closing singles & apostrophes
+	    .replace(/'/g, '\u2019')
+	    // opening doubles
+	    .replace(/(^|[-\u2014/(\[{\u2018\s])"/g, '$1\u201c')
+	    // closing doubles
+	    .replace(/"/g, '\u201d')
+	    // ellipses
+	    .replace(/\.{3}/g, '\u2026');
+	};
+
+	/**
+	 * Mangle Links
+	 */
+
+	InlineLexer.prototype.mangle = function(text) {
+	  if (!this.options.mangle) return text;
+	  var out = ''
+	    , l = text.length
+	    , i = 0
+	    , ch;
+
+	  for (; i < l; i++) {
+	    ch = text.charCodeAt(i);
+	    if (Math.random() > 0.5) {
+	      ch = 'x' + ch.toString(16);
+	    }
+	    out += '&#' + ch + ';';
+	  }
+
+	  return out;
+	};
+
+	/**
+	 * Renderer
+	 */
+
+	function Renderer(options) {
+	  this.options = options || {};
+	}
+
+	Renderer.prototype.code = function(code, lang, escaped) {
+	  if (this.options.highlight) {
+	    var out = this.options.highlight(code, lang);
+	    if (out != null && out !== code) {
+	      escaped = true;
+	      code = out;
+	    }
+	  }
+
+	  if (!lang) {
+	    return '<pre><code>'
+	      + (escaped ? code : escape(code, true))
+	      + '\n</code></pre>';
+	  }
+
+	  return '<pre><code class="'
+	    + this.options.langPrefix
+	    + escape(lang, true)
+	    + '">'
+	    + (escaped ? code : escape(code, true))
+	    + '\n</code></pre>\n';
+	};
+
+	Renderer.prototype.blockquote = function(quote) {
+	  return '<blockquote>\n' + quote + '</blockquote>\n';
+	};
+
+	Renderer.prototype.html = function(html) {
+	  return html;
+	};
+
+	Renderer.prototype.heading = function(text, level, raw) {
+	  return '<h'
+	    + level
+	    + ' id="'
+	    + this.options.headerPrefix
+	    + raw.toLowerCase().replace(/[^\w]+/g, '-')
+	    + '">'
+	    + text
+	    + '</h'
+	    + level
+	    + '>\n';
+	};
+
+	Renderer.prototype.hr = function() {
+	  return this.options.xhtml ? '<hr/>\n' : '<hr>\n';
+	};
+
+	Renderer.prototype.list = function(body, ordered) {
+	  var type = ordered ? 'ol' : 'ul';
+	  return '<' + type + '>\n' + body + '</' + type + '>\n';
+	};
+
+	Renderer.prototype.listitem = function(text) {
+	  return '<li>' + text + '</li>\n';
+	};
+
+	Renderer.prototype.paragraph = function(text) {
+	  return '<p>' + text + '</p>\n';
+	};
+
+	Renderer.prototype.table = function(header, body) {
+	  return '<table>\n'
+	    + '<thead>\n'
+	    + header
+	    + '</thead>\n'
+	    + '<tbody>\n'
+	    + body
+	    + '</tbody>\n'
+	    + '</table>\n';
+	};
+
+	Renderer.prototype.tablerow = function(content) {
+	  return '<tr>\n' + content + '</tr>\n';
+	};
+
+	Renderer.prototype.tablecell = function(content, flags) {
+	  var type = flags.header ? 'th' : 'td';
+	  var tag = flags.align
+	    ? '<' + type + ' style="text-align:' + flags.align + '">'
+	    : '<' + type + '>';
+	  return tag + content + '</' + type + '>\n';
+	};
+
+	// span level renderer
+	Renderer.prototype.strong = function(text) {
+	  return '<strong>' + text + '</strong>';
+	};
+
+	Renderer.prototype.em = function(text) {
+	  return '<em>' + text + '</em>';
+	};
+
+	Renderer.prototype.codespan = function(text) {
+	  return '<code>' + text + '</code>';
+	};
+
+	Renderer.prototype.br = function() {
+	  return this.options.xhtml ? '<br/>' : '<br>';
+	};
+
+	Renderer.prototype.del = function(text) {
+	  return '<del>' + text + '</del>';
+	};
+
+	Renderer.prototype.link = function(href, title, text) {
+	  if (this.options.sanitize) {
+	    try {
+	      var prot = decodeURIComponent(unescape(href))
+	        .replace(/[^\w:]/g, '')
+	        .toLowerCase();
+	    } catch (e) {
+	      return '';
+	    }
+	    if (prot.indexOf('javascript:') === 0 || prot.indexOf('vbscript:') === 0) {
+	      return '';
+	    }
+	  }
+	  var out = '<a href="' + href + '"';
+	  if (title) {
+	    out += ' title="' + title + '"';
+	  }
+	  out += '>' + text + '</a>';
+	  return out;
+	};
+
+	Renderer.prototype.image = function(href, title, text) {
+	  var out = '<img src="' + href + '" alt="' + text + '"';
+	  if (title) {
+	    out += ' title="' + title + '"';
+	  }
+	  out += this.options.xhtml ? '/>' : '>';
+	  return out;
+	};
+
+	Renderer.prototype.text = function(text) {
+	  return text;
+	};
+
+	/**
+	 * Parsing & Compiling
+	 */
+
+	function Parser(options) {
+	  this.tokens = [];
+	  this.token = null;
+	  this.options = options || marked.defaults;
+	  this.options.renderer = this.options.renderer || new Renderer;
+	  this.renderer = this.options.renderer;
+	  this.renderer.options = this.options;
+	}
+
+	/**
+	 * Static Parse Method
+	 */
+
+	Parser.parse = function(src, options, renderer) {
+	  var parser = new Parser(options, renderer);
+	  return parser.parse(src);
+	};
+
+	/**
+	 * Parse Loop
+	 */
+
+	Parser.prototype.parse = function(src) {
+	  this.inline = new InlineLexer(src.links, this.options, this.renderer);
+	  this.tokens = src.reverse();
+
+	  var out = '';
+	  while (this.next()) {
+	    out += this.tok();
+	  }
+
+	  return out;
+	};
+
+	/**
+	 * Next Token
+	 */
+
+	Parser.prototype.next = function() {
+	  return this.token = this.tokens.pop();
+	};
+
+	/**
+	 * Preview Next Token
+	 */
+
+	Parser.prototype.peek = function() {
+	  return this.tokens[this.tokens.length - 1] || 0;
+	};
+
+	/**
+	 * Parse Text Tokens
+	 */
+
+	Parser.prototype.parseText = function() {
+	  var body = this.token.text;
+
+	  while (this.peek().type === 'text') {
+	    body += '\n' + this.next().text;
+	  }
+
+	  return this.inline.output(body);
+	};
+
+	/**
+	 * Parse Current Token
+	 */
+
+	Parser.prototype.tok = function() {
+	  switch (this.token.type) {
+	    case 'space': {
+	      return '';
+	    }
+	    case 'hr': {
+	      return this.renderer.hr();
+	    }
+	    case 'heading': {
+	      return this.renderer.heading(
+	        this.inline.output(this.token.text),
+	        this.token.depth,
+	        this.token.text);
+	    }
+	    case 'code': {
+	      return this.renderer.code(this.token.text,
+	        this.token.lang,
+	        this.token.escaped);
+	    }
+	    case 'table': {
+	      var header = ''
+	        , body = ''
+	        , i
+	        , row
+	        , cell
+	        , flags
+	        , j;
+
+	      // header
+	      cell = '';
+	      for (i = 0; i < this.token.header.length; i++) {
+	        flags = { header: true, align: this.token.align[i] };
+	        cell += this.renderer.tablecell(
+	          this.inline.output(this.token.header[i]),
+	          { header: true, align: this.token.align[i] }
+	        );
+	      }
+	      header += this.renderer.tablerow(cell);
+
+	      for (i = 0; i < this.token.cells.length; i++) {
+	        row = this.token.cells[i];
+
+	        cell = '';
+	        for (j = 0; j < row.length; j++) {
+	          cell += this.renderer.tablecell(
+	            this.inline.output(row[j]),
+	            { header: false, align: this.token.align[j] }
+	          );
+	        }
+
+	        body += this.renderer.tablerow(cell);
+	      }
+	      return this.renderer.table(header, body);
+	    }
+	    case 'blockquote_start': {
+	      var body = '';
+
+	      while (this.next().type !== 'blockquote_end') {
+	        body += this.tok();
+	      }
+
+	      return this.renderer.blockquote(body);
+	    }
+	    case 'list_start': {
+	      var body = ''
+	        , ordered = this.token.ordered;
+
+	      while (this.next().type !== 'list_end') {
+	        body += this.tok();
+	      }
+
+	      return this.renderer.list(body, ordered);
+	    }
+	    case 'list_item_start': {
+	      var body = '';
+
+	      while (this.next().type !== 'list_item_end') {
+	        body += this.token.type === 'text'
+	          ? this.parseText()
+	          : this.tok();
+	      }
+
+	      return this.renderer.listitem(body);
+	    }
+	    case 'loose_item_start': {
+	      var body = '';
+
+	      while (this.next().type !== 'list_item_end') {
+	        body += this.tok();
+	      }
+
+	      return this.renderer.listitem(body);
+	    }
+	    case 'html': {
+	      var html = !this.token.pre && !this.options.pedantic
+	        ? this.inline.output(this.token.text)
+	        : this.token.text;
+	      return this.renderer.html(html);
+	    }
+	    case 'paragraph': {
+	      return this.renderer.paragraph(this.inline.output(this.token.text));
+	    }
+	    case 'text': {
+	      return this.renderer.paragraph(this.parseText());
+	    }
+	  }
+	};
+
+	/**
+	 * Helpers
+	 */
+
+	function escape(html, encode) {
+	  return html
+	    .replace(!encode ? /&(?!#?\w+;)/g : /&/g, '&amp;')
+	    .replace(/</g, '&lt;')
+	    .replace(/>/g, '&gt;')
+	    .replace(/"/g, '&quot;')
+	    .replace(/'/g, '&#39;');
+	}
+
+	function unescape(html) {
+		// explicitly match decimal, hex, and named HTML entities 
+	  return html.replace(/&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/g, function(_, n) {
+	    n = n.toLowerCase();
+	    if (n === 'colon') return ':';
+	    if (n.charAt(0) === '#') {
+	      return n.charAt(1) === 'x'
+	        ? String.fromCharCode(parseInt(n.substring(2), 16))
+	        : String.fromCharCode(+n.substring(1));
+	    }
+	    return '';
+	  });
+	}
+
+	function replace(regex, opt) {
+	  regex = regex.source;
+	  opt = opt || '';
+	  return function self(name, val) {
+	    if (!name) return new RegExp(regex, opt);
+	    val = val.source || val;
+	    val = val.replace(/(^|[^\[])\^/g, '$1');
+	    regex = regex.replace(name, val);
+	    return self;
+	  };
+	}
+
+	function noop() {}
+	noop.exec = noop;
+
+	function merge(obj) {
+	  var i = 1
+	    , target
+	    , key;
+
+	  for (; i < arguments.length; i++) {
+	    target = arguments[i];
+	    for (key in target) {
+	      if (Object.prototype.hasOwnProperty.call(target, key)) {
+	        obj[key] = target[key];
+	      }
+	    }
+	  }
+
+	  return obj;
+	}
+
+
+	/**
+	 * Marked
+	 */
+
+	function marked(src, opt, callback) {
+	  if (callback || typeof opt === 'function') {
+	    if (!callback) {
+	      callback = opt;
+	      opt = null;
+	    }
+
+	    opt = merge({}, marked.defaults, opt || {});
+
+	    var highlight = opt.highlight
+	      , tokens
+	      , pending
+	      , i = 0;
+
+	    try {
+	      tokens = Lexer.lex(src, opt)
+	    } catch (e) {
+	      return callback(e);
+	    }
+
+	    pending = tokens.length;
+
+	    var done = function(err) {
+	      if (err) {
+	        opt.highlight = highlight;
+	        return callback(err);
+	      }
+
+	      var out;
+
+	      try {
+	        out = Parser.parse(tokens, opt);
+	      } catch (e) {
+	        err = e;
+	      }
+
+	      opt.highlight = highlight;
+
+	      return err
+	        ? callback(err)
+	        : callback(null, out);
+	    };
+
+	    if (!highlight || highlight.length < 3) {
+	      return done();
+	    }
+
+	    delete opt.highlight;
+
+	    if (!pending) return done();
+
+	    for (; i < tokens.length; i++) {
+	      (function(token) {
+	        if (token.type !== 'code') {
+	          return --pending || done();
+	        }
+	        return highlight(token.text, token.lang, function(err, code) {
+	          if (err) return done(err);
+	          if (code == null || code === token.text) {
+	            return --pending || done();
+	          }
+	          token.text = code;
+	          token.escaped = true;
+	          --pending || done();
+	        });
+	      })(tokens[i]);
+	    }
+
+	    return;
+	  }
+	  try {
+	    if (opt) opt = merge({}, marked.defaults, opt);
+	    return Parser.parse(Lexer.lex(src, opt), opt);
+	  } catch (e) {
+	    e.message += '\nPlease report this to https://github.com/chjj/marked.';
+	    if ((opt || marked.defaults).silent) {
+	      return '<p>An error occured:</p><pre>'
+	        + escape(e.message + '', true)
+	        + '</pre>';
+	    }
+	    throw e;
+	  }
+	}
+
+	/**
+	 * Options
+	 */
+
+	marked.options =
+	marked.setOptions = function(opt) {
+	  merge(marked.defaults, opt);
+	  return marked;
+	};
+
+	marked.defaults = {
+	  gfm: true,
+	  tables: true,
+	  breaks: false,
+	  pedantic: false,
+	  sanitize: false,
+	  sanitizer: null,
+	  mangle: true,
+	  smartLists: false,
+	  silent: false,
+	  highlight: null,
+	  langPrefix: 'lang-',
+	  smartypants: false,
+	  headerPrefix: '',
+	  renderer: new Renderer,
+	  xhtml: false
+	};
+
+	/**
+	 * Expose
+	 */
+
+	marked.Parser = Parser;
+	marked.parser = Parser.parse;
+
+	marked.Renderer = Renderer;
+
+	marked.Lexer = Lexer;
+	marked.lexer = Lexer.lex;
+
+	marked.InlineLexer = InlineLexer;
+	marked.inlineLexer = InlineLexer.output;
+
+	marked.parse = marked;
+
+	if (true) {
+	  module.exports = marked;
+	} else if (typeof define === 'function' && define.amd) {
+	  define(function() { return marked; });
+	} else {
+	  this.marked = marked;
+	}
+
+	}).call(function() {
+	  return this || (typeof window !== 'undefined' ? window : global);
+	}());
+
+	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
+
+/***/ },
+/* 267 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// CodeMirror, copyright (c) by Marijn Haverbeke and others
+	// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+	// This is CodeMirror (http://codemirror.net), a code editor
+	// implemented in JavaScript on top of the browser's DOM.
+	//
+	// You can find some technical background for some of the code below
+	// at http://marijnhaverbeke.nl/blog/#cm-internals .
+
+	(function (global, factory) {
+	   true ? module.exports = factory() :
+	  typeof define === 'function' && define.amd ? define(factory) :
+	  (global.CodeMirror = factory());
+	}(this, (function () { 'use strict';
+
+	// Kludges for bugs and behavior differences that can't be feature
+	// detected are enabled based on userAgent etc sniffing.
+	var userAgent = navigator.userAgent
+	var platform = navigator.platform
+
+	var gecko = /gecko\/\d/i.test(userAgent)
+	var ie_upto10 = /MSIE \d/.test(userAgent)
+	var ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(userAgent)
+	var ie = ie_upto10 || ie_11up
+	var ie_version = ie && (ie_upto10 ? document.documentMode || 6 : ie_11up[1])
+	var webkit = /WebKit\//.test(userAgent)
+	var qtwebkit = webkit && /Qt\/\d+\.\d+/.test(userAgent)
+	var chrome = /Chrome\//.test(userAgent)
+	var presto = /Opera\//.test(userAgent)
+	var safari = /Apple Computer/.test(navigator.vendor)
+	var mac_geMountainLion = /Mac OS X 1\d\D([8-9]|\d\d)\D/.test(userAgent)
+	var phantom = /PhantomJS/.test(userAgent)
+
+	var ios = /AppleWebKit/.test(userAgent) && /Mobile\/\w+/.test(userAgent)
+	// This is woefully incomplete. Suggestions for alternative methods welcome.
+	var mobile = ios || /Android|webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(userAgent)
+	var mac = ios || /Mac/.test(platform)
+	var chromeOS = /\bCrOS\b/.test(userAgent)
+	var windows = /win/i.test(platform)
+
+	var presto_version = presto && userAgent.match(/Version\/(\d*\.\d*)/)
+	if (presto_version) { presto_version = Number(presto_version[1]) }
+	if (presto_version && presto_version >= 15) { presto = false; webkit = true }
+	// Some browsers use the wrong event properties to signal cmd/ctrl on OS X
+	var flipCtrlCmd = mac && (qtwebkit || presto && (presto_version == null || presto_version < 12.11))
+	var captureRightClick = gecko || (ie && ie_version >= 9)
+
+	function classTest(cls) { return new RegExp("(^|\\s)" + cls + "(?:$|\\s)\\s*") }
+
+	var rmClass = function(node, cls) {
+	  var current = node.className
+	  var match = classTest(cls).exec(current)
+	  if (match) {
+	    var after = current.slice(match.index + match[0].length)
+	    node.className = current.slice(0, match.index) + (after ? match[1] + after : "")
+	  }
+	}
+
+	function removeChildren(e) {
+	  for (var count = e.childNodes.length; count > 0; --count)
+	    { e.removeChild(e.firstChild) }
+	  return e
+	}
+
+	function removeChildrenAndAdd(parent, e) {
+	  return removeChildren(parent).appendChild(e)
+	}
+
+	function elt(tag, content, className, style) {
+	  var e = document.createElement(tag)
+	  if (className) { e.className = className }
+	  if (style) { e.style.cssText = style }
+	  if (typeof content == "string") { e.appendChild(document.createTextNode(content)) }
+	  else if (content) { for (var i = 0; i < content.length; ++i) { e.appendChild(content[i]) } }
+	  return e
+	}
+
+	var range
+	if (document.createRange) { range = function(node, start, end, endNode) {
+	  var r = document.createRange()
+	  r.setEnd(endNode || node, end)
+	  r.setStart(node, start)
+	  return r
+	} }
+	else { range = function(node, start, end) {
+	  var r = document.body.createTextRange()
+	  try { r.moveToElementText(node.parentNode) }
+	  catch(e) { return r }
+	  r.collapse(true)
+	  r.moveEnd("character", end)
+	  r.moveStart("character", start)
+	  return r
+	} }
+
+	function contains(parent, child) {
+	  if (child.nodeType == 3) // Android browser always returns false when child is a textnode
+	    { child = child.parentNode }
+	  if (parent.contains)
+	    { return parent.contains(child) }
+	  do {
+	    if (child.nodeType == 11) { child = child.host }
+	    if (child == parent) { return true }
+	  } while (child = child.parentNode)
+	}
+
+	function activeElt() {
+	  // IE and Edge may throw an "Unspecified Error" when accessing document.activeElement.
+	  // IE < 10 will throw when accessed while the page is loading or in an iframe.
+	  // IE > 9 and Edge will throw when accessed in an iframe if document.body is unavailable.
+	  var activeElement
+	  try {
+	    activeElement = document.activeElement
+	  } catch(e) {
+	    activeElement = document.body || null
+	  }
+	  while (activeElement && activeElement.root && activeElement.root.activeElement)
+	    { activeElement = activeElement.root.activeElement }
+	  return activeElement
+	}
+
+	function addClass(node, cls) {
+	  var current = node.className
+	  if (!classTest(cls).test(current)) { node.className += (current ? " " : "") + cls }
+	}
+	function joinClasses(a, b) {
+	  var as = a.split(" ")
+	  for (var i = 0; i < as.length; i++)
+	    { if (as[i] && !classTest(as[i]).test(b)) { b += " " + as[i] } }
+	  return b
+	}
+
+	var selectInput = function(node) { node.select() }
+	if (ios) // Mobile Safari apparently has a bug where select() is broken.
+	  { selectInput = function(node) { node.selectionStart = 0; node.selectionEnd = node.value.length } }
+	else if (ie) // Suppress mysterious IE10 errors
+	  { selectInput = function(node) { try { node.select() } catch(_e) {} } }
+
+	function bind(f) {
+	  var args = Array.prototype.slice.call(arguments, 1)
+	  return function(){return f.apply(null, args)}
+	}
+
+	function copyObj(obj, target, overwrite) {
+	  if (!target) { target = {} }
+	  for (var prop in obj)
+	    { if (obj.hasOwnProperty(prop) && (overwrite !== false || !target.hasOwnProperty(prop)))
+	      { target[prop] = obj[prop] } }
+	  return target
+	}
+
+	// Counts the column offset in a string, taking tabs into account.
+	// Used mostly to find indentation.
+	function countColumn(string, end, tabSize, startIndex, startValue) {
+	  if (end == null) {
+	    end = string.search(/[^\s\u00a0]/)
+	    if (end == -1) { end = string.length }
+	  }
+	  for (var i = startIndex || 0, n = startValue || 0;;) {
+	    var nextTab = string.indexOf("\t", i)
+	    if (nextTab < 0 || nextTab >= end)
+	      { return n + (end - i) }
+	    n += nextTab - i
+	    n += tabSize - (n % tabSize)
+	    i = nextTab + 1
+	  }
+	}
+
+	function Delayed() {this.id = null}
+	Delayed.prototype.set = function(ms, f) {
+	  clearTimeout(this.id)
+	  this.id = setTimeout(f, ms)
+	}
+
+	function indexOf(array, elt) {
+	  for (var i = 0; i < array.length; ++i)
+	    { if (array[i] == elt) { return i } }
+	  return -1
+	}
+
+	// Number of pixels added to scroller and sizer to hide scrollbar
+	var scrollerGap = 30
+
+	// Returned or thrown by various protocols to signal 'I'm not
+	// handling this'.
+	var Pass = {toString: function(){return "CodeMirror.Pass"}}
+
+	// Reused option objects for setSelection & friends
+	var sel_dontScroll = {scroll: false};
+	var sel_mouse = {origin: "*mouse"};
+	var sel_move = {origin: "+move"};
+	// The inverse of countColumn -- find the offset that corresponds to
+	// a particular column.
+	function findColumn(string, goal, tabSize) {
+	  for (var pos = 0, col = 0;;) {
+	    var nextTab = string.indexOf("\t", pos)
+	    if (nextTab == -1) { nextTab = string.length }
+	    var skipped = nextTab - pos
+	    if (nextTab == string.length || col + skipped >= goal)
+	      { return pos + Math.min(skipped, goal - col) }
+	    col += nextTab - pos
+	    col += tabSize - (col % tabSize)
+	    pos = nextTab + 1
+	    if (col >= goal) { return pos }
+	  }
+	}
+
+	var spaceStrs = [""]
+	function spaceStr(n) {
+	  while (spaceStrs.length <= n)
+	    { spaceStrs.push(lst(spaceStrs) + " ") }
+	  return spaceStrs[n]
+	}
+
+	function lst(arr) { return arr[arr.length-1] }
+
+	function map(array, f) {
+	  var out = []
+	  for (var i = 0; i < array.length; i++) { out[i] = f(array[i], i) }
+	  return out
+	}
+
+	function insertSorted(array, value, score) {
+	  var pos = 0, priority = score(value)
+	  while (pos < array.length && score(array[pos]) <= priority) { pos++ }
+	  array.splice(pos, 0, value)
+	}
+
+	function nothing() {}
+
+	function createObj(base, props) {
+	  var inst
+	  if (Object.create) {
+	    inst = Object.create(base)
+	  } else {
+	    nothing.prototype = base
+	    inst = new nothing()
+	  }
+	  if (props) { copyObj(props, inst) }
+	  return inst
+	}
+
+	var nonASCIISingleCaseWordChar = /[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/
+	function isWordCharBasic(ch) {
+	  return /\w/.test(ch) || ch > "\x80" &&
+	    (ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch))
+	}
+	function isWordChar(ch, helper) {
+	  if (!helper) { return isWordCharBasic(ch) }
+	  if (helper.source.indexOf("\\w") > -1 && isWordCharBasic(ch)) { return true }
+	  return helper.test(ch)
+	}
+
+	function isEmpty(obj) {
+	  for (var n in obj) { if (obj.hasOwnProperty(n) && obj[n]) { return false } }
+	  return true
+	}
+
+	// Extending unicode characters. A series of a non-extending char +
+	// any number of extending chars is treated as a single unit as far
+	// as editing and measuring is concerned. This is not fully correct,
+	// since some scripts/fonts/browsers also treat other configurations
+	// of code points as a group.
+	var extendingChars = /[\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u065e\u0670\u06d6-\u06dc\u06de-\u06e4\u06e7\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0900-\u0902\u093c\u0941-\u0948\u094d\u0951-\u0955\u0962\u0963\u0981\u09bc\u09be\u09c1-\u09c4\u09cd\u09d7\u09e2\u09e3\u0a01\u0a02\u0a3c\u0a41\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a70\u0a71\u0a75\u0a81\u0a82\u0abc\u0ac1-\u0ac5\u0ac7\u0ac8\u0acd\u0ae2\u0ae3\u0b01\u0b3c\u0b3e\u0b3f\u0b41-\u0b44\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b82\u0bbe\u0bc0\u0bcd\u0bd7\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0cbc\u0cbf\u0cc2\u0cc6\u0ccc\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0d3e\u0d41-\u0d44\u0d4d\u0d57\u0d62\u0d63\u0dca\u0dcf\u0dd2-\u0dd4\u0dd6\u0ddf\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0f18\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86\u0f87\u0f90-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039\u103a\u103d\u103e\u1058\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085\u1086\u108d\u109d\u135f\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd\u180b-\u180d\u18a9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193b\u1a17\u1a18\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1b00-\u1b03\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80\u1b81\u1ba2-\u1ba5\u1ba8\u1ba9\u1c2c-\u1c33\u1c36\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1dc0-\u1de6\u1dfd-\u1dff\u200c\u200d\u20d0-\u20f0\u2cef-\u2cf1\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua66f-\ua672\ua67c\ua67d\ua6f0\ua6f1\ua802\ua806\ua80b\ua825\ua826\ua8c4\ua8e0-\ua8f1\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc\uaa29-\uaa2e\uaa31\uaa32\uaa35\uaa36\uaa43\uaa4c\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uabe5\uabe8\uabed\udc00-\udfff\ufb1e\ufe00-\ufe0f\ufe20-\ufe26\uff9e\uff9f]/
+	function isExtendingChar(ch) { return ch.charCodeAt(0) >= 768 && extendingChars.test(ch) }
+
+	// The display handles the DOM integration, both for input reading
+	// and content drawing. It holds references to DOM nodes and
+	// display-related state.
+
+	function Display(place, doc, input) {
+	  var d = this
+	  this.input = input
+
+	  // Covers bottom-right square when both scrollbars are present.
+	  d.scrollbarFiller = elt("div", null, "CodeMirror-scrollbar-filler")
+	  d.scrollbarFiller.setAttribute("cm-not-content", "true")
+	  // Covers bottom of gutter when coverGutterNextToScrollbar is on
+	  // and h scrollbar is present.
+	  d.gutterFiller = elt("div", null, "CodeMirror-gutter-filler")
+	  d.gutterFiller.setAttribute("cm-not-content", "true")
+	  // Will contain the actual code, positioned to cover the viewport.
+	  d.lineDiv = elt("div", null, "CodeMirror-code")
+	  // Elements are added to these to represent selection and cursors.
+	  d.selectionDiv = elt("div", null, null, "position: relative; z-index: 1")
+	  d.cursorDiv = elt("div", null, "CodeMirror-cursors")
+	  // A visibility: hidden element used to find the size of things.
+	  d.measure = elt("div", null, "CodeMirror-measure")
+	  // When lines outside of the viewport are measured, they are drawn in this.
+	  d.lineMeasure = elt("div", null, "CodeMirror-measure")
+	  // Wraps everything that needs to exist inside the vertically-padded coordinate system
+	  d.lineSpace = elt("div", [d.measure, d.lineMeasure, d.selectionDiv, d.cursorDiv, d.lineDiv],
+	                    null, "position: relative; outline: none")
+	  // Moved around its parent to cover visible view.
+	  d.mover = elt("div", [elt("div", [d.lineSpace], "CodeMirror-lines")], null, "position: relative")
+	  // Set to the height of the document, allowing scrolling.
+	  d.sizer = elt("div", [d.mover], "CodeMirror-sizer")
+	  d.sizerWidth = null
+	  // Behavior of elts with overflow: auto and padding is
+	  // inconsistent across browsers. This is used to ensure the
+	  // scrollable area is big enough.
+	  d.heightForcer = elt("div", null, null, "position: absolute; height: " + scrollerGap + "px; width: 1px;")
+	  // Will contain the gutters, if any.
+	  d.gutters = elt("div", null, "CodeMirror-gutters")
+	  d.lineGutter = null
+	  // Actual scrollable element.
+	  d.scroller = elt("div", [d.sizer, d.heightForcer, d.gutters], "CodeMirror-scroll")
+	  d.scroller.setAttribute("tabIndex", "-1")
+	  // The element in which the editor lives.
+	  d.wrapper = elt("div", [d.scrollbarFiller, d.gutterFiller, d.scroller], "CodeMirror")
+
+	  // Work around IE7 z-index bug (not perfect, hence IE7 not really being supported)
+	  if (ie && ie_version < 8) { d.gutters.style.zIndex = -1; d.scroller.style.paddingRight = 0 }
+	  if (!webkit && !(gecko && mobile)) { d.scroller.draggable = true }
+
+	  if (place) {
+	    if (place.appendChild) { place.appendChild(d.wrapper) }
+	    else { place(d.wrapper) }
+	  }
+
+	  // Current rendered range (may be bigger than the view window).
+	  d.viewFrom = d.viewTo = doc.first
+	  d.reportedViewFrom = d.reportedViewTo = doc.first
+	  // Information about the rendered lines.
+	  d.view = []
+	  d.renderedView = null
+	  // Holds info about a single rendered line when it was rendered
+	  // for measurement, while not in view.
+	  d.externalMeasured = null
+	  // Empty space (in pixels) above the view
+	  d.viewOffset = 0
+	  d.lastWrapHeight = d.lastWrapWidth = 0
+	  d.updateLineNumbers = null
+
+	  d.nativeBarWidth = d.barHeight = d.barWidth = 0
+	  d.scrollbarsClipped = false
+
+	  // Used to only resize the line number gutter when necessary (when
+	  // the amount of lines crosses a boundary that makes its width change)
+	  d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null
+	  // Set to true when a non-horizontal-scrolling line widget is
+	  // added. As an optimization, line widget aligning is skipped when
+	  // this is false.
+	  d.alignWidgets = false
+
+	  d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null
+
+	  // Tracks the maximum line length so that the horizontal scrollbar
+	  // can be kept static when scrolling.
+	  d.maxLine = null
+	  d.maxLineLength = 0
+	  d.maxLineChanged = false
+
+	  // Used for measuring wheel scrolling granularity
+	  d.wheelDX = d.wheelDY = d.wheelStartX = d.wheelStartY = null
+
+	  // True when shift is held down.
+	  d.shift = false
+
+	  // Used to track whether anything happened since the context menu
+	  // was opened.
+	  d.selForContextMenu = null
+
+	  d.activeTouch = null
+
+	  input.init(d)
+	}
+
+	// Find the line object corresponding to the given line number.
+	function getLine(doc, n) {
+	  n -= doc.first
+	  if (n < 0 || n >= doc.size) { throw new Error("There is no line " + (n + doc.first) + " in the document.") }
+	  var chunk = doc
+	  while (!chunk.lines) {
+	    for (var i = 0;; ++i) {
+	      var child = chunk.children[i], sz = child.chunkSize()
+	      if (n < sz) { chunk = child; break }
+	      n -= sz
+	    }
+	  }
+	  return chunk.lines[n]
+	}
+
+	// Get the part of a document between two positions, as an array of
+	// strings.
+	function getBetween(doc, start, end) {
+	  var out = [], n = start.line
+	  doc.iter(start.line, end.line + 1, function (line) {
+	    var text = line.text
+	    if (n == end.line) { text = text.slice(0, end.ch) }
+	    if (n == start.line) { text = text.slice(start.ch) }
+	    out.push(text)
+	    ++n
+	  })
+	  return out
+	}
+	// Get the lines between from and to, as array of strings.
+	function getLines(doc, from, to) {
+	  var out = []
+	  doc.iter(from, to, function (line) { out.push(line.text) }) // iter aborts when callback returns truthy value
+	  return out
+	}
+
+	// Update the height of a line, propagating the height change
+	// upwards to parent nodes.
+	function updateLineHeight(line, height) {
+	  var diff = height - line.height
+	  if (diff) { for (var n = line; n; n = n.parent) { n.height += diff } }
+	}
+
+	// Given a line object, find its line number by walking up through
+	// its parent links.
+	function lineNo(line) {
+	  if (line.parent == null) { return null }
+	  var cur = line.parent, no = indexOf(cur.lines, line)
+	  for (var chunk = cur.parent; chunk; cur = chunk, chunk = chunk.parent) {
+	    for (var i = 0;; ++i) {
+	      if (chunk.children[i] == cur) { break }
+	      no += chunk.children[i].chunkSize()
+	    }
+	  }
+	  return no + cur.first
+	}
+
+	// Find the line at the given vertical position, using the height
+	// information in the document tree.
+	function lineAtHeight(chunk, h) {
+	  var n = chunk.first
+	  outer: do {
+	    for (var i$1 = 0; i$1 < chunk.children.length; ++i$1) {
+	      var child = chunk.children[i$1], ch = child.height
+	      if (h < ch) { chunk = child; continue outer }
+	      h -= ch
+	      n += child.chunkSize()
+	    }
+	    return n
+	  } while (!chunk.lines)
+	  var i = 0
+	  for (; i < chunk.lines.length; ++i) {
+	    var line = chunk.lines[i], lh = line.height
+	    if (h < lh) { break }
+	    h -= lh
+	  }
+	  return n + i
+	}
+
+	function isLine(doc, l) {return l >= doc.first && l < doc.first + doc.size}
+
+	function lineNumberFor(options, i) {
+	  return String(options.lineNumberFormatter(i + options.firstLineNumber))
+	}
+
+	// A Pos instance represents a position within the text.
+	function Pos (line, ch) {
+	  if (!(this instanceof Pos)) { return new Pos(line, ch) }
+	  this.line = line; this.ch = ch
+	}
+
+	// Compare two positions, return 0 if they are the same, a negative
+	// number when a is less, and a positive number otherwise.
+	function cmp(a, b) { return a.line - b.line || a.ch - b.ch }
+
+	function copyPos(x) {return Pos(x.line, x.ch)}
+	function maxPos(a, b) { return cmp(a, b) < 0 ? b : a }
+	function minPos(a, b) { return cmp(a, b) < 0 ? a : b }
+
+	// Most of the external API clips given positions to make sure they
+	// actually exist within the document.
+	function clipLine(doc, n) {return Math.max(doc.first, Math.min(n, doc.first + doc.size - 1))}
+	function clipPos(doc, pos) {
+	  if (pos.line < doc.first) { return Pos(doc.first, 0) }
+	  var last = doc.first + doc.size - 1
+	  if (pos.line > last) { return Pos(last, getLine(doc, last).text.length) }
+	  return clipToLen(pos, getLine(doc, pos.line).text.length)
+	}
+	function clipToLen(pos, linelen) {
+	  var ch = pos.ch
+	  if (ch == null || ch > linelen) { return Pos(pos.line, linelen) }
+	  else if (ch < 0) { return Pos(pos.line, 0) }
+	  else { return pos }
+	}
+	function clipPosArray(doc, array) {
+	  var out = []
+	  for (var i = 0; i < array.length; i++) { out[i] = clipPos(doc, array[i]) }
+	  return out
+	}
+
+	// Optimize some code when these features are not used.
+	var sawReadOnlySpans = false;
+	var sawCollapsedSpans = false;
+	function seeReadOnlySpans() {
+	  sawReadOnlySpans = true
+	}
+
+	function seeCollapsedSpans() {
+	  sawCollapsedSpans = true
+	}
+
+	// TEXTMARKER SPANS
+
+	function MarkedSpan(marker, from, to) {
+	  this.marker = marker
+	  this.from = from; this.to = to
+	}
+
+	// Search an array of spans for a span matching the given marker.
+	function getMarkedSpanFor(spans, marker) {
+	  if (spans) { for (var i = 0; i < spans.length; ++i) {
+	    var span = spans[i]
+	    if (span.marker == marker) { return span }
+	  } }
+	}
+	// Remove a span from an array, returning undefined if no spans are
+	// left (we don't store arrays for lines without spans).
+	function removeMarkedSpan(spans, span) {
+	  var r
+	  for (var i = 0; i < spans.length; ++i)
+	    { if (spans[i] != span) { (r || (r = [])).push(spans[i]) } }
+	  return r
+	}
+	// Add a span to a line.
+	function addMarkedSpan(line, span) {
+	  line.markedSpans = line.markedSpans ? line.markedSpans.concat([span]) : [span]
+	  span.marker.attachLine(line)
+	}
+
+	// Used for the algorithm that adjusts markers for a change in the
+	// document. These functions cut an array of spans at a given
+	// character position, returning an array of remaining chunks (or
+	// undefined if nothing remains).
+	function markedSpansBefore(old, startCh, isInsert) {
+	  var nw
+	  if (old) { for (var i = 0; i < old.length; ++i) {
+	    var span = old[i], marker = span.marker
+	    var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= startCh : span.from < startCh)
+	    if (startsBefore || span.from == startCh && marker.type == "bookmark" && (!isInsert || !span.marker.insertLeft)) {
+	      var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= startCh : span.to > startCh)
+	      ;(nw || (nw = [])).push(new MarkedSpan(marker, span.from, endsAfter ? null : span.to))
+	    }
+	  } }
+	  return nw
+	}
+	function markedSpansAfter(old, endCh, isInsert) {
+	  var nw
+	  if (old) { for (var i = 0; i < old.length; ++i) {
+	    var span = old[i], marker = span.marker
+	    var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= endCh : span.to > endCh)
+	    if (endsAfter || span.from == endCh && marker.type == "bookmark" && (!isInsert || span.marker.insertLeft)) {
+	      var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= endCh : span.from < endCh)
+	      ;(nw || (nw = [])).push(new MarkedSpan(marker, startsBefore ? null : span.from - endCh,
+	                                            span.to == null ? null : span.to - endCh))
+	    }
+	  } }
+	  return nw
+	}
+
+	// Given a change object, compute the new set of marker spans that
+	// cover the line in which the change took place. Removes spans
+	// entirely within the change, reconnects spans belonging to the
+	// same marker that appear on both sides of the change, and cuts off
+	// spans partially within the change. Returns an array of span
+	// arrays with one element for each line in (after) the change.
+	function stretchSpansOverChange(doc, change) {
+	  if (change.full) { return null }
+	  var oldFirst = isLine(doc, change.from.line) && getLine(doc, change.from.line).markedSpans
+	  var oldLast = isLine(doc, change.to.line) && getLine(doc, change.to.line).markedSpans
+	  if (!oldFirst && !oldLast) { return null }
+
+	  var startCh = change.from.ch, endCh = change.to.ch, isInsert = cmp(change.from, change.to) == 0
+	  // Get the spans that 'stick out' on both sides
+	  var first = markedSpansBefore(oldFirst, startCh, isInsert)
+	  var last = markedSpansAfter(oldLast, endCh, isInsert)
+
+	  // Next, merge those two ends
+	  var sameLine = change.text.length == 1, offset = lst(change.text).length + (sameLine ? startCh : 0)
+	  if (first) {
+	    // Fix up .to properties of first
+	    for (var i = 0; i < first.length; ++i) {
+	      var span = first[i]
+	      if (span.to == null) {
+	        var found = getMarkedSpanFor(last, span.marker)
+	        if (!found) { span.to = startCh }
+	        else if (sameLine) { span.to = found.to == null ? null : found.to + offset }
+	      }
+	    }
+	  }
+	  if (last) {
+	    // Fix up .from in last (or move them into first in case of sameLine)
+	    for (var i$1 = 0; i$1 < last.length; ++i$1) {
+	      var span$1 = last[i$1]
+	      if (span$1.to != null) { span$1.to += offset }
+	      if (span$1.from == null) {
+	        var found$1 = getMarkedSpanFor(first, span$1.marker)
+	        if (!found$1) {
+	          span$1.from = offset
+	          if (sameLine) { (first || (first = [])).push(span$1) }
+	        }
+	      } else {
+	        span$1.from += offset
+	        if (sameLine) { (first || (first = [])).push(span$1) }
+	      }
+	    }
+	  }
+	  // Make sure we didn't create any zero-length spans
+	  if (first) { first = clearEmptySpans(first) }
+	  if (last && last != first) { last = clearEmptySpans(last) }
+
+	  var newMarkers = [first]
+	  if (!sameLine) {
+	    // Fill gap with whole-line-spans
+	    var gap = change.text.length - 2, gapMarkers
+	    if (gap > 0 && first)
+	      { for (var i$2 = 0; i$2 < first.length; ++i$2)
+	        { if (first[i$2].to == null)
+	          { (gapMarkers || (gapMarkers = [])).push(new MarkedSpan(first[i$2].marker, null, null)) } } }
+	    for (var i$3 = 0; i$3 < gap; ++i$3)
+	      { newMarkers.push(gapMarkers) }
+	    newMarkers.push(last)
+	  }
+	  return newMarkers
+	}
+
+	// Remove spans that are empty and don't have a clearWhenEmpty
+	// option of false.
+	function clearEmptySpans(spans) {
+	  for (var i = 0; i < spans.length; ++i) {
+	    var span = spans[i]
+	    if (span.from != null && span.from == span.to && span.marker.clearWhenEmpty !== false)
+	      { spans.splice(i--, 1) }
+	  }
+	  if (!spans.length) { return null }
+	  return spans
+	}
+
+	// Used to 'clip' out readOnly ranges when making a change.
+	function removeReadOnlyRanges(doc, from, to) {
+	  var markers = null
+	  doc.iter(from.line, to.line + 1, function (line) {
+	    if (line.markedSpans) { for (var i = 0; i < line.markedSpans.length; ++i) {
+	      var mark = line.markedSpans[i].marker
+	      if (mark.readOnly && (!markers || indexOf(markers, mark) == -1))
+	        { (markers || (markers = [])).push(mark) }
+	    } }
+	  })
+	  if (!markers) { return null }
+	  var parts = [{from: from, to: to}]
+	  for (var i = 0; i < markers.length; ++i) {
+	    var mk = markers[i], m = mk.find(0)
+	    for (var j = 0; j < parts.length; ++j) {
+	      var p = parts[j]
+	      if (cmp(p.to, m.from) < 0 || cmp(p.from, m.to) > 0) { continue }
+	      var newParts = [j, 1], dfrom = cmp(p.from, m.from), dto = cmp(p.to, m.to)
+	      if (dfrom < 0 || !mk.inclusiveLeft && !dfrom)
+	        { newParts.push({from: p.from, to: m.from}) }
+	      if (dto > 0 || !mk.inclusiveRight && !dto)
+	        { newParts.push({from: m.to, to: p.to}) }
+	      parts.splice.apply(parts, newParts)
+	      j += newParts.length - 1
+	    }
+	  }
+	  return parts
+	}
+
+	// Connect or disconnect spans from a line.
+	function detachMarkedSpans(line) {
+	  var spans = line.markedSpans
+	  if (!spans) { return }
+	  for (var i = 0; i < spans.length; ++i)
+	    { spans[i].marker.detachLine(line) }
+	  line.markedSpans = null
+	}
+	function attachMarkedSpans(line, spans) {
+	  if (!spans) { return }
+	  for (var i = 0; i < spans.length; ++i)
+	    { spans[i].marker.attachLine(line) }
+	  line.markedSpans = spans
+	}
+
+	// Helpers used when computing which overlapping collapsed span
+	// counts as the larger one.
+	function extraLeft(marker) { return marker.inclusiveLeft ? -1 : 0 }
+	function extraRight(marker) { return marker.inclusiveRight ? 1 : 0 }
+
+	// Returns a number indicating which of two overlapping collapsed
+	// spans is larger (and thus includes the other). Falls back to
+	// comparing ids when the spans cover exactly the same range.
+	function compareCollapsedMarkers(a, b) {
+	  var lenDiff = a.lines.length - b.lines.length
+	  if (lenDiff != 0) { return lenDiff }
+	  var aPos = a.find(), bPos = b.find()
+	  var fromCmp = cmp(aPos.from, bPos.from) || extraLeft(a) - extraLeft(b)
+	  if (fromCmp) { return -fromCmp }
+	  var toCmp = cmp(aPos.to, bPos.to) || extraRight(a) - extraRight(b)
+	  if (toCmp) { return toCmp }
+	  return b.id - a.id
+	}
+
+	// Find out whether a line ends or starts in a collapsed span. If
+	// so, return the marker for that span.
+	function collapsedSpanAtSide(line, start) {
+	  var sps = sawCollapsedSpans && line.markedSpans, found
+	  if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) {
+	    sp = sps[i]
+	    if (sp.marker.collapsed && (start ? sp.from : sp.to) == null &&
+	        (!found || compareCollapsedMarkers(found, sp.marker) < 0))
+	      { found = sp.marker }
+	  } }
+	  return found
+	}
+	function collapsedSpanAtStart(line) { return collapsedSpanAtSide(line, true) }
+	function collapsedSpanAtEnd(line) { return collapsedSpanAtSide(line, false) }
+
+	// Test whether there exists a collapsed span that partially
+	// overlaps (covers the start or end, but not both) of a new span.
+	// Such overlap is not allowed.
+	function conflictingCollapsedRange(doc, lineNo, from, to, marker) {
+	  var line = getLine(doc, lineNo)
+	  var sps = sawCollapsedSpans && line.markedSpans
+	  if (sps) { for (var i = 0; i < sps.length; ++i) {
+	    var sp = sps[i]
+	    if (!sp.marker.collapsed) { continue }
+	    var found = sp.marker.find(0)
+	    var fromCmp = cmp(found.from, from) || extraLeft(sp.marker) - extraLeft(marker)
+	    var toCmp = cmp(found.to, to) || extraRight(sp.marker) - extraRight(marker)
+	    if (fromCmp >= 0 && toCmp <= 0 || fromCmp <= 0 && toCmp >= 0) { continue }
+	    if (fromCmp <= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.to, from) >= 0 : cmp(found.to, from) > 0) ||
+	        fromCmp >= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.from, to) <= 0 : cmp(found.from, to) < 0))
+	      { return true }
+	  } }
+	}
+
+	// A visual line is a line as drawn on the screen. Folding, for
+	// example, can cause multiple logical lines to appear on the same
+	// visual line. This finds the start of the visual line that the
+	// given line is part of (usually that is the line itself).
+	function visualLine(line) {
+	  var merged
+	  while (merged = collapsedSpanAtStart(line))
+	    { line = merged.find(-1, true).line }
+	  return line
+	}
+
+	// Returns an array of logical lines that continue the visual line
+	// started by the argument, or undefined if there are no such lines.
+	function visualLineContinued(line) {
+	  var merged, lines
+	  while (merged = collapsedSpanAtEnd(line)) {
+	    line = merged.find(1, true).line
+	    ;(lines || (lines = [])).push(line)
+	  }
+	  return lines
+	}
+
+	// Get the line number of the start of the visual line that the
+	// given line number is part of.
+	function visualLineNo(doc, lineN) {
+	  var line = getLine(doc, lineN), vis = visualLine(line)
+	  if (line == vis) { return lineN }
+	  return lineNo(vis)
+	}
+
+	// Get the line number of the start of the next visual line after
+	// the given line.
+	function visualLineEndNo(doc, lineN) {
+	  if (lineN > doc.lastLine()) { return lineN }
+	  var line = getLine(doc, lineN), merged
+	  if (!lineIsHidden(doc, line)) { return lineN }
+	  while (merged = collapsedSpanAtEnd(line))
+	    { line = merged.find(1, true).line }
+	  return lineNo(line) + 1
+	}
+
+	// Compute whether a line is hidden. Lines count as hidden when they
+	// are part of a visual line that starts with another line, or when
+	// they are entirely covered by collapsed, non-widget span.
+	function lineIsHidden(doc, line) {
+	  var sps = sawCollapsedSpans && line.markedSpans
+	  if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) {
+	    sp = sps[i]
+	    if (!sp.marker.collapsed) { continue }
+	    if (sp.from == null) { return true }
+	    if (sp.marker.widgetNode) { continue }
+	    if (sp.from == 0 && sp.marker.inclusiveLeft && lineIsHiddenInner(doc, line, sp))
+	      { return true }
+	  } }
+	}
+	function lineIsHiddenInner(doc, line, span) {
+	  if (span.to == null) {
+	    var end = span.marker.find(1, true)
+	    return lineIsHiddenInner(doc, end.line, getMarkedSpanFor(end.line.markedSpans, span.marker))
+	  }
+	  if (span.marker.inclusiveRight && span.to == line.text.length)
+	    { return true }
+	  for (var sp = (void 0), i = 0; i < line.markedSpans.length; ++i) {
+	    sp = line.markedSpans[i]
+	    if (sp.marker.collapsed && !sp.marker.widgetNode && sp.from == span.to &&
+	        (sp.to == null || sp.to != span.from) &&
+	        (sp.marker.inclusiveLeft || span.marker.inclusiveRight) &&
+	        lineIsHiddenInner(doc, line, sp)) { return true }
+	  }
+	}
+
+	// Find the height above the given line.
+	function heightAtLine(lineObj) {
+	  lineObj = visualLine(lineObj)
+
+	  var h = 0, chunk = lineObj.parent
+	  for (var i = 0; i < chunk.lines.length; ++i) {
+	    var line = chunk.lines[i]
+	    if (line == lineObj) { break }
+	    else { h += line.height }
+	  }
+	  for (var p = chunk.parent; p; chunk = p, p = chunk.parent) {
+	    for (var i$1 = 0; i$1 < p.children.length; ++i$1) {
+	      var cur = p.children[i$1]
+	      if (cur == chunk) { break }
+	      else { h += cur.height }
+	    }
+	  }
+	  return h
+	}
+
+	// Compute the character length of a line, taking into account
+	// collapsed ranges (see markText) that might hide parts, and join
+	// other lines onto it.
+	function lineLength(line) {
+	  if (line.height == 0) { return 0 }
+	  var len = line.text.length, merged, cur = line
+	  while (merged = collapsedSpanAtStart(cur)) {
+	    var found = merged.find(0, true)
+	    cur = found.from.line
+	    len += found.from.ch - found.to.ch
+	  }
+	  cur = line
+	  while (merged = collapsedSpanAtEnd(cur)) {
+	    var found$1 = merged.find(0, true)
+	    len -= cur.text.length - found$1.from.ch
+	    cur = found$1.to.line
+	    len += cur.text.length - found$1.to.ch
+	  }
+	  return len
+	}
+
+	// Find the longest line in the document.
+	function findMaxLine(cm) {
+	  var d = cm.display, doc = cm.doc
+	  d.maxLine = getLine(doc, doc.first)
+	  d.maxLineLength = lineLength(d.maxLine)
+	  d.maxLineChanged = true
+	  doc.iter(function (line) {
+	    var len = lineLength(line)
+	    if (len > d.maxLineLength) {
+	      d.maxLineLength = len
+	      d.maxLine = line
+	    }
+	  })
+	}
+
+	// BIDI HELPERS
+
+	function iterateBidiSections(order, from, to, f) {
+	  if (!order) { return f(from, to, "ltr") }
+	  var found = false
+	  for (var i = 0; i < order.length; ++i) {
+	    var part = order[i]
+	    if (part.from < to && part.to > from || from == to && part.to == from) {
+	      f(Math.max(part.from, from), Math.min(part.to, to), part.level == 1 ? "rtl" : "ltr")
+	      found = true
+	    }
+	  }
+	  if (!found) { f(from, to, "ltr") }
+	}
+
+	function bidiLeft(part) { return part.level % 2 ? part.to : part.from }
+	function bidiRight(part) { return part.level % 2 ? part.from : part.to }
+
+	function lineLeft(line) { var order = getOrder(line); return order ? bidiLeft(order[0]) : 0 }
+	function lineRight(line) {
+	  var order = getOrder(line)
+	  if (!order) { return line.text.length }
+	  return bidiRight(lst(order))
+	}
+
+	function compareBidiLevel(order, a, b) {
+	  var linedir = order[0].level
+	  if (a == linedir) { return true }
+	  if (b == linedir) { return false }
+	  return a < b
+	}
+
+	var bidiOther = null
+	function getBidiPartAt(order, pos) {
+	  var found
+	  bidiOther = null
+	  for (var i = 0; i < order.length; ++i) {
+	    var cur = order[i]
+	    if (cur.from < pos && cur.to > pos) { return i }
+	    if ((cur.from == pos || cur.to == pos)) {
+	      if (found == null) {
+	        found = i
+	      } else if (compareBidiLevel(order, cur.level, order[found].level)) {
+	        if (cur.from != cur.to) { bidiOther = found }
+	        return i
+	      } else {
+	        if (cur.from != cur.to) { bidiOther = i }
+	        return found
+	      }
+	    }
+	  }
+	  return found
+	}
+
+	function moveInLine(line, pos, dir, byUnit) {
+	  if (!byUnit) { return pos + dir }
+	  do { pos += dir }
+	  while (pos > 0 && isExtendingChar(line.text.charAt(pos)))
+	  return pos
+	}
+
+	// This is needed in order to move 'visually' through bi-directional
+	// text -- i.e., pressing left should make the cursor go left, even
+	// when in RTL text. The tricky part is the 'jumps', where RTL and
+	// LTR text touch each other. This often requires the cursor offset
+	// to move more than one unit, in order to visually move one unit.
+	function moveVisually(line, start, dir, byUnit) {
+	  var bidi = getOrder(line)
+	  if (!bidi) { return moveLogically(line, start, dir, byUnit) }
+	  var pos = getBidiPartAt(bidi, start), part = bidi[pos]
+	  var target = moveInLine(line, start, part.level % 2 ? -dir : dir, byUnit)
+
+	  for (;;) {
+	    if (target > part.from && target < part.to) { return target }
+	    if (target == part.from || target == part.to) {
+	      if (getBidiPartAt(bidi, target) == pos) { return target }
+	      part = bidi[pos += dir]
+	      return (dir > 0) == part.level % 2 ? part.to : part.from
+	    } else {
+	      part = bidi[pos += dir]
+	      if (!part) { return null }
+	      if ((dir > 0) == part.level % 2)
+	        { target = moveInLine(line, part.to, -1, byUnit) }
+	      else
+	        { target = moveInLine(line, part.from, 1, byUnit) }
+	    }
+	  }
+	}
+
+	function moveLogically(line, start, dir, byUnit) {
+	  var target = start + dir
+	  if (byUnit) { while (target > 0 && isExtendingChar(line.text.charAt(target))) { target += dir } }
+	  return target < 0 || target > line.text.length ? null : target
+	}
+
+	// Bidirectional ordering algorithm
+	// See http://unicode.org/reports/tr9/tr9-13.html for the algorithm
+	// that this (partially) implements.
+
+	// One-char codes used for character types:
+	// L (L):   Left-to-Right
+	// R (R):   Right-to-Left
+	// r (AL):  Right-to-Left Arabic
+	// 1 (EN):  European Number
+	// + (ES):  European Number Separator
+	// % (ET):  European Number Terminator
+	// n (AN):  Arabic Number
+	// , (CS):  Common Number Separator
+	// m (NSM): Non-Spacing Mark
+	// b (BN):  Boundary Neutral
+	// s (B):   Paragraph Separator
+	// t (S):   Segment Separator
+	// w (WS):  Whitespace
+	// N (ON):  Other Neutrals
+
+	// Returns null if characters are ordered as they appear
+	// (left-to-right), or an array of sections ({from, to, level}
+	// objects) in the order in which they occur visually.
+	var bidiOrdering = (function() {
+	  // Character types for codepoints 0 to 0xff
+	  var lowTypes = "bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLN"
+	  // Character types for codepoints 0x600 to 0x6ff
+	  var arabicTypes = "rrrrrrrrrrrr,rNNmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmrrrrrrrnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmNmmmm"
+	  function charType(code) {
+	    if (code <= 0xf7) { return lowTypes.charAt(code) }
+	    else if (0x590 <= code && code <= 0x5f4) { return "R" }
+	    else if (0x600 <= code && code <= 0x6ed) { return arabicTypes.charAt(code - 0x600) }
+	    else if (0x6ee <= code && code <= 0x8ac) { return "r" }
+	    else if (0x2000 <= code && code <= 0x200b) { return "w" }
+	    else if (code == 0x200c) { return "b" }
+	    else { return "L" }
+	  }
+
+	  var bidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac]/
+	  var isNeutral = /[stwN]/, isStrong = /[LRr]/, countsAsLeft = /[Lb1n]/, countsAsNum = /[1n]/
+	  // Browsers seem to always treat the boundaries of block elements as being L.
+	  var outerType = "L"
+
+	  function BidiSpan(level, from, to) {
+	    this.level = level
+	    this.from = from; this.to = to
+	  }
+
+	  return function(str) {
+	    if (!bidiRE.test(str)) { return false }
+	    var len = str.length, types = []
+	    for (var i = 0; i < len; ++i)
+	      { types.push(charType(str.charCodeAt(i))) }
+
+	    // W1. Examine each non-spacing mark (NSM) in the level run, and
+	    // change the type of the NSM to the type of the previous
+	    // character. If the NSM is at the start of the level run, it will
+	    // get the type of sor.
+	    for (var i$1 = 0, prev = outerType; i$1 < len; ++i$1) {
+	      var type = types[i$1]
+	      if (type == "m") { types[i$1] = prev }
+	      else { prev = type }
+	    }
+
+	    // W2. Search backwards from each instance of a European number
+	    // until the first strong type (R, L, AL, or sor) is found. If an
+	    // AL is found, change the type of the European number to Arabic
+	    // number.
+	    // W3. Change all ALs to R.
+	    for (var i$2 = 0, cur = outerType; i$2 < len; ++i$2) {
+	      var type$1 = types[i$2]
+	      if (type$1 == "1" && cur == "r") { types[i$2] = "n" }
+	      else if (isStrong.test(type$1)) { cur = type$1; if (type$1 == "r") { types[i$2] = "R" } }
+	    }
+
+	    // W4. A single European separator between two European numbers
+	    // changes to a European number. A single common separator between
+	    // two numbers of the same type changes to that type.
+	    for (var i$3 = 1, prev$1 = types[0]; i$3 < len - 1; ++i$3) {
+	      var type$2 = types[i$3]
+	      if (type$2 == "+" && prev$1 == "1" && types[i$3+1] == "1") { types[i$3] = "1" }
+	      else if (type$2 == "," && prev$1 == types[i$3+1] &&
+	               (prev$1 == "1" || prev$1 == "n")) { types[i$3] = prev$1 }
+	      prev$1 = type$2
+	    }
+
+	    // W5. A sequence of European terminators adjacent to European
+	    // numbers changes to all European numbers.
+	    // W6. Otherwise, separators and terminators change to Other
+	    // Neutral.
+	    for (var i$4 = 0; i$4 < len; ++i$4) {
+	      var type$3 = types[i$4]
+	      if (type$3 == ",") { types[i$4] = "N" }
+	      else if (type$3 == "%") {
+	        var end = (void 0)
+	        for (end = i$4 + 1; end < len && types[end] == "%"; ++end) {}
+	        var replace = (i$4 && types[i$4-1] == "!") || (end < len && types[end] == "1") ? "1" : "N"
+	        for (var j = i$4; j < end; ++j) { types[j] = replace }
+	        i$4 = end - 1
+	      }
+	    }
+
+	    // W7. Search backwards from each instance of a European number
+	    // until the first strong type (R, L, or sor) is found. If an L is
+	    // found, then change the type of the European number to L.
+	    for (var i$5 = 0, cur$1 = outerType; i$5 < len; ++i$5) {
+	      var type$4 = types[i$5]
+	      if (cur$1 == "L" && type$4 == "1") { types[i$5] = "L" }
+	      else if (isStrong.test(type$4)) { cur$1 = type$4 }
+	    }
+
+	    // N1. A sequence of neutrals takes the direction of the
+	    // surrounding strong text if the text on both sides has the same
+	    // direction. European and Arabic numbers act as if they were R in
+	    // terms of their influence on neutrals. Start-of-level-run (sor)
+	    // and end-of-level-run (eor) are used at level run boundaries.
+	    // N2. Any remaining neutrals take the embedding direction.
+	    for (var i$6 = 0; i$6 < len; ++i$6) {
+	      if (isNeutral.test(types[i$6])) {
+	        var end$1 = (void 0)
+	        for (end$1 = i$6 + 1; end$1 < len && isNeutral.test(types[end$1]); ++end$1) {}
+	        var before = (i$6 ? types[i$6-1] : outerType) == "L"
+	        var after = (end$1 < len ? types[end$1] : outerType) == "L"
+	        var replace$1 = before || after ? "L" : "R"
+	        for (var j$1 = i$6; j$1 < end$1; ++j$1) { types[j$1] = replace$1 }
+	        i$6 = end$1 - 1
+	      }
+	    }
+
+	    // Here we depart from the documented algorithm, in order to avoid
+	    // building up an actual levels array. Since there are only three
+	    // levels (0, 1, 2) in an implementation that doesn't take
+	    // explicit embedding into account, we can build up the order on
+	    // the fly, without following the level-based algorithm.
+	    var order = [], m
+	    for (var i$7 = 0; i$7 < len;) {
+	      if (countsAsLeft.test(types[i$7])) {
+	        var start = i$7
+	        for (++i$7; i$7 < len && countsAsLeft.test(types[i$7]); ++i$7) {}
+	        order.push(new BidiSpan(0, start, i$7))
+	      } else {
+	        var pos = i$7, at = order.length
+	        for (++i$7; i$7 < len && types[i$7] != "L"; ++i$7) {}
+	        for (var j$2 = pos; j$2 < i$7;) {
+	          if (countsAsNum.test(types[j$2])) {
+	            if (pos < j$2) { order.splice(at, 0, new BidiSpan(1, pos, j$2)) }
+	            var nstart = j$2
+	            for (++j$2; j$2 < i$7 && countsAsNum.test(types[j$2]); ++j$2) {}
+	            order.splice(at, 0, new BidiSpan(2, nstart, j$2))
+	            pos = j$2
+	          } else { ++j$2 }
+	        }
+	        if (pos < i$7) { order.splice(at, 0, new BidiSpan(1, pos, i$7)) }
+	      }
+	    }
+	    if (order[0].level == 1 && (m = str.match(/^\s+/))) {
+	      order[0].from = m[0].length
+	      order.unshift(new BidiSpan(0, 0, m[0].length))
+	    }
+	    if (lst(order).level == 1 && (m = str.match(/\s+$/))) {
+	      lst(order).to -= m[0].length
+	      order.push(new BidiSpan(0, len - m[0].length, len))
+	    }
+	    if (order[0].level == 2)
+	      { order.unshift(new BidiSpan(1, order[0].to, order[0].to)) }
+	    if (order[0].level != lst(order).level)
+	      { order.push(new BidiSpan(order[0].level, len, len)) }
+
+	    return order
+	  }
+	})()
+
+	// Get the bidi ordering for the given line (and cache it). Returns
+	// false for lines that are fully left-to-right, and an array of
+	// BidiSpan objects otherwise.
+	function getOrder(line) {
+	  var order = line.order
+	  if (order == null) { order = line.order = bidiOrdering(line.text) }
+	  return order
+	}
+
+	// EVENT HANDLING
+
+	// Lightweight event framework. on/off also work on DOM nodes,
+	// registering native DOM handlers.
+
+	var noHandlers = []
+
+	var on = function(emitter, type, f) {
+	  if (emitter.addEventListener) {
+	    emitter.addEventListener(type, f, false)
+	  } else if (emitter.attachEvent) {
+	    emitter.attachEvent("on" + type, f)
+	  } else {
+	    var map = emitter._handlers || (emitter._handlers = {})
+	    map[type] = (map[type] || noHandlers).concat(f)
+	  }
+	}
+
+	function getHandlers(emitter, type) {
+	  return emitter._handlers && emitter._handlers[type] || noHandlers
+	}
+
+	function off(emitter, type, f) {
+	  if (emitter.removeEventListener) {
+	    emitter.removeEventListener(type, f, false)
+	  } else if (emitter.detachEvent) {
+	    emitter.detachEvent("on" + type, f)
+	  } else {
+	    var map = emitter._handlers, arr = map && map[type]
+	    if (arr) {
+	      var index = indexOf(arr, f)
+	      if (index > -1)
+	        { map[type] = arr.slice(0, index).concat(arr.slice(index + 1)) }
+	    }
+	  }
+	}
+
+	function signal(emitter, type /*, values...*/) {
+	  var handlers = getHandlers(emitter, type)
+	  if (!handlers.length) { return }
+	  var args = Array.prototype.slice.call(arguments, 2)
+	  for (var i = 0; i < handlers.length; ++i) { handlers[i].apply(null, args) }
+	}
+
+	// The DOM events that CodeMirror handles can be overridden by
+	// registering a (non-DOM) handler on the editor for the event name,
+	// and preventDefault-ing the event in that handler.
+	function signalDOMEvent(cm, e, override) {
+	  if (typeof e == "string")
+	    { e = {type: e, preventDefault: function() { this.defaultPrevented = true }} }
+	  signal(cm, override || e.type, cm, e)
+	  return e_defaultPrevented(e) || e.codemirrorIgnore
+	}
+
+	function signalCursorActivity(cm) {
+	  var arr = cm._handlers && cm._handlers.cursorActivity
+	  if (!arr) { return }
+	  var set = cm.curOp.cursorActivityHandlers || (cm.curOp.cursorActivityHandlers = [])
+	  for (var i = 0; i < arr.length; ++i) { if (indexOf(set, arr[i]) == -1)
+	    { set.push(arr[i]) } }
+	}
+
+	function hasHandler(emitter, type) {
+	  return getHandlers(emitter, type).length > 0
+	}
+
+	// Add on and off methods to a constructor's prototype, to make
+	// registering events on such objects more convenient.
+	function eventMixin(ctor) {
+	  ctor.prototype.on = function(type, f) {on(this, type, f)}
+	  ctor.prototype.off = function(type, f) {off(this, type, f)}
+	}
+
+	// Due to the fact that we still support jurassic IE versions, some
+	// compatibility wrappers are needed.
+
+	function e_preventDefault(e) {
+	  if (e.preventDefault) { e.preventDefault() }
+	  else { e.returnValue = false }
+	}
+	function e_stopPropagation(e) {
+	  if (e.stopPropagation) { e.stopPropagation() }
+	  else { e.cancelBubble = true }
+	}
+	function e_defaultPrevented(e) {
+	  return e.defaultPrevented != null ? e.defaultPrevented : e.returnValue == false
+	}
+	function e_stop(e) {e_preventDefault(e); e_stopPropagation(e)}
+
+	function e_target(e) {return e.target || e.srcElement}
+	function e_button(e) {
+	  var b = e.which
+	  if (b == null) {
+	    if (e.button & 1) { b = 1 }
+	    else if (e.button & 2) { b = 3 }
+	    else if (e.button & 4) { b = 2 }
+	  }
+	  if (mac && e.ctrlKey && b == 1) { b = 3 }
+	  return b
+	}
+
+	// Detect drag-and-drop
+	var dragAndDrop = function() {
+	  // There is *some* kind of drag-and-drop support in IE6-8, but I
+	  // couldn't get it to work yet.
+	  if (ie && ie_version < 9) { return false }
+	  var div = elt('div')
+	  return "draggable" in div || "dragDrop" in div
+	}()
+
+	var zwspSupported
+	function zeroWidthElement(measure) {
+	  if (zwspSupported == null) {
+	    var test = elt("span", "\u200b")
+	    removeChildrenAndAdd(measure, elt("span", [test, document.createTextNode("x")]))
+	    if (measure.firstChild.offsetHeight != 0)
+	      { zwspSupported = test.offsetWidth <= 1 && test.offsetHeight > 2 && !(ie && ie_version < 8) }
+	  }
+	  var node = zwspSupported ? elt("span", "\u200b") :
+	    elt("span", "\u00a0", null, "display: inline-block; width: 1px; margin-right: -1px")
+	  node.setAttribute("cm-text", "")
+	  return node
+	}
+
+	// Feature-detect IE's crummy client rect reporting for bidi text
+	var badBidiRects
+	function hasBadBidiRects(measure) {
+	  if (badBidiRects != null) { return badBidiRects }
+	  var txt = removeChildrenAndAdd(measure, document.createTextNode("A\u062eA"))
+	  var r0 = range(txt, 0, 1).getBoundingClientRect()
+	  var r1 = range(txt, 1, 2).getBoundingClientRect()
+	  removeChildren(measure)
+	  if (!r0 || r0.left == r0.right) { return false } // Safari returns null in some cases (#2780)
+	  return badBidiRects = (r1.right - r0.right < 3)
+	}
+
+	// See if "".split is the broken IE version, if so, provide an
+	// alternative way to split lines.
+	var splitLinesAuto = "\n\nb".split(/\n/).length != 3 ? function (string) {
+	  var pos = 0, result = [], l = string.length
+	  while (pos <= l) {
+	    var nl = string.indexOf("\n", pos)
+	    if (nl == -1) { nl = string.length }
+	    var line = string.slice(pos, string.charAt(nl - 1) == "\r" ? nl - 1 : nl)
+	    var rt = line.indexOf("\r")
+	    if (rt != -1) {
+	      result.push(line.slice(0, rt))
+	      pos += rt + 1
+	    } else {
+	      result.push(line)
+	      pos = nl + 1
+	    }
+	  }
+	  return result
+	} : function (string) { return string.split(/\r\n?|\n/); }
+
+	var hasSelection = window.getSelection ? function (te) {
+	  try { return te.selectionStart != te.selectionEnd }
+	  catch(e) { return false }
+	} : function (te) {
+	  var range
+	  try {range = te.ownerDocument.selection.createRange()}
+	  catch(e) {}
+	  if (!range || range.parentElement() != te) { return false }
+	  return range.compareEndPoints("StartToEnd", range) != 0
+	}
+
+	var hasCopyEvent = (function () {
+	  var e = elt("div")
+	  if ("oncopy" in e) { return true }
+	  e.setAttribute("oncopy", "return;")
+	  return typeof e.oncopy == "function"
+	})()
+
+	var badZoomedRects = null
+	function hasBadZoomedRects(measure) {
+	  if (badZoomedRects != null) { return badZoomedRects }
+	  var node = removeChildrenAndAdd(measure, elt("span", "x"))
+	  var normal = node.getBoundingClientRect()
+	  var fromRange = range(node, 0, 1).getBoundingClientRect()
+	  return badZoomedRects = Math.abs(normal.left - fromRange.left) > 1
+	}
+
+	var modes = {};
+	var mimeModes = {};
+	// Extra arguments are stored as the mode's dependencies, which is
+	// used by (legacy) mechanisms like loadmode.js to automatically
+	// load a mode. (Preferred mechanism is the require/define calls.)
+	function defineMode(name, mode) {
+	  if (arguments.length > 2)
+	    { mode.dependencies = Array.prototype.slice.call(arguments, 2) }
+	  modes[name] = mode
+	}
+
+	function defineMIME(mime, spec) {
+	  mimeModes[mime] = spec
+	}
+
+	// Given a MIME type, a {name, ...options} config object, or a name
+	// string, return a mode config object.
+	function resolveMode(spec) {
+	  if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) {
+	    spec = mimeModes[spec]
+	  } else if (spec && typeof spec.name == "string" && mimeModes.hasOwnProperty(spec.name)) {
+	    var found = mimeModes[spec.name]
+	    if (typeof found == "string") { found = {name: found} }
+	    spec = createObj(found, spec)
+	    spec.name = found.name
+	  } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+xml$/.test(spec)) {
+	    return resolveMode("application/xml")
+	  } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+json$/.test(spec)) {
+	    return resolveMode("application/json")
+	  }
+	  if (typeof spec == "string") { return {name: spec} }
+	  else { return spec || {name: "null"} }
+	}
+
+	// Given a mode spec (anything that resolveMode accepts), find and
+	// initialize an actual mode object.
+	function getMode(options, spec) {
+	  spec = resolveMode(spec)
+	  var mfactory = modes[spec.name]
+	  if (!mfactory) { return getMode(options, "text/plain") }
+	  var modeObj = mfactory(options, spec)
+	  if (modeExtensions.hasOwnProperty(spec.name)) {
+	    var exts = modeExtensions[spec.name]
+	    for (var prop in exts) {
+	      if (!exts.hasOwnProperty(prop)) { continue }
+	      if (modeObj.hasOwnProperty(prop)) { modeObj["_" + prop] = modeObj[prop] }
+	      modeObj[prop] = exts[prop]
+	    }
+	  }
+	  modeObj.name = spec.name
+	  if (spec.helperType) { modeObj.helperType = spec.helperType }
+	  if (spec.modeProps) { for (var prop$1 in spec.modeProps)
+	    { modeObj[prop$1] = spec.modeProps[prop$1] } }
+
+	  return modeObj
+	}
+
+	// This can be used to attach properties to mode objects from
+	// outside the actual mode definition.
+	var modeExtensions = {}
+	function extendMode(mode, properties) {
+	  var exts = modeExtensions.hasOwnProperty(mode) ? modeExtensions[mode] : (modeExtensions[mode] = {})
+	  copyObj(properties, exts)
+	}
+
+	function copyState(mode, state) {
+	  if (state === true) { return state }
+	  if (mode.copyState) { return mode.copyState(state) }
+	  var nstate = {}
+	  for (var n in state) {
+	    var val = state[n]
+	    if (val instanceof Array) { val = val.concat([]) }
+	    nstate[n] = val
+	  }
+	  return nstate
+	}
+
+	// Given a mode and a state (for that mode), find the inner mode and
+	// state at the position that the state refers to.
+	function innerMode(mode, state) {
+	  var info
+	  while (mode.innerMode) {
+	    info = mode.innerMode(state)
+	    if (!info || info.mode == mode) { break }
+	    state = info.state
+	    mode = info.mode
+	  }
+	  return info || {mode: mode, state: state}
+	}
+
+	function startState(mode, a1, a2) {
+	  return mode.startState ? mode.startState(a1, a2) : true
+	}
+
+	// STRING STREAM
+
+	// Fed to the mode parsers, provides helper functions to make
+	// parsers more succinct.
+
+	var StringStream = function(string, tabSize) {
+	  this.pos = this.start = 0
+	  this.string = string
+	  this.tabSize = tabSize || 8
+	  this.lastColumnPos = this.lastColumnValue = 0
+	  this.lineStart = 0
+	}
+
+	StringStream.prototype = {
+	  eol: function() {return this.pos >= this.string.length},
+	  sol: function() {return this.pos == this.lineStart},
+	  peek: function() {return this.string.charAt(this.pos) || undefined},
+	  next: function() {
+	    if (this.pos < this.string.length)
+	      { return this.string.charAt(this.pos++) }
+	  },
+	  eat: function(match) {
+	    var ch = this.string.charAt(this.pos)
+	    var ok
+	    if (typeof match == "string") { ok = ch == match }
+	    else { ok = ch && (match.test ? match.test(ch) : match(ch)) }
+	    if (ok) {++this.pos; return ch}
+	  },
+	  eatWhile: function(match) {
+	    var start = this.pos
+	    while (this.eat(match)){}
+	    return this.pos > start
+	  },
+	  eatSpace: function() {
+	    var this$1 = this;
+
+	    var start = this.pos
+	    while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) { ++this$1.pos }
+	    return this.pos > start
+	  },
+	  skipToEnd: function() {this.pos = this.string.length},
+	  skipTo: function(ch) {
+	    var found = this.string.indexOf(ch, this.pos)
+	    if (found > -1) {this.pos = found; return true}
+	  },
+	  backUp: function(n) {this.pos -= n},
+	  column: function() {
+	    if (this.lastColumnPos < this.start) {
+	      this.lastColumnValue = countColumn(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue)
+	      this.lastColumnPos = this.start
+	    }
+	    return this.lastColumnValue - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0)
+	  },
+	  indentation: function() {
+	    return countColumn(this.string, null, this.tabSize) -
+	      (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0)
+	  },
+	  match: function(pattern, consume, caseInsensitive) {
+	    if (typeof pattern == "string") {
+	      var cased = function (str) { return caseInsensitive ? str.toLowerCase() : str; }
+	      var substr = this.string.substr(this.pos, pattern.length)
+	      if (cased(substr) == cased(pattern)) {
+	        if (consume !== false) { this.pos += pattern.length }
+	        return true
+	      }
+	    } else {
+	      var match = this.string.slice(this.pos).match(pattern)
+	      if (match && match.index > 0) { return null }
+	      if (match && consume !== false) { this.pos += match[0].length }
+	      return match
+	    }
+	  },
+	  current: function(){return this.string.slice(this.start, this.pos)},
+	  hideFirstChars: function(n, inner) {
+	    this.lineStart += n
+	    try { return inner() }
+	    finally { this.lineStart -= n }
+	  }
+	}
+
+	// Compute a style array (an array starting with a mode generation
+	// -- for invalidation -- followed by pairs of end positions and
+	// style strings), which is used to highlight the tokens on the
+	// line.
+	function highlightLine(cm, line, state, forceToEnd) {
+	  // A styles array always starts with a number identifying the
+	  // mode/overlays that it is based on (for easy invalidation).
+	  var st = [cm.state.modeGen], lineClasses = {}
+	  // Compute the base array of styles
+	  runMode(cm, line.text, cm.doc.mode, state, function (end, style) { return st.push(end, style); },
+	    lineClasses, forceToEnd)
+
+	  // Run overlays, adjust style array.
+	  var loop = function ( o ) {
+	    var overlay = cm.state.overlays[o], i = 1, at = 0
+	    runMode(cm, line.text, overlay.mode, true, function (end, style) {
+	      var start = i
+	      // Ensure there's a token end at the current position, and that i points at it
+	      while (at < end) {
+	        var i_end = st[i]
+	        if (i_end > end)
+	          { st.splice(i, 1, end, st[i+1], i_end) }
+	        i += 2
+	        at = Math.min(end, i_end)
+	      }
+	      if (!style) { return }
+	      if (overlay.opaque) {
+	        st.splice(start, i - start, end, "overlay " + style)
+	        i = start + 2
+	      } else {
+	        for (; start < i; start += 2) {
+	          var cur = st[start+1]
+	          st[start+1] = (cur ? cur + " " : "") + "overlay " + style
+	        }
+	      }
+	    }, lineClasses)
+	  };
+
+	  for (var o = 0; o < cm.state.overlays.length; ++o) loop( o );
+
+	  return {styles: st, classes: lineClasses.bgClass || lineClasses.textClass ? lineClasses : null}
+	}
+
+	function getLineStyles(cm, line, updateFrontier) {
+	  if (!line.styles || line.styles[0] != cm.state.modeGen) {
+	    var state = getStateBefore(cm, lineNo(line))
+	    var result = highlightLine(cm, line, line.text.length > cm.options.maxHighlightLength ? copyState(cm.doc.mode, state) : state)
+	    line.stateAfter = state
+	    line.styles = result.styles
+	    if (result.classes) { line.styleClasses = result.classes }
+	    else if (line.styleClasses) { line.styleClasses = null }
+	    if (updateFrontier === cm.doc.frontier) { cm.doc.frontier++ }
+	  }
+	  return line.styles
+	}
+
+	function getStateBefore(cm, n, precise) {
+	  var doc = cm.doc, display = cm.display
+	  if (!doc.mode.startState) { return true }
+	  var pos = findStartLine(cm, n, precise), state = pos > doc.first && getLine(doc, pos-1).stateAfter
+	  if (!state) { state = startState(doc.mode) }
+	  else { state = copyState(doc.mode, state) }
+	  doc.iter(pos, n, function (line) {
+	    processLine(cm, line.text, state)
+	    var save = pos == n - 1 || pos % 5 == 0 || pos >= display.viewFrom && pos < display.viewTo
+	    line.stateAfter = save ? copyState(doc.mode, state) : null
+	    ++pos
+	  })
+	  if (precise) { doc.frontier = pos }
+	  return state
+	}
+
+	// Lightweight form of highlight -- proceed over this line and
+	// update state, but don't save a style array. Used for lines that
+	// aren't currently visible.
+	function processLine(cm, text, state, startAt) {
+	  var mode = cm.doc.mode
+	  var stream = new StringStream(text, cm.options.tabSize)
+	  stream.start = stream.pos = startAt || 0
+	  if (text == "") { callBlankLine(mode, state) }
+	  while (!stream.eol()) {
+	    readToken(mode, stream, state)
+	    stream.start = stream.pos
+	  }
+	}
+
+	function callBlankLine(mode, state) {
+	  if (mode.blankLine) { return mode.blankLine(state) }
+	  if (!mode.innerMode) { return }
+	  var inner = innerMode(mode, state)
+	  if (inner.mode.blankLine) { return inner.mode.blankLine(inner.state) }
+	}
+
+	function readToken(mode, stream, state, inner) {
+	  for (var i = 0; i < 10; i++) {
+	    if (inner) { inner[0] = innerMode(mode, state).mode }
+	    var style = mode.token(stream, state)
+	    if (stream.pos > stream.start) { return style }
+	  }
+	  throw new Error("Mode " + mode.name + " failed to advance stream.")
+	}
+
+	// Utility for getTokenAt and getLineTokens
+	function takeToken(cm, pos, precise, asArray) {
+	  var getObj = function (copy) { return ({
+	    start: stream.start, end: stream.pos,
+	    string: stream.current(),
+	    type: style || null,
+	    state: copy ? copyState(doc.mode, state) : state
+	  }); }
+
+	  var doc = cm.doc, mode = doc.mode, style
+	  pos = clipPos(doc, pos)
+	  var line = getLine(doc, pos.line), state = getStateBefore(cm, pos.line, precise)
+	  var stream = new StringStream(line.text, cm.options.tabSize), tokens
+	  if (asArray) { tokens = [] }
+	  while ((asArray || stream.pos < pos.ch) && !stream.eol()) {
+	    stream.start = stream.pos
+	    style = readToken(mode, stream, state)
+	    if (asArray) { tokens.push(getObj(true)) }
+	  }
+	  return asArray ? tokens : getObj()
+	}
+
+	function extractLineClasses(type, output) {
+	  if (type) { for (;;) {
+	    var lineClass = type.match(/(?:^|\s+)line-(background-)?(\S+)/)
+	    if (!lineClass) { break }
+	    type = type.slice(0, lineClass.index) + type.slice(lineClass.index + lineClass[0].length)
+	    var prop = lineClass[1] ? "bgClass" : "textClass"
+	    if (output[prop] == null)
+	      { output[prop] = lineClass[2] }
+	    else if (!(new RegExp("(?:^|\s)" + lineClass[2] + "(?:$|\s)")).test(output[prop]))
+	      { output[prop] += " " + lineClass[2] }
+	  } }
+	  return type
+	}
+
+	// Run the given mode's parser over a line, calling f for each token.
+	function runMode(cm, text, mode, state, f, lineClasses, forceToEnd) {
+	  var flattenSpans = mode.flattenSpans
+	  if (flattenSpans == null) { flattenSpans = cm.options.flattenSpans }
+	  var curStart = 0, curStyle = null
+	  var stream = new StringStream(text, cm.options.tabSize), style
+	  var inner = cm.options.addModeClass && [null]
+	  if (text == "") { extractLineClasses(callBlankLine(mode, state), lineClasses) }
+	  while (!stream.eol()) {
+	    if (stream.pos > cm.options.maxHighlightLength) {
+	      flattenSpans = false
+	      if (forceToEnd) { processLine(cm, text, state, stream.pos) }
+	      stream.pos = text.length
+	      style = null
+	    } else {
+	      style = extractLineClasses(readToken(mode, stream, state, inner), lineClasses)
+	    }
+	    if (inner) {
+	      var mName = inner[0].name
+	      if (mName) { style = "m-" + (style ? mName + " " + style : mName) }
+	    }
+	    if (!flattenSpans || curStyle != style) {
+	      while (curStart < stream.start) {
+	        curStart = Math.min(stream.start, curStart + 5000)
+	        f(curStart, curStyle)
+	      }
+	      curStyle = style
+	    }
+	    stream.start = stream.pos
+	  }
+	  while (curStart < stream.pos) {
+	    // Webkit seems to refuse to render text nodes longer than 57444
+	    // characters, and returns inaccurate measurements in nodes
+	    // starting around 5000 chars.
+	    var pos = Math.min(stream.pos, curStart + 5000)
+	    f(pos, curStyle)
+	    curStart = pos
+	  }
+	}
+
+	// Finds the line to start with when starting a parse. Tries to
+	// find a line with a stateAfter, so that it can start with a
+	// valid state. If that fails, it returns the line with the
+	// smallest indentation, which tends to need the least context to
+	// parse correctly.
+	function findStartLine(cm, n, precise) {
+	  var minindent, minline, doc = cm.doc
+	  var lim = precise ? -1 : n - (cm.doc.mode.innerMode ? 1000 : 100)
+	  for (var search = n; search > lim; --search) {
+	    if (search <= doc.first) { return doc.first }
+	    var line = getLine(doc, search - 1)
+	    if (line.stateAfter && (!precise || search <= doc.frontier)) { return search }
+	    var indented = countColumn(line.text, null, cm.options.tabSize)
+	    if (minline == null || minindent > indented) {
+	      minline = search - 1
+	      minindent = indented
+	    }
+	  }
+	  return minline
+	}
+
+	// LINE DATA STRUCTURE
+
+	// Line objects. These hold state related to a line, including
+	// highlighting info (the styles array).
+	function Line(text, markedSpans, estimateHeight) {
+	  this.text = text
+	  attachMarkedSpans(this, markedSpans)
+	  this.height = estimateHeight ? estimateHeight(this) : 1
+	}
+	eventMixin(Line)
+	Line.prototype.lineNo = function() { return lineNo(this) }
+
+	// Change the content (text, markers) of a line. Automatically
+	// invalidates cached information and tries to re-estimate the
+	// line's height.
+	function updateLine(line, text, markedSpans, estimateHeight) {
+	  line.text = text
+	  if (line.stateAfter) { line.stateAfter = null }
+	  if (line.styles) { line.styles = null }
+	  if (line.order != null) { line.order = null }
+	  detachMarkedSpans(line)
+	  attachMarkedSpans(line, markedSpans)
+	  var estHeight = estimateHeight ? estimateHeight(line) : 1
+	  if (estHeight != line.height) { updateLineHeight(line, estHeight) }
+	}
+
+	// Detach a line from the document tree and its markers.
+	function cleanUpLine(line) {
+	  line.parent = null
+	  detachMarkedSpans(line)
+	}
+
+	// Convert a style as returned by a mode (either null, or a string
+	// containing one or more styles) to a CSS style. This is cached,
+	// and also looks for line-wide styles.
+	var styleToClassCache = {};
+	var styleToClassCacheWithMode = {};
+	function interpretTokenStyle(style, options) {
+	  if (!style || /^\s*$/.test(style)) { return null }
+	  var cache = options.addModeClass ? styleToClassCacheWithMode : styleToClassCache
+	  return cache[style] ||
+	    (cache[style] = style.replace(/\S+/g, "cm-$&"))
+	}
+
+	// Render the DOM representation of the text of a line. Also builds
+	// up a 'line map', which points at the DOM nodes that represent
+	// specific stretches of text, and is used by the measuring code.
+	// The returned object contains the DOM node, this map, and
+	// information about line-wide styles that were set by the mode.
+	function buildLineContent(cm, lineView) {
+	  // The padding-right forces the element to have a 'border', which
+	  // is needed on Webkit to be able to get line-level bounding
+	  // rectangles for it (in measureChar).
+	  var content = elt("span", null, null, webkit ? "padding-right: .1px" : null)
+	  var builder = {pre: elt("pre", [content], "CodeMirror-line"), content: content,
+	                 col: 0, pos: 0, cm: cm,
+	                 trailingSpace: false,
+	                 splitSpaces: (ie || webkit) && cm.getOption("lineWrapping")}
+	  lineView.measure = {}
+
+	  // Iterate over the logical lines that make up this visual line.
+	  for (var i = 0; i <= (lineView.rest ? lineView.rest.length : 0); i++) {
+	    var line = i ? lineView.rest[i - 1] : lineView.line, order = (void 0)
+	    builder.pos = 0
+	    builder.addToken = buildToken
+	    // Optionally wire in some hacks into the token-rendering
+	    // algorithm, to deal with browser quirks.
+	    if (hasBadBidiRects(cm.display.measure) && (order = getOrder(line)))
+	      { builder.addToken = buildTokenBadBidi(builder.addToken, order) }
+	    builder.map = []
+	    var allowFrontierUpdate = lineView != cm.display.externalMeasured && lineNo(line)
+	    insertLineContent(line, builder, getLineStyles(cm, line, allowFrontierUpdate))
+	    if (line.styleClasses) {
+	      if (line.styleClasses.bgClass)
+	        { builder.bgClass = joinClasses(line.styleClasses.bgClass, builder.bgClass || "") }
+	      if (line.styleClasses.textClass)
+	        { builder.textClass = joinClasses(line.styleClasses.textClass, builder.textClass || "") }
+	    }
+
+	    // Ensure at least a single node is present, for measuring.
+	    if (builder.map.length == 0)
+	      { builder.map.push(0, 0, builder.content.appendChild(zeroWidthElement(cm.display.measure))) }
+
+	    // Store the map and a cache object for the current logical line
+	    if (i == 0) {
+	      lineView.measure.map = builder.map
+	      lineView.measure.cache = {}
+	    } else {
+	      ;(lineView.measure.maps || (lineView.measure.maps = [])).push(builder.map)
+	      ;(lineView.measure.caches || (lineView.measure.caches = [])).push({})
+	    }
+	  }
+
+	  // See issue #2901
+	  if (webkit) {
+	    var last = builder.content.lastChild
+	    if (/\bcm-tab\b/.test(last.className) || (last.querySelector && last.querySelector(".cm-tab")))
+	      { builder.content.className = "cm-tab-wrap-hack" }
+	  }
+
+	  signal(cm, "renderLine", cm, lineView.line, builder.pre)
+	  if (builder.pre.className)
+	    { builder.textClass = joinClasses(builder.pre.className, builder.textClass || "") }
+
+	  return builder
+	}
+
+	function defaultSpecialCharPlaceholder(ch) {
+	  var token = elt("span", "\u2022", "cm-invalidchar")
+	  token.title = "\\u" + ch.charCodeAt(0).toString(16)
+	  token.setAttribute("aria-label", token.title)
+	  return token
+	}
+
+	// Build up the DOM representation for a single token, and add it to
+	// the line map. Takes care to render special characters separately.
+	function buildToken(builder, text, style, startStyle, endStyle, title, css) {
+	  if (!text) { return }
+	  var displayText = builder.splitSpaces ? splitSpaces(text, builder.trailingSpace) : text
+	  var special = builder.cm.state.specialChars, mustWrap = false
+	  var content
+	  if (!special.test(text)) {
+	    builder.col += text.length
+	    content = document.createTextNode(displayText)
+	    builder.map.push(builder.pos, builder.pos + text.length, content)
+	    if (ie && ie_version < 9) { mustWrap = true }
+	    builder.pos += text.length
+	  } else {
+	    content = document.createDocumentFragment()
+	    var pos = 0
+	    while (true) {
+	      special.lastIndex = pos
+	      var m = special.exec(text)
+	      var skipped = m ? m.index - pos : text.length - pos
+	      if (skipped) {
+	        var txt = document.createTextNode(displayText.slice(pos, pos + skipped))
+	        if (ie && ie_version < 9) { content.appendChild(elt("span", [txt])) }
+	        else { content.appendChild(txt) }
+	        builder.map.push(builder.pos, builder.pos + skipped, txt)
+	        builder.col += skipped
+	        builder.pos += skipped
+	      }
+	      if (!m) { break }
+	      pos += skipped + 1
+	      var txt$1 = (void 0)
+	      if (m[0] == "\t") {
+	        var tabSize = builder.cm.options.tabSize, tabWidth = tabSize - builder.col % tabSize
+	        txt$1 = content.appendChild(elt("span", spaceStr(tabWidth), "cm-tab"))
+	        txt$1.setAttribute("role", "presentation")
+	        txt$1.setAttribute("cm-text", "\t")
+	        builder.col += tabWidth
+	      } else if (m[0] == "\r" || m[0] == "\n") {
+	        txt$1 = content.appendChild(elt("span", m[0] == "\r" ? "\u240d" : "\u2424", "cm-invalidchar"))
+	        txt$1.setAttribute("cm-text", m[0])
+	        builder.col += 1
+	      } else {
+	        txt$1 = builder.cm.options.specialCharPlaceholder(m[0])
+	        txt$1.setAttribute("cm-text", m[0])
+	        if (ie && ie_version < 9) { content.appendChild(elt("span", [txt$1])) }
+	        else { content.appendChild(txt$1) }
+	        builder.col += 1
+	      }
+	      builder.map.push(builder.pos, builder.pos + 1, txt$1)
+	      builder.pos++
+	    }
+	  }
+	  builder.trailingSpace = displayText.charCodeAt(text.length - 1) == 32
+	  if (style || startStyle || endStyle || mustWrap || css) {
+	    var fullStyle = style || ""
+	    if (startStyle) { fullStyle += startStyle }
+	    if (endStyle) { fullStyle += endStyle }
+	    var token = elt("span", [content], fullStyle, css)
+	    if (title) { token.title = title }
+	    return builder.content.appendChild(token)
+	  }
+	  builder.content.appendChild(content)
+	}
+
+	function splitSpaces(text, trailingBefore) {
+	  if (text.length > 1 && !/  /.test(text)) { return text }
+	  var spaceBefore = trailingBefore, result = ""
+	  for (var i = 0; i < text.length; i++) {
+	    var ch = text.charAt(i)
+	    if (ch == " " && spaceBefore && (i == text.length - 1 || text.charCodeAt(i + 1) == 32))
+	      { ch = "\u00a0" }
+	    result += ch
+	    spaceBefore = ch == " "
+	  }
+	  return result
+	}
+
+	// Work around nonsense dimensions being reported for stretches of
+	// right-to-left text.
+	function buildTokenBadBidi(inner, order) {
+	  return function (builder, text, style, startStyle, endStyle, title, css) {
+	    style = style ? style + " cm-force-border" : "cm-force-border"
+	    var start = builder.pos, end = start + text.length
+	    for (;;) {
+	      // Find the part that overlaps with the start of this text
+	      var part = (void 0)
+	      for (var i = 0; i < order.length; i++) {
+	        part = order[i]
+	        if (part.to > start && part.from <= start) { break }
+	      }
+	      if (part.to >= end) { return inner(builder, text, style, startStyle, endStyle, title, css) }
+	      inner(builder, text.slice(0, part.to - start), style, startStyle, null, title, css)
+	      startStyle = null
+	      text = text.slice(part.to - start)
+	      start = part.to
+	    }
+	  }
+	}
+
+	function buildCollapsedSpan(builder, size, marker, ignoreWidget) {
+	  var widget = !ignoreWidget && marker.widgetNode
+	  if (widget) { builder.map.push(builder.pos, builder.pos + size, widget) }
+	  if (!ignoreWidget && builder.cm.display.input.needsContentAttribute) {
+	    if (!widget)
+	      { widget = builder.content.appendChild(document.createElement("span")) }
+	    widget.setAttribute("cm-marker", marker.id)
+	  }
+	  if (widget) {
+	    builder.cm.display.input.setUneditable(widget)
+	    builder.content.appendChild(widget)
+	  }
+	  builder.pos += size
+	  builder.trailingSpace = false
+	}
+
+	// Outputs a number of spans to make up a line, taking highlighting
+	// and marked text into account.
+	function insertLineContent(line, builder, styles) {
+	  var spans = line.markedSpans, allText = line.text, at = 0
+	  if (!spans) {
+	    for (var i$1 = 1; i$1 < styles.length; i$1+=2)
+	      { builder.addToken(builder, allText.slice(at, at = styles[i$1]), interpretTokenStyle(styles[i$1+1], builder.cm.options)) }
+	    return
+	  }
+
+	  var len = allText.length, pos = 0, i = 1, text = "", style, css
+	  var nextChange = 0, spanStyle, spanEndStyle, spanStartStyle, title, collapsed
+	  for (;;) {
+	    if (nextChange == pos) { // Update current marker set
+	      spanStyle = spanEndStyle = spanStartStyle = title = css = ""
+	      collapsed = null; nextChange = Infinity
+	      var foundBookmarks = [], endStyles = (void 0)
+	      for (var j = 0; j < spans.length; ++j) {
+	        var sp = spans[j], m = sp.marker
+	        if (m.type == "bookmark" && sp.from == pos && m.widgetNode) {
+	          foundBookmarks.push(m)
+	        } else if (sp.from <= pos && (sp.to == null || sp.to > pos || m.collapsed && sp.to == pos && sp.from == pos)) {
+	          if (sp.to != null && sp.to != pos && nextChange > sp.to) {
+	            nextChange = sp.to
+	            spanEndStyle = ""
+	          }
+	          if (m.className) { spanStyle += " " + m.className }
+	          if (m.css) { css = (css ? css + ";" : "") + m.css }
+	          if (m.startStyle && sp.from == pos) { spanStartStyle += " " + m.startStyle }
+	          if (m.endStyle && sp.to == nextChange) { (endStyles || (endStyles = [])).push(m.endStyle, sp.to) }
+	          if (m.title && !title) { title = m.title }
+	          if (m.collapsed && (!collapsed || compareCollapsedMarkers(collapsed.marker, m) < 0))
+	            { collapsed = sp }
+	        } else if (sp.from > pos && nextChange > sp.from) {
+	          nextChange = sp.from
+	        }
+	      }
+	      if (endStyles) { for (var j$1 = 0; j$1 < endStyles.length; j$1 += 2)
+	        { if (endStyles[j$1 + 1] == nextChange) { spanEndStyle += " " + endStyles[j$1] } } }
+
+	      if (!collapsed || collapsed.from == pos) { for (var j$2 = 0; j$2 < foundBookmarks.length; ++j$2)
+	        { buildCollapsedSpan(builder, 0, foundBookmarks[j$2]) } }
+	      if (collapsed && (collapsed.from || 0) == pos) {
+	        buildCollapsedSpan(builder, (collapsed.to == null ? len + 1 : collapsed.to) - pos,
+	                           collapsed.marker, collapsed.from == null)
+	        if (collapsed.to == null) { return }
+	        if (collapsed.to == pos) { collapsed = false }
+	      }
+	    }
+	    if (pos >= len) { break }
+
+	    var upto = Math.min(len, nextChange)
+	    while (true) {
+	      if (text) {
+	        var end = pos + text.length
+	        if (!collapsed) {
+	          var tokenText = end > upto ? text.slice(0, upto - pos) : text
+	          builder.addToken(builder, tokenText, style ? style + spanStyle : spanStyle,
+	                           spanStartStyle, pos + tokenText.length == nextChange ? spanEndStyle : "", title, css)
+	        }
+	        if (end >= upto) {text = text.slice(upto - pos); pos = upto; break}
+	        pos = end
+	        spanStartStyle = ""
+	      }
+	      text = allText.slice(at, at = styles[i++])
+	      style = interpretTokenStyle(styles[i++], builder.cm.options)
+	    }
+	  }
+	}
+
+
+	// These objects are used to represent the visible (currently drawn)
+	// part of the document. A LineView may correspond to multiple
+	// logical lines, if those are connected by collapsed ranges.
+	function LineView(doc, line, lineN) {
+	  // The starting line
+	  this.line = line
+	  // Continuing lines, if any
+	  this.rest = visualLineContinued(line)
+	  // Number of logical lines in this visual line
+	  this.size = this.rest ? lineNo(lst(this.rest)) - lineN + 1 : 1
+	  this.node = this.text = null
+	  this.hidden = lineIsHidden(doc, line)
+	}
+
+	// Create a range of LineView objects for the given lines.
+	function buildViewArray(cm, from, to) {
+	  var array = [], nextPos
+	  for (var pos = from; pos < to; pos = nextPos) {
+	    var view = new LineView(cm.doc, getLine(cm.doc, pos), pos)
+	    nextPos = pos + view.size
+	    array.push(view)
+	  }
+	  return array
+	}
+
+	var operationGroup = null
+
+	function pushOperation(op) {
+	  if (operationGroup) {
+	    operationGroup.ops.push(op)
+	  } else {
+	    op.ownsGroup = operationGroup = {
+	      ops: [op],
+	      delayedCallbacks: []
+	    }
+	  }
+	}
+
+	function fireCallbacksForOps(group) {
+	  // Calls delayed callbacks and cursorActivity handlers until no
+	  // new ones appear
+	  var callbacks = group.delayedCallbacks, i = 0
+	  do {
+	    for (; i < callbacks.length; i++)
+	      { callbacks[i].call(null) }
+	    for (var j = 0; j < group.ops.length; j++) {
+	      var op = group.ops[j]
+	      if (op.cursorActivityHandlers)
+	        { while (op.cursorActivityCalled < op.cursorActivityHandlers.length)
+	          { op.cursorActivityHandlers[op.cursorActivityCalled++].call(null, op.cm) } }
+	    }
+	  } while (i < callbacks.length)
+	}
+
+	function finishOperation(op, endCb) {
+	  var group = op.ownsGroup
+	  if (!group) { return }
+
+	  try { fireCallbacksForOps(group) }
+	  finally {
+	    operationGroup = null
+	    endCb(group)
+	  }
+	}
+
+	var orphanDelayedCallbacks = null
+
+	// Often, we want to signal events at a point where we are in the
+	// middle of some work, but don't want the handler to start calling
+	// other methods on the editor, which might be in an inconsistent
+	// state or simply not expect any other events to happen.
+	// signalLater looks whether there are any handlers, and schedules
+	// them to be executed when the last operation ends, or, if no
+	// operation is active, when a timeout fires.
+	function signalLater(emitter, type /*, values...*/) {
+	  var arr = getHandlers(emitter, type)
+	  if (!arr.length) { return }
+	  var args = Array.prototype.slice.call(arguments, 2), list
+	  if (operationGroup) {
+	    list = operationGroup.delayedCallbacks
+	  } else if (orphanDelayedCallbacks) {
+	    list = orphanDelayedCallbacks
+	  } else {
+	    list = orphanDelayedCallbacks = []
+	    setTimeout(fireOrphanDelayed, 0)
+	  }
+	  var loop = function ( i ) {
+	    list.push(function () { return arr[i].apply(null, args); })
+	  };
+
+	  for (var i = 0; i < arr.length; ++i)
+	    loop( i );
+	}
+
+	function fireOrphanDelayed() {
+	  var delayed = orphanDelayedCallbacks
+	  orphanDelayedCallbacks = null
+	  for (var i = 0; i < delayed.length; ++i) { delayed[i]() }
+	}
+
+	// When an aspect of a line changes, a string is added to
+	// lineView.changes. This updates the relevant part of the line's
+	// DOM structure.
+	function updateLineForChanges(cm, lineView, lineN, dims) {
+	  for (var j = 0; j < lineView.changes.length; j++) {
+	    var type = lineView.changes[j]
+	    if (type == "text") { updateLineText(cm, lineView) }
+	    else if (type == "gutter") { updateLineGutter(cm, lineView, lineN, dims) }
+	    else if (type == "class") { updateLineClasses(lineView) }
+	    else if (type == "widget") { updateLineWidgets(cm, lineView, dims) }
+	  }
+	  lineView.changes = null
+	}
+
+	// Lines with gutter elements, widgets or a background class need to
+	// be wrapped, and have the extra elements added to the wrapper div
+	function ensureLineWrapped(lineView) {
+	  if (lineView.node == lineView.text) {
+	    lineView.node = elt("div", null, null, "position: relative")
+	    if (lineView.text.parentNode)
+	      { lineView.text.parentNode.replaceChild(lineView.node, lineView.text) }
+	    lineView.node.appendChild(lineView.text)
+	    if (ie && ie_version < 8) { lineView.node.style.zIndex = 2 }
+	  }
+	  return lineView.node
+	}
+
+	function updateLineBackground(lineView) {
+	  var cls = lineView.bgClass ? lineView.bgClass + " " + (lineView.line.bgClass || "") : lineView.line.bgClass
+	  if (cls) { cls += " CodeMirror-linebackground" }
+	  if (lineView.background) {
+	    if (cls) { lineView.background.className = cls }
+	    else { lineView.background.parentNode.removeChild(lineView.background); lineView.background = null }
+	  } else if (cls) {
+	    var wrap = ensureLineWrapped(lineView)
+	    lineView.background = wrap.insertBefore(elt("div", null, cls), wrap.firstChild)
+	  }
+	}
+
+	// Wrapper around buildLineContent which will reuse the structure
+	// in display.externalMeasured when possible.
+	function getLineContent(cm, lineView) {
+	  var ext = cm.display.externalMeasured
+	  if (ext && ext.line == lineView.line) {
+	    cm.display.externalMeasured = null
+	    lineView.measure = ext.measure
+	    return ext.built
+	  }
+	  return buildLineContent(cm, lineView)
+	}
+
+	// Redraw the line's text. Interacts with the background and text
+	// classes because the mode may output tokens that influence these
+	// classes.
+	function updateLineText(cm, lineView) {
+	  var cls = lineView.text.className
+	  var built = getLineContent(cm, lineView)
+	  if (lineView.text == lineView.node) { lineView.node = built.pre }
+	  lineView.text.parentNode.replaceChild(built.pre, lineView.text)
+	  lineView.text = built.pre
+	  if (built.bgClass != lineView.bgClass || built.textClass != lineView.textClass) {
+	    lineView.bgClass = built.bgClass
+	    lineView.textClass = built.textClass
+	    updateLineClasses(lineView)
+	  } else if (cls) {
+	    lineView.text.className = cls
+	  }
+	}
+
+	function updateLineClasses(lineView) {
+	  updateLineBackground(lineView)
+	  if (lineView.line.wrapClass)
+	    { ensureLineWrapped(lineView).className = lineView.line.wrapClass }
+	  else if (lineView.node != lineView.text)
+	    { lineView.node.className = "" }
+	  var textClass = lineView.textClass ? lineView.textClass + " " + (lineView.line.textClass || "") : lineView.line.textClass
+	  lineView.text.className = textClass || ""
+	}
+
+	function updateLineGutter(cm, lineView, lineN, dims) {
+	  if (lineView.gutter) {
+	    lineView.node.removeChild(lineView.gutter)
+	    lineView.gutter = null
+	  }
+	  if (lineView.gutterBackground) {
+	    lineView.node.removeChild(lineView.gutterBackground)
+	    lineView.gutterBackground = null
+	  }
+	  if (lineView.line.gutterClass) {
+	    var wrap = ensureLineWrapped(lineView)
+	    lineView.gutterBackground = elt("div", null, "CodeMirror-gutter-background " + lineView.line.gutterClass,
+	                                    ("left: " + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + "px; width: " + (dims.gutterTotalWidth) + "px"))
+	    wrap.insertBefore(lineView.gutterBackground, lineView.text)
+	  }
+	  var markers = lineView.line.gutterMarkers
+	  if (cm.options.lineNumbers || markers) {
+	    var wrap$1 = ensureLineWrapped(lineView)
+	    var gutterWrap = lineView.gutter = elt("div", null, "CodeMirror-gutter-wrapper", ("left: " + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + "px"))
+	    cm.display.input.setUneditable(gutterWrap)
+	    wrap$1.insertBefore(gutterWrap, lineView.text)
+	    if (lineView.line.gutterClass)
+	      { gutterWrap.className += " " + lineView.line.gutterClass }
+	    if (cm.options.lineNumbers && (!markers || !markers["CodeMirror-linenumbers"]))
+	      { lineView.lineNumber = gutterWrap.appendChild(
+	        elt("div", lineNumberFor(cm.options, lineN),
+	            "CodeMirror-linenumber CodeMirror-gutter-elt",
+	            ("left: " + (dims.gutterLeft["CodeMirror-linenumbers"]) + "px; width: " + (cm.display.lineNumInnerWidth) + "px"))) }
+	    if (markers) { for (var k = 0; k < cm.options.gutters.length; ++k) {
+	      var id = cm.options.gutters[k], found = markers.hasOwnProperty(id) && markers[id]
+	      if (found)
+	        { gutterWrap.appendChild(elt("div", [found], "CodeMirror-gutter-elt",
+	                                   ("left: " + (dims.gutterLeft[id]) + "px; width: " + (dims.gutterWidth[id]) + "px"))) }
+	    } }
+	  }
+	}
+
+	function updateLineWidgets(cm, lineView, dims) {
+	  if (lineView.alignable) { lineView.alignable = null }
+	  for (var node = lineView.node.firstChild, next = (void 0); node; node = next) {
+	    next = node.nextSibling
+	    if (node.className == "CodeMirror-linewidget")
+	      { lineView.node.removeChild(node) }
+	  }
+	  insertLineWidgets(cm, lineView, dims)
+	}
+
+	// Build a line's DOM representation from scratch
+	function buildLineElement(cm, lineView, lineN, dims) {
+	  var built = getLineContent(cm, lineView)
+	  lineView.text = lineView.node = built.pre
+	  if (built.bgClass) { lineView.bgClass = built.bgClass }
+	  if (built.textClass) { lineView.textClass = built.textClass }
+
+	  updateLineClasses(lineView)
+	  updateLineGutter(cm, lineView, lineN, dims)
+	  insertLineWidgets(cm, lineView, dims)
+	  return lineView.node
+	}
+
+	// A lineView may contain multiple logical lines (when merged by
+	// collapsed spans). The widgets for all of them need to be drawn.
+	function insertLineWidgets(cm, lineView, dims) {
+	  insertLineWidgetsFor(cm, lineView.line, lineView, dims, true)
+	  if (lineView.rest) { for (var i = 0; i < lineView.rest.length; i++)
+	    { insertLineWidgetsFor(cm, lineView.rest[i], lineView, dims, false) } }
+	}
+
+	function insertLineWidgetsFor(cm, line, lineView, dims, allowAbove) {
+	  if (!line.widgets) { return }
+	  var wrap = ensureLineWrapped(lineView)
+	  for (var i = 0, ws = line.widgets; i < ws.length; ++i) {
+	    var widget = ws[i], node = elt("div", [widget.node], "CodeMirror-linewidget")
+	    if (!widget.handleMouseEvents) { node.setAttribute("cm-ignore-events", "true") }
+	    positionLineWidget(widget, node, lineView, dims)
+	    cm.display.input.setUneditable(node)
+	    if (allowAbove && widget.above)
+	      { wrap.insertBefore(node, lineView.gutter || lineView.text) }
+	    else
+	      { wrap.appendChild(node) }
+	    signalLater(widget, "redraw")
+	  }
+	}
+
+	function positionLineWidget(widget, node, lineView, dims) {
+	  if (widget.noHScroll) {
+	    ;(lineView.alignable || (lineView.alignable = [])).push(node)
+	    var width = dims.wrapperWidth
+	    node.style.left = dims.fixedPos + "px"
+	    if (!widget.coverGutter) {
+	      width -= dims.gutterTotalWidth
+	      node.style.paddingLeft = dims.gutterTotalWidth + "px"
+	    }
+	    node.style.width = width + "px"
+	  }
+	  if (widget.coverGutter) {
+	    node.style.zIndex = 5
+	    node.style.position = "relative"
+	    if (!widget.noHScroll) { node.style.marginLeft = -dims.gutterTotalWidth + "px" }
+	  }
+	}
+
+	function widgetHeight(widget) {
+	  if (widget.height != null) { return widget.height }
+	  var cm = widget.doc.cm
+	  if (!cm) { return 0 }
+	  if (!contains(document.body, widget.node)) {
+	    var parentStyle = "position: relative;"
+	    if (widget.coverGutter)
+	      { parentStyle += "margin-left: -" + cm.display.gutters.offsetWidth + "px;" }
+	    if (widget.noHScroll)
+	      { parentStyle += "width: " + cm.display.wrapper.clientWidth + "px;" }
+	    removeChildrenAndAdd(cm.display.measure, elt("div", [widget.node], null, parentStyle))
+	  }
+	  return widget.height = widget.node.parentNode.offsetHeight
+	}
+
+	// Return true when the given mouse event happened in a widget
+	function eventInWidget(display, e) {
+	  for (var n = e_target(e); n != display.wrapper; n = n.parentNode) {
+	    if (!n || (n.nodeType == 1 && n.getAttribute("cm-ignore-events") == "true") ||
+	        (n.parentNode == display.sizer && n != display.mover))
+	      { return true }
+	  }
+	}
+
+	// POSITION MEASUREMENT
+
+	function paddingTop(display) {return display.lineSpace.offsetTop}
+	function paddingVert(display) {return display.mover.offsetHeight - display.lineSpace.offsetHeight}
+	function paddingH(display) {
+	  if (display.cachedPaddingH) { return display.cachedPaddingH }
+	  var e = removeChildrenAndAdd(display.measure, elt("pre", "x"))
+	  var style = window.getComputedStyle ? window.getComputedStyle(e) : e.currentStyle
+	  var data = {left: parseInt(style.paddingLeft), right: parseInt(style.paddingRight)}
+	  if (!isNaN(data.left) && !isNaN(data.right)) { display.cachedPaddingH = data }
+	  return data
+	}
+
+	function scrollGap(cm) { return scrollerGap - cm.display.nativeBarWidth }
+	function displayWidth(cm) {
+	  return cm.display.scroller.clientWidth - scrollGap(cm) - cm.display.barWidth
+	}
+	function displayHeight(cm) {
+	  return cm.display.scroller.clientHeight - scrollGap(cm) - cm.display.barHeight
+	}
+
+	// Ensure the lineView.wrapping.heights array is populated. This is
+	// an array of bottom offsets for the lines that make up a drawn
+	// line. When lineWrapping is on, there might be more than one
+	// height.
+	function ensureLineHeights(cm, lineView, rect) {
+	  var wrapping = cm.options.lineWrapping
+	  var curWidth = wrapping && displayWidth(cm)
+	  if (!lineView.measure.heights || wrapping && lineView.measure.width != curWidth) {
+	    var heights = lineView.measure.heights = []
+	    if (wrapping) {
+	      lineView.measure.width = curWidth
+	      var rects = lineView.text.firstChild.getClientRects()
+	      for (var i = 0; i < rects.length - 1; i++) {
+	        var cur = rects[i], next = rects[i + 1]
+	        if (Math.abs(cur.bottom - next.bottom) > 2)
+	          { heights.push((cur.bottom + next.top) / 2 - rect.top) }
+	      }
+	    }
+	    heights.push(rect.bottom - rect.top)
+	  }
+	}
+
+	// Find a line map (mapping character offsets to text nodes) and a
+	// measurement cache for the given line number. (A line view might
+	// contain multiple lines when collapsed ranges are present.)
+	function mapFromLineView(lineView, line, lineN) {
+	  if (lineView.line == line)
+	    { return {map: lineView.measure.map, cache: lineView.measure.cache} }
+	  for (var i = 0; i < lineView.rest.length; i++)
+	    { if (lineView.rest[i] == line)
+	      { return {map: lineView.measure.maps[i], cache: lineView.measure.caches[i]} } }
+	  for (var i$1 = 0; i$1 < lineView.rest.length; i$1++)
+	    { if (lineNo(lineView.rest[i$1]) > lineN)
+	      { return {map: lineView.measure.maps[i$1], cache: lineView.measure.caches[i$1], before: true} } }
+	}
+
+	// Render a line into the hidden node display.externalMeasured. Used
+	// when measurement is needed for a line that's not in the viewport.
+	function updateExternalMeasurement(cm, line) {
+	  line = visualLine(line)
+	  var lineN = lineNo(line)
+	  var view = cm.display.externalMeasured = new LineView(cm.doc, line, lineN)
+	  view.lineN = lineN
+	  var built = view.built = buildLineContent(cm, view)
+	  view.text = built.pre
+	  removeChildrenAndAdd(cm.display.lineMeasure, built.pre)
+	  return view
+	}
+
+	// Get a {top, bottom, left, right} box (in line-local coordinates)
+	// for a given character.
+	function measureChar(cm, line, ch, bias) {
+	  return measureCharPrepared(cm, prepareMeasureForLine(cm, line), ch, bias)
+	}
+
+	// Find a line view that corresponds to the given line number.
+	function findViewForLine(cm, lineN) {
+	  if (lineN >= cm.display.viewFrom && lineN < cm.display.viewTo)
+	    { return cm.display.view[findViewIndex(cm, lineN)] }
+	  var ext = cm.display.externalMeasured
+	  if (ext && lineN >= ext.lineN && lineN < ext.lineN + ext.size)
+	    { return ext }
+	}
+
+	// Measurement can be split in two steps, the set-up work that
+	// applies to the whole line, and the measurement of the actual
+	// character. Functions like coordsChar, that need to do a lot of
+	// measurements in a row, can thus ensure that the set-up work is
+	// only done once.
+	function prepareMeasureForLine(cm, line) {
+	  var lineN = lineNo(line)
+	  var view = findViewForLine(cm, lineN)
+	  if (view && !view.text) {
+	    view = null
+	  } else if (view && view.changes) {
+	    updateLineForChanges(cm, view, lineN, getDimensions(cm))
+	    cm.curOp.forceUpdate = true
+	  }
+	  if (!view)
+	    { view = updateExternalMeasurement(cm, line) }
+
+	  var info = mapFromLineView(view, line, lineN)
+	  return {
+	    line: line, view: view, rect: null,
+	    map: info.map, cache: info.cache, before: info.before,
+	    hasHeights: false
+	  }
+	}
+
+	// Given a prepared measurement object, measures the position of an
+	// actual character (or fetches it from the cache).
+	function measureCharPrepared(cm, prepared, ch, bias, varHeight) {
+	  if (prepared.before) { ch = -1 }
+	  var key = ch + (bias || ""), found
+	  if (prepared.cache.hasOwnProperty(key)) {
+	    found = prepared.cache[key]
+	  } else {
+	    if (!prepared.rect)
+	      { prepared.rect = prepared.view.text.getBoundingClientRect() }
+	    if (!prepared.hasHeights) {
+	      ensureLineHeights(cm, prepared.view, prepared.rect)
+	      prepared.hasHeights = true
+	    }
+	    found = measureCharInner(cm, prepared, ch, bias)
+	    if (!found.bogus) { prepared.cache[key] = found }
+	  }
+	  return {left: found.left, right: found.right,
+	          top: varHeight ? found.rtop : found.top,
+	          bottom: varHeight ? found.rbottom : found.bottom}
+	}
+
+	var nullRect = {left: 0, right: 0, top: 0, bottom: 0}
+
+	function nodeAndOffsetInLineMap(map, ch, bias) {
+	  var node, start, end, collapse, mStart, mEnd
+	  // First, search the line map for the text node corresponding to,
+	  // or closest to, the target character.
+	  for (var i = 0; i < map.length; i += 3) {
+	    mStart = map[i]
+	    mEnd = map[i + 1]
+	    if (ch < mStart) {
+	      start = 0; end = 1
+	      collapse = "left"
+	    } else if (ch < mEnd) {
+	      start = ch - mStart
+	      end = start + 1
+	    } else if (i == map.length - 3 || ch == mEnd && map[i + 3] > ch) {
+	      end = mEnd - mStart
+	      start = end - 1
+	      if (ch >= mEnd) { collapse = "right" }
+	    }
+	    if (start != null) {
+	      node = map[i + 2]
+	      if (mStart == mEnd && bias == (node.insertLeft ? "left" : "right"))
+	        { collapse = bias }
+	      if (bias == "left" && start == 0)
+	        { while (i && map[i - 2] == map[i - 3] && map[i - 1].insertLeft) {
+	          node = map[(i -= 3) + 2]
+	          collapse = "left"
+	        } }
+	      if (bias == "right" && start == mEnd - mStart)
+	        { while (i < map.length - 3 && map[i + 3] == map[i + 4] && !map[i + 5].insertLeft) {
+	          node = map[(i += 3) + 2]
+	          collapse = "right"
+	        } }
+	      break
+	    }
+	  }
+	  return {node: node, start: start, end: end, collapse: collapse, coverStart: mStart, coverEnd: mEnd}
+	}
+
+	function getUsefulRect(rects, bias) {
+	  var rect = nullRect
+	  if (bias == "left") { for (var i = 0; i < rects.length; i++) {
+	    if ((rect = rects[i]).left != rect.right) { break }
+	  } } else { for (var i$1 = rects.length - 1; i$1 >= 0; i$1--) {
+	    if ((rect = rects[i$1]).left != rect.right) { break }
+	  } }
+	  return rect
+	}
+
+	function measureCharInner(cm, prepared, ch, bias) {
+	  var place = nodeAndOffsetInLineMap(prepared.map, ch, bias)
+	  var node = place.node, start = place.start, end = place.end, collapse = place.collapse
+
+	  var rect
+	  if (node.nodeType == 3) { // If it is a text node, use a range to retrieve the coordinates.
+	    for (var i$1 = 0; i$1 < 4; i$1++) { // Retry a maximum of 4 times when nonsense rectangles are returned
+	      while (start && isExtendingChar(prepared.line.text.charAt(place.coverStart + start))) { --start }
+	      while (place.coverStart + end < place.coverEnd && isExtendingChar(prepared.line.text.charAt(place.coverStart + end))) { ++end }
+	      if (ie && ie_version < 9 && start == 0 && end == place.coverEnd - place.coverStart)
+	        { rect = node.parentNode.getBoundingClientRect() }
+	      else
+	        { rect = getUsefulRect(range(node, start, end).getClientRects(), bias) }
+	      if (rect.left || rect.right || start == 0) { break }
+	      end = start
+	      start = start - 1
+	      collapse = "right"
+	    }
+	    if (ie && ie_version < 11) { rect = maybeUpdateRectForZooming(cm.display.measure, rect) }
+	  } else { // If it is a widget, simply get the box for the whole widget.
+	    if (start > 0) { collapse = bias = "right" }
+	    var rects
+	    if (cm.options.lineWrapping && (rects = node.getClientRects()).length > 1)
+	      { rect = rects[bias == "right" ? rects.length - 1 : 0] }
+	    else
+	      { rect = node.getBoundingClientRect() }
+	  }
+	  if (ie && ie_version < 9 && !start && (!rect || !rect.left && !rect.right)) {
+	    var rSpan = node.parentNode.getClientRects()[0]
+	    if (rSpan)
+	      { rect = {left: rSpan.left, right: rSpan.left + charWidth(cm.display), top: rSpan.top, bottom: rSpan.bottom} }
+	    else
+	      { rect = nullRect }
+	  }
+
+	  var rtop = rect.top - prepared.rect.top, rbot = rect.bottom - prepared.rect.top
+	  var mid = (rtop + rbot) / 2
+	  var heights = prepared.view.measure.heights
+	  var i = 0
+	  for (; i < heights.length - 1; i++)
+	    { if (mid < heights[i]) { break } }
+	  var top = i ? heights[i - 1] : 0, bot = heights[i]
+	  var result = {left: (collapse == "right" ? rect.right : rect.left) - prepared.rect.left,
+	                right: (collapse == "left" ? rect.left : rect.right) - prepared.rect.left,
+	                top: top, bottom: bot}
+	  if (!rect.left && !rect.right) { result.bogus = true }
+	  if (!cm.options.singleCursorHeightPerLine) { result.rtop = rtop; result.rbottom = rbot }
+
+	  return result
+	}
+
+	// Work around problem with bounding client rects on ranges being
+	// returned incorrectly when zoomed on IE10 and below.
+	function maybeUpdateRectForZooming(measure, rect) {
+	  if (!window.screen || screen.logicalXDPI == null ||
+	      screen.logicalXDPI == screen.deviceXDPI || !hasBadZoomedRects(measure))
+	    { return rect }
+	  var scaleX = screen.logicalXDPI / screen.deviceXDPI
+	  var scaleY = screen.logicalYDPI / screen.deviceYDPI
+	  return {left: rect.left * scaleX, right: rect.right * scaleX,
+	          top: rect.top * scaleY, bottom: rect.bottom * scaleY}
+	}
+
+	function clearLineMeasurementCacheFor(lineView) {
+	  if (lineView.measure) {
+	    lineView.measure.cache = {}
+	    lineView.measure.heights = null
+	    if (lineView.rest) { for (var i = 0; i < lineView.rest.length; i++)
+	      { lineView.measure.caches[i] = {} } }
+	  }
+	}
+
+	function clearLineMeasurementCache(cm) {
+	  cm.display.externalMeasure = null
+	  removeChildren(cm.display.lineMeasure)
+	  for (var i = 0; i < cm.display.view.length; i++)
+	    { clearLineMeasurementCacheFor(cm.display.view[i]) }
+	}
+
+	function clearCaches(cm) {
+	  clearLineMeasurementCache(cm)
+	  cm.display.cachedCharWidth = cm.display.cachedTextHeight = cm.display.cachedPaddingH = null
+	  if (!cm.options.lineWrapping) { cm.display.maxLineChanged = true }
+	  cm.display.lineNumChars = null
+	}
+
+	function pageScrollX() { return window.pageXOffset || (document.documentElement || document.body).scrollLeft }
+	function pageScrollY() { return window.pageYOffset || (document.documentElement || document.body).scrollTop }
+
+	// Converts a {top, bottom, left, right} box from line-local
+	// coordinates into another coordinate system. Context may be one of
+	// "line", "div" (display.lineDiv), "local"./null (editor), "window",
+	// or "page".
+	function intoCoordSystem(cm, lineObj, rect, context, includeWidgets) {
+	  if (!includeWidgets && lineObj.widgets) { for (var i = 0; i < lineObj.widgets.length; ++i) { if (lineObj.widgets[i].above) {
+	    var size = widgetHeight(lineObj.widgets[i])
+	    rect.top += size; rect.bottom += size
+	  } } }
+	  if (context == "line") { return rect }
+	  if (!context) { context = "local" }
+	  var yOff = heightAtLine(lineObj)
+	  if (context == "local") { yOff += paddingTop(cm.display) }
+	  else { yOff -= cm.display.viewOffset }
+	  if (context == "page" || context == "window") {
+	    var lOff = cm.display.lineSpace.getBoundingClientRect()
+	    yOff += lOff.top + (context == "window" ? 0 : pageScrollY())
+	    var xOff = lOff.left + (context == "window" ? 0 : pageScrollX())
+	    rect.left += xOff; rect.right += xOff
+	  }
+	  rect.top += yOff; rect.bottom += yOff
+	  return rect
+	}
+
+	// Coverts a box from "div" coords to another coordinate system.
+	// Context may be "window", "page", "div", or "local"./null.
+	function fromCoordSystem(cm, coords, context) {
+	  if (context == "div") { return coords }
+	  var left = coords.left, top = coords.top
+	  // First move into "page" coordinate system
+	  if (context == "page") {
+	    left -= pageScrollX()
+	    top -= pageScrollY()
+	  } else if (context == "local" || !context) {
+	    var localBox = cm.display.sizer.getBoundingClientRect()
+	    left += localBox.left
+	    top += localBox.top
+	  }
+
+	  var lineSpaceBox = cm.display.lineSpace.getBoundingClientRect()
+	  return {left: left - lineSpaceBox.left, top: top - lineSpaceBox.top}
+	}
+
+	function charCoords(cm, pos, context, lineObj, bias) {
+	  if (!lineObj) { lineObj = getLine(cm.doc, pos.line) }
+	  return intoCoordSystem(cm, lineObj, measureChar(cm, lineObj, pos.ch, bias), context)
+	}
+
+	// Returns a box for a given cursor position, which may have an
+	// 'other' property containing the position of the secondary cursor
+	// on a bidi boundary.
+	function cursorCoords(cm, pos, context, lineObj, preparedMeasure, varHeight) {
+	  lineObj = lineObj || getLine(cm.doc, pos.line)
+	  if (!preparedMeasure) { preparedMeasure = prepareMeasureForLine(cm, lineObj) }
+	  function get(ch, right) {
+	    var m = measureCharPrepared(cm, preparedMeasure, ch, right ? "right" : "left", varHeight)
+	    if (right) { m.left = m.right; } else { m.right = m.left }
+	    return intoCoordSystem(cm, lineObj, m, context)
+	  }
+	  function getBidi(ch, partPos) {
+	    var part = order[partPos], right = part.level % 2
+	    if (ch == bidiLeft(part) && partPos && part.level < order[partPos - 1].level) {
+	      part = order[--partPos]
+	      ch = bidiRight(part) - (part.level % 2 ? 0 : 1)
+	      right = true
+	    } else if (ch == bidiRight(part) && partPos < order.length - 1 && part.level < order[partPos + 1].level) {
+	      part = order[++partPos]
+	      ch = bidiLeft(part) - part.level % 2
+	      right = false
+	    }
+	    if (right && ch == part.to && ch > part.from) { return get(ch - 1) }
+	    return get(ch, right)
+	  }
+	  var order = getOrder(lineObj), ch = pos.ch
+	  if (!order) { return get(ch) }
+	  var partPos = getBidiPartAt(order, ch)
+	  var val = getBidi(ch, partPos)
+	  if (bidiOther != null) { val.other = getBidi(ch, bidiOther) }
+	  return val
+	}
+
+	// Used to cheaply estimate the coordinates for a position. Used for
+	// intermediate scroll updates.
+	function estimateCoords(cm, pos) {
+	  var left = 0
+	  pos = clipPos(cm.doc, pos)
+	  if (!cm.options.lineWrapping) { left = charWidth(cm.display) * pos.ch }
+	  var lineObj = getLine(cm.doc, pos.line)
+	  var top = heightAtLine(lineObj) + paddingTop(cm.display)
+	  return {left: left, right: left, top: top, bottom: top + lineObj.height}
+	}
+
+	// Positions returned by coordsChar contain some extra information.
+	// xRel is the relative x position of the input coordinates compared
+	// to the found position (so xRel > 0 means the coordinates are to
+	// the right of the character position, for example). When outside
+	// is true, that means the coordinates lie outside the line's
+	// vertical range.
+	function PosWithInfo(line, ch, outside, xRel) {
+	  var pos = Pos(line, ch)
+	  pos.xRel = xRel
+	  if (outside) { pos.outside = true }
+	  return pos
+	}
+
+	// Compute the character position closest to the given coordinates.
+	// Input must be lineSpace-local ("div" coordinate system).
+	function coordsChar(cm, x, y) {
+	  var doc = cm.doc
+	  y += cm.display.viewOffset
+	  if (y < 0) { return PosWithInfo(doc.first, 0, true, -1) }
+	  var lineN = lineAtHeight(doc, y), last = doc.first + doc.size - 1
+	  if (lineN > last)
+	    { return PosWithInfo(doc.first + doc.size - 1, getLine(doc, last).text.length, true, 1) }
+	  if (x < 0) { x = 0 }
+
+	  var lineObj = getLine(doc, lineN)
+	  for (;;) {
+	    var found = coordsCharInner(cm, lineObj, lineN, x, y)
+	    var merged = collapsedSpanAtEnd(lineObj)
+	    var mergedPos = merged && merged.find(0, true)
+	    if (merged && (found.ch > mergedPos.from.ch || found.ch == mergedPos.from.ch && found.xRel > 0))
+	      { lineN = lineNo(lineObj = mergedPos.to.line) }
+	    else
+	      { return found }
+	  }
+	}
+
+	function coordsCharInner(cm, lineObj, lineNo, x, y) {
+	  var innerOff = y - heightAtLine(lineObj)
+	  var wrongLine = false, adjust = 2 * cm.display.wrapper.clientWidth
+	  var preparedMeasure = prepareMeasureForLine(cm, lineObj)
+
+	  function getX(ch) {
+	    var sp = cursorCoords(cm, Pos(lineNo, ch), "line", lineObj, preparedMeasure)
+	    wrongLine = true
+	    if (innerOff > sp.bottom) { return sp.left - adjust }
+	    else if (innerOff < sp.top) { return sp.left + adjust }
+	    else { wrongLine = false }
+	    return sp.left
+	  }
+
+	  var bidi = getOrder(lineObj), dist = lineObj.text.length
+	  var from = lineLeft(lineObj), to = lineRight(lineObj)
+	  var fromX = getX(from), fromOutside = wrongLine, toX = getX(to), toOutside = wrongLine
+
+	  if (x > toX) { return PosWithInfo(lineNo, to, toOutside, 1) }
+	  // Do a binary search between these bounds.
+	  for (;;) {
+	    if (bidi ? to == from || to == moveVisually(lineObj, from, 1) : to - from <= 1) {
+	      var ch = x < fromX || x - fromX <= toX - x ? from : to
+	      var outside = ch == from ? fromOutside : toOutside
+	      var xDiff = x - (ch == from ? fromX : toX)
+	      // This is a kludge to handle the case where the coordinates
+	      // are after a line-wrapped line. We should replace it with a
+	      // more general handling of cursor positions around line
+	      // breaks. (Issue #4078)
+	      if (toOutside && !bidi && !/\s/.test(lineObj.text.charAt(ch)) && xDiff > 0 &&
+	          ch < lineObj.text.length && preparedMeasure.view.measure.heights.length > 1) {
+	        var charSize = measureCharPrepared(cm, preparedMeasure, ch, "right")
+	        if (innerOff <= charSize.bottom && innerOff >= charSize.top && Math.abs(x - charSize.right) < xDiff) {
+	          outside = false
+	          ch++
+	          xDiff = x - charSize.right
+	        }
+	      }
+	      while (isExtendingChar(lineObj.text.charAt(ch))) { ++ch }
+	      var pos = PosWithInfo(lineNo, ch, outside, xDiff < -1 ? -1 : xDiff > 1 ? 1 : 0)
+	      return pos
+	    }
+	    var step = Math.ceil(dist / 2), middle = from + step
+	    if (bidi) {
+	      middle = from
+	      for (var i = 0; i < step; ++i) { middle = moveVisually(lineObj, middle, 1) }
+	    }
+	    var middleX = getX(middle)
+	    if (middleX > x) {to = middle; toX = middleX; if (toOutside = wrongLine) { toX += 1000; } dist = step}
+	    else {from = middle; fromX = middleX; fromOutside = wrongLine; dist -= step}
+	  }
+	}
+
+	var measureText
+	// Compute the default text height.
+	function textHeight(display) {
+	  if (display.cachedTextHeight != null) { return display.cachedTextHeight }
+	  if (measureText == null) {
+	    measureText = elt("pre")
+	    // Measure a bunch of lines, for browsers that compute
+	    // fractional heights.
+	    for (var i = 0; i < 49; ++i) {
+	      measureText.appendChild(document.createTextNode("x"))
+	      measureText.appendChild(elt("br"))
+	    }
+	    measureText.appendChild(document.createTextNode("x"))
+	  }
+	  removeChildrenAndAdd(display.measure, measureText)
+	  var height = measureText.offsetHeight / 50
+	  if (height > 3) { display.cachedTextHeight = height }
+	  removeChildren(display.measure)
+	  return height || 1
+	}
+
+	// Compute the default character width.
+	function charWidth(display) {
+	  if (display.cachedCharWidth != null) { return display.cachedCharWidth }
+	  var anchor = elt("span", "xxxxxxxxxx")
+	  var pre = elt("pre", [anchor])
+	  removeChildrenAndAdd(display.measure, pre)
+	  var rect = anchor.getBoundingClientRect(), width = (rect.right - rect.left) / 10
+	  if (width > 2) { display.cachedCharWidth = width }
+	  return width || 10
+	}
+
+	// Do a bulk-read of the DOM positions and sizes needed to draw the
+	// view, so that we don't interleave reading and writing to the DOM.
+	function getDimensions(cm) {
+	  var d = cm.display, left = {}, width = {}
+	  var gutterLeft = d.gutters.clientLeft
+	  for (var n = d.gutters.firstChild, i = 0; n; n = n.nextSibling, ++i) {
+	    left[cm.options.gutters[i]] = n.offsetLeft + n.clientLeft + gutterLeft
+	    width[cm.options.gutters[i]] = n.clientWidth
+	  }
+	  return {fixedPos: compensateForHScroll(d),
+	          gutterTotalWidth: d.gutters.offsetWidth,
+	          gutterLeft: left,
+	          gutterWidth: width,
+	          wrapperWidth: d.wrapper.clientWidth}
+	}
+
+	// Computes display.scroller.scrollLeft + display.gutters.offsetWidth,
+	// but using getBoundingClientRect to get a sub-pixel-accurate
+	// result.
+	function compensateForHScroll(display) {
+	  return display.scroller.getBoundingClientRect().left - display.sizer.getBoundingClientRect().left
+	}
+
+	// Returns a function that estimates the height of a line, to use as
+	// first approximation until the line becomes visible (and is thus
+	// properly measurable).
+	function estimateHeight(cm) {
+	  var th = textHeight(cm.display), wrapping = cm.options.lineWrapping
+	  var perLine = wrapping && Math.max(5, cm.display.scroller.clientWidth / charWidth(cm.display) - 3)
+	  return function (line) {
+	    if (lineIsHidden(cm.doc, line)) { return 0 }
+
+	    var widgetsHeight = 0
+	    if (line.widgets) { for (var i = 0; i < line.widgets.length; i++) {
+	      if (line.widgets[i].height) { widgetsHeight += line.widgets[i].height }
+	    } }
+
+	    if (wrapping)
+	      { return widgetsHeight + (Math.ceil(line.text.length / perLine) || 1) * th }
+	    else
+	      { return widgetsHeight + th }
+	  }
+	}
+
+	function estimateLineHeights(cm) {
+	  var doc = cm.doc, est = estimateHeight(cm)
+	  doc.iter(function (line) {
+	    var estHeight = est(line)
+	    if (estHeight != line.height) { updateLineHeight(line, estHeight) }
+	  })
+	}
+
+	// Given a mouse event, find the corresponding position. If liberal
+	// is false, it checks whether a gutter or scrollbar was clicked,
+	// and returns null if it was. forRect is used by rectangular
+	// selections, and tries to estimate a character position even for
+	// coordinates beyond the right of the text.
+	function posFromMouse(cm, e, liberal, forRect) {
+	  var display = cm.display
+	  if (!liberal && e_target(e).getAttribute("cm-not-content") == "true") { return null }
+
+	  var x, y, space = display.lineSpace.getBoundingClientRect()
+	  // Fails unpredictably on IE[67] when mouse is dragged around quickly.
+	  try { x = e.clientX - space.left; y = e.clientY - space.top }
+	  catch (e) { return null }
+	  var coords = coordsChar(cm, x, y), line
+	  if (forRect && coords.xRel == 1 && (line = getLine(cm.doc, coords.line).text).length == coords.ch) {
+	    var colDiff = countColumn(line, line.length, cm.options.tabSize) - line.length
+	    coords = Pos(coords.line, Math.max(0, Math.round((x - paddingH(cm.display).left) / charWidth(cm.display)) - colDiff))
+	  }
+	  return coords
+	}
+
+	// Find the view element corresponding to a given line. Return null
+	// when the line isn't visible.
+	function findViewIndex(cm, n) {
+	  if (n >= cm.display.viewTo) { return null }
+	  n -= cm.display.viewFrom
+	  if (n < 0) { return null }
+	  var view = cm.display.view
+	  for (var i = 0; i < view.length; i++) {
+	    n -= view[i].size
+	    if (n < 0) { return i }
+	  }
+	}
+
+	function updateSelection(cm) {
+	  cm.display.input.showSelection(cm.display.input.prepareSelection())
+	}
+
+	function prepareSelection(cm, primary) {
+	  var doc = cm.doc, result = {}
+	  var curFragment = result.cursors = document.createDocumentFragment()
+	  var selFragment = result.selection = document.createDocumentFragment()
+
+	  for (var i = 0; i < doc.sel.ranges.length; i++) {
+	    if (primary === false && i == doc.sel.primIndex) { continue }
+	    var range = doc.sel.ranges[i]
+	    if (range.from().line >= cm.display.viewTo || range.to().line < cm.display.viewFrom) { continue }
+	    var collapsed = range.empty()
+	    if (collapsed || cm.options.showCursorWhenSelecting)
+	      { drawSelectionCursor(cm, range.head, curFragment) }
+	    if (!collapsed)
+	      { drawSelectionRange(cm, range, selFragment) }
+	  }
+	  return result
+	}
+
+	// Draws a cursor for the given range
+	function drawSelectionCursor(cm, head, output) {
+	  var pos = cursorCoords(cm, head, "div", null, null, !cm.options.singleCursorHeightPerLine)
+
+	  var cursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor"))
+	  cursor.style.left = pos.left + "px"
+	  cursor.style.top = pos.top + "px"
+	  cursor.style.height = Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight + "px"
+
+	  if (pos.other) {
+	    // Secondary cursor, shown when on a 'jump' in bi-directional text
+	    var otherCursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor CodeMirror-secondarycursor"))
+	    otherCursor.style.display = ""
+	    otherCursor.style.left = pos.other.left + "px"
+	    otherCursor.style.top = pos.other.top + "px"
+	    otherCursor.style.height = (pos.other.bottom - pos.other.top) * .85 + "px"
+	  }
+	}
+
+	// Draws the given range as a highlighted selection
+	function drawSelectionRange(cm, range, output) {
+	  var display = cm.display, doc = cm.doc
+	  var fragment = document.createDocumentFragment()
+	  var padding = paddingH(cm.display), leftSide = padding.left
+	  var rightSide = Math.max(display.sizerWidth, displayWidth(cm) - display.sizer.offsetLeft) - padding.right
+
+	  function add(left, top, width, bottom) {
+	    if (top < 0) { top = 0 }
+	    top = Math.round(top)
+	    bottom = Math.round(bottom)
+	    fragment.appendChild(elt("div", null, "CodeMirror-selected", ("position: absolute; left: " + left + "px;\n                             top: " + top + "px; width: " + (width == null ? rightSide - left : width) + "px;\n                             height: " + (bottom - top) + "px")))
+	  }
+
+	  function drawForLine(line, fromArg, toArg) {
+	    var lineObj = getLine(doc, line)
+	    var lineLen = lineObj.text.length
+	    var start, end
+	    function coords(ch, bias) {
+	      return charCoords(cm, Pos(line, ch), "div", lineObj, bias)
+	    }
+
+	    iterateBidiSections(getOrder(lineObj), fromArg || 0, toArg == null ? lineLen : toArg, function (from, to, dir) {
+	      var leftPos = coords(from, "left"), rightPos, left, right
+	      if (from == to) {
+	        rightPos = leftPos
+	        left = right = leftPos.left
+	      } else {
+	        rightPos = coords(to - 1, "right")
+	        if (dir == "rtl") { var tmp = leftPos; leftPos = rightPos; rightPos = tmp }
+	        left = leftPos.left
+	        right = rightPos.right
+	      }
+	      if (fromArg == null && from == 0) { left = leftSide }
+	      if (rightPos.top - leftPos.top > 3) { // Different lines, draw top part
+	        add(left, leftPos.top, null, leftPos.bottom)
+	        left = leftSide
+	        if (leftPos.bottom < rightPos.top) { add(left, leftPos.bottom, null, rightPos.top) }
+	      }
+	      if (toArg == null && to == lineLen) { right = rightSide }
+	      if (!start || leftPos.top < start.top || leftPos.top == start.top && leftPos.left < start.left)
+	        { start = leftPos }
+	      if (!end || rightPos.bottom > end.bottom || rightPos.bottom == end.bottom && rightPos.right > end.right)
+	        { end = rightPos }
+	      if (left < leftSide + 1) { left = leftSide }
+	      add(left, rightPos.top, right - left, rightPos.bottom)
+	    })
+	    return {start: start, end: end}
+	  }
+
+	  var sFrom = range.from(), sTo = range.to()
+	  if (sFrom.line == sTo.line) {
+	    drawForLine(sFrom.line, sFrom.ch, sTo.ch)
+	  } else {
+	    var fromLine = getLine(doc, sFrom.line), toLine = getLine(doc, sTo.line)
+	    var singleVLine = visualLine(fromLine) == visualLine(toLine)
+	    var leftEnd = drawForLine(sFrom.line, sFrom.ch, singleVLine ? fromLine.text.length + 1 : null).end
+	    var rightStart = drawForLine(sTo.line, singleVLine ? 0 : null, sTo.ch).start
+	    if (singleVLine) {
+	      if (leftEnd.top < rightStart.top - 2) {
+	        add(leftEnd.right, leftEnd.top, null, leftEnd.bottom)
+	        add(leftSide, rightStart.top, rightStart.left, rightStart.bottom)
+	      } else {
+	        add(leftEnd.right, leftEnd.top, rightStart.left - leftEnd.right, leftEnd.bottom)
+	      }
+	    }
+	    if (leftEnd.bottom < rightStart.top)
+	      { add(leftSide, leftEnd.bottom, null, rightStart.top) }
+	  }
+
+	  output.appendChild(fragment)
+	}
+
+	// Cursor-blinking
+	function restartBlink(cm) {
+	  if (!cm.state.focused) { return }
+	  var display = cm.display
+	  clearInterval(display.blinker)
+	  var on = true
+	  display.cursorDiv.style.visibility = ""
+	  if (cm.options.cursorBlinkRate > 0)
+	    { display.blinker = setInterval(function () { return display.cursorDiv.style.visibility = (on = !on) ? "" : "hidden"; },
+	      cm.options.cursorBlinkRate) }
+	  else if (cm.options.cursorBlinkRate < 0)
+	    { display.cursorDiv.style.visibility = "hidden" }
+	}
+
+	function ensureFocus(cm) {
+	  if (!cm.state.focused) { cm.display.input.focus(); onFocus(cm) }
+	}
+
+	function delayBlurEvent(cm) {
+	  cm.state.delayingBlurEvent = true
+	  setTimeout(function () { if (cm.state.delayingBlurEvent) {
+	    cm.state.delayingBlurEvent = false
+	    onBlur(cm)
+	  } }, 100)
+	}
+
+	function onFocus(cm, e) {
+	  if (cm.state.delayingBlurEvent) { cm.state.delayingBlurEvent = false }
+
+	  if (cm.options.readOnly == "nocursor") { return }
+	  if (!cm.state.focused) {
+	    signal(cm, "focus", cm, e)
+	    cm.state.focused = true
+	    addClass(cm.display.wrapper, "CodeMirror-focused")
+	    // This test prevents this from firing when a context
+	    // menu is closed (since the input reset would kill the
+	    // select-all detection hack)
+	    if (!cm.curOp && cm.display.selForContextMenu != cm.doc.sel) {
+	      cm.display.input.reset()
+	      if (webkit) { setTimeout(function () { return cm.display.input.reset(true); }, 20) } // Issue #1730
+	    }
+	    cm.display.input.receivedFocus()
+	  }
+	  restartBlink(cm)
+	}
+	function onBlur(cm, e) {
+	  if (cm.state.delayingBlurEvent) { return }
+
+	  if (cm.state.focused) {
+	    signal(cm, "blur", cm, e)
+	    cm.state.focused = false
+	    rmClass(cm.display.wrapper, "CodeMirror-focused")
+	  }
+	  clearInterval(cm.display.blinker)
+	  setTimeout(function () { if (!cm.state.focused) { cm.display.shift = false } }, 150)
+	}
+
+	// Re-align line numbers and gutter marks to compensate for
+	// horizontal scrolling.
+	function alignHorizontally(cm) {
+	  var display = cm.display, view = display.view
+	  if (!display.alignWidgets && (!display.gutters.firstChild || !cm.options.fixedGutter)) { return }
+	  var comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.doc.scrollLeft
+	  var gutterW = display.gutters.offsetWidth, left = comp + "px"
+	  for (var i = 0; i < view.length; i++) { if (!view[i].hidden) {
+	    if (cm.options.fixedGutter) {
+	      if (view[i].gutter)
+	        { view[i].gutter.style.left = left }
+	      if (view[i].gutterBackground)
+	        { view[i].gutterBackground.style.left = left }
+	    }
+	    var align = view[i].alignable
+	    if (align) { for (var j = 0; j < align.length; j++)
+	      { align[j].style.left = left } }
+	  } }
+	  if (cm.options.fixedGutter)
+	    { display.gutters.style.left = (comp + gutterW) + "px" }
+	}
+
+	// Used to ensure that the line number gutter is still the right
+	// size for the current document size. Returns true when an update
+	// is needed.
+	function maybeUpdateLineNumberWidth(cm) {
+	  if (!cm.options.lineNumbers) { return false }
+	  var doc = cm.doc, last = lineNumberFor(cm.options, doc.first + doc.size - 1), display = cm.display
+	  if (last.length != display.lineNumChars) {
+	    var test = display.measure.appendChild(elt("div", [elt("div", last)],
+	                                               "CodeMirror-linenumber CodeMirror-gutter-elt"))
+	    var innerW = test.firstChild.offsetWidth, padding = test.offsetWidth - innerW
+	    display.lineGutter.style.width = ""
+	    display.lineNumInnerWidth = Math.max(innerW, display.lineGutter.offsetWidth - padding) + 1
+	    display.lineNumWidth = display.lineNumInnerWidth + padding
+	    display.lineNumChars = display.lineNumInnerWidth ? last.length : -1
+	    display.lineGutter.style.width = display.lineNumWidth + "px"
+	    updateGutterSpace(cm)
+	    return true
+	  }
+	  return false
+	}
+
+	// Read the actual heights of the rendered lines, and update their
+	// stored heights to match.
+	function updateHeightsInViewport(cm) {
+	  var display = cm.display
+	  var prevBottom = display.lineDiv.offsetTop
+	  for (var i = 0; i < display.view.length; i++) {
+	    var cur = display.view[i], height = (void 0)
+	    if (cur.hidden) { continue }
+	    if (ie && ie_version < 8) {
+	      var bot = cur.node.offsetTop + cur.node.offsetHeight
+	      height = bot - prevBottom
+	      prevBottom = bot
+	    } else {
+	      var box = cur.node.getBoundingClientRect()
+	      height = box.bottom - box.top
+	    }
+	    var diff = cur.line.height - height
+	    if (height < 2) { height = textHeight(display) }
+	    if (diff > .001 || diff < -.001) {
+	      updateLineHeight(cur.line, height)
+	      updateWidgetHeight(cur.line)
+	      if (cur.rest) { for (var j = 0; j < cur.rest.length; j++)
+	        { updateWidgetHeight(cur.rest[j]) } }
+	    }
+	  }
+	}
+
+	// Read and store the height of line widgets associated with the
+	// given line.
+	function updateWidgetHeight(line) {
+	  if (line.widgets) { for (var i = 0; i < line.widgets.length; ++i)
+	    { line.widgets[i].height = line.widgets[i].node.parentNode.offsetHeight } }
+	}
+
+	// Compute the lines that are visible in a given viewport (defaults
+	// the the current scroll position). viewport may contain top,
+	// height, and ensure (see op.scrollToPos) properties.
+	function visibleLines(display, doc, viewport) {
+	  var top = viewport && viewport.top != null ? Math.max(0, viewport.top) : display.scroller.scrollTop
+	  top = Math.floor(top - paddingTop(display))
+	  var bottom = viewport && viewport.bottom != null ? viewport.bottom : top + display.wrapper.clientHeight
+
+	  var from = lineAtHeight(doc, top), to = lineAtHeight(doc, bottom)
+	  // Ensure is a {from: {line, ch}, to: {line, ch}} object, and
+	  // forces those lines into the viewport (if possible).
+	  if (viewport && viewport.ensure) {
+	    var ensureFrom = viewport.ensure.from.line, ensureTo = viewport.ensure.to.line
+	    if (ensureFrom < from) {
+	      from = ensureFrom
+	      to = lineAtHeight(doc, heightAtLine(getLine(doc, ensureFrom)) + display.wrapper.clientHeight)
+	    } else if (Math.min(ensureTo, doc.lastLine()) >= to) {
+	      from = lineAtHeight(doc, heightAtLine(getLine(doc, ensureTo)) - display.wrapper.clientHeight)
+	      to = ensureTo
+	    }
+	  }
+	  return {from: from, to: Math.max(to, from + 1)}
+	}
+
+	// Sync the scrollable area and scrollbars, ensure the viewport
+	// covers the visible area.
+	function setScrollTop(cm, val) {
+	  if (Math.abs(cm.doc.scrollTop - val) < 2) { return }
+	  cm.doc.scrollTop = val
+	  if (!gecko) { updateDisplaySimple(cm, {top: val}) }
+	  if (cm.display.scroller.scrollTop != val) { cm.display.scroller.scrollTop = val }
+	  cm.display.scrollbars.setScrollTop(val)
+	  if (gecko) { updateDisplaySimple(cm) }
+	  startWorker(cm, 100)
+	}
+	// Sync scroller and scrollbar, ensure the gutter elements are
+	// aligned.
+	function setScrollLeft(cm, val, isScroller) {
+	  if (isScroller ? val == cm.doc.scrollLeft : Math.abs(cm.doc.scrollLeft - val) < 2) { return }
+	  val = Math.min(val, cm.display.scroller.scrollWidth - cm.display.scroller.clientWidth)
+	  cm.doc.scrollLeft = val
+	  alignHorizontally(cm)
+	  if (cm.display.scroller.scrollLeft != val) { cm.display.scroller.scrollLeft = val }
+	  cm.display.scrollbars.setScrollLeft(val)
+	}
+
+	// Since the delta values reported on mouse wheel events are
+	// unstandardized between browsers and even browser versions, and
+	// generally horribly unpredictable, this code starts by measuring
+	// the scroll effect that the first few mouse wheel events have,
+	// and, from that, detects the way it can convert deltas to pixel
+	// offsets afterwards.
+	//
+	// The reason we want to know the amount a wheel event will scroll
+	// is that it gives us a chance to update the display before the
+	// actual scrolling happens, reducing flickering.
+
+	var wheelSamples = 0;
+	var wheelPixelsPerUnit = null;
+	// Fill in a browser-detected starting value on browsers where we
+	// know one. These don't have to be accurate -- the result of them
+	// being wrong would just be a slight flicker on the first wheel
+	// scroll (if it is large enough).
+	if (ie) { wheelPixelsPerUnit = -.53 }
+	else if (gecko) { wheelPixelsPerUnit = 15 }
+	else if (chrome) { wheelPixelsPerUnit = -.7 }
+	else if (safari) { wheelPixelsPerUnit = -1/3 }
+
+	function wheelEventDelta(e) {
+	  var dx = e.wheelDeltaX, dy = e.wheelDeltaY
+	  if (dx == null && e.detail && e.axis == e.HORIZONTAL_AXIS) { dx = e.detail }
+	  if (dy == null && e.detail && e.axis == e.VERTICAL_AXIS) { dy = e.detail }
+	  else if (dy == null) { dy = e.wheelDelta }
+	  return {x: dx, y: dy}
+	}
+	function wheelEventPixels(e) {
+	  var delta = wheelEventDelta(e)
+	  delta.x *= wheelPixelsPerUnit
+	  delta.y *= wheelPixelsPerUnit
+	  return delta
+	}
+
+	function onScrollWheel(cm, e) {
+	  var delta = wheelEventDelta(e), dx = delta.x, dy = delta.y
+
+	  var display = cm.display, scroll = display.scroller
+	  // Quit if there's nothing to scroll here
+	  var canScrollX = scroll.scrollWidth > scroll.clientWidth
+	  var canScrollY = scroll.scrollHeight > scroll.clientHeight
+	  if (!(dx && canScrollX || dy && canScrollY)) { return }
+
+	  // Webkit browsers on OS X abort momentum scrolls when the target
+	  // of the scroll event is removed from the scrollable element.
+	  // This hack (see related code in patchDisplay) makes sure the
+	  // element is kept around.
+	  if (dy && mac && webkit) {
+	    outer: for (var cur = e.target, view = display.view; cur != scroll; cur = cur.parentNode) {
+	      for (var i = 0; i < view.length; i++) {
+	        if (view[i].node == cur) {
+	          cm.display.currentWheelTarget = cur
+	          break outer
+	        }
+	      }
+	    }
+	  }
+
+	  // On some browsers, horizontal scrolling will cause redraws to
+	  // happen before the gutter has been realigned, causing it to
+	  // wriggle around in a most unseemly way. When we have an
+	  // estimated pixels/delta value, we just handle horizontal
+	  // scrolling entirely here. It'll be slightly off from native, but
+	  // better than glitching out.
+	  if (dx && !gecko && !presto && wheelPixelsPerUnit != null) {
+	    if (dy && canScrollY)
+	      { setScrollTop(cm, Math.max(0, Math.min(scroll.scrollTop + dy * wheelPixelsPerUnit, scroll.scrollHeight - scroll.clientHeight))) }
+	    setScrollLeft(cm, Math.max(0, Math.min(scroll.scrollLeft + dx * wheelPixelsPerUnit, scroll.scrollWidth - scroll.clientWidth)))
+	    // Only prevent default scrolling if vertical scrolling is
+	    // actually possible. Otherwise, it causes vertical scroll
+	    // jitter on OSX trackpads when deltaX is small and deltaY
+	    // is large (issue #3579)
+	    if (!dy || (dy && canScrollY))
+	      { e_preventDefault(e) }
+	    display.wheelStartX = null // Abort measurement, if in progress
+	    return
+	  }
+
+	  // 'Project' the visible viewport to cover the area that is being
+	  // scrolled into view (if we know enough to estimate it).
+	  if (dy && wheelPixelsPerUnit != null) {
+	    var pixels = dy * wheelPixelsPerUnit
+	    var top = cm.doc.scrollTop, bot = top + display.wrapper.clientHeight
+	    if (pixels < 0) { top = Math.max(0, top + pixels - 50) }
+	    else { bot = Math.min(cm.doc.height, bot + pixels + 50) }
+	    updateDisplaySimple(cm, {top: top, bottom: bot})
+	  }
+
+	  if (wheelSamples < 20) {
+	    if (display.wheelStartX == null) {
+	      display.wheelStartX = scroll.scrollLeft; display.wheelStartY = scroll.scrollTop
+	      display.wheelDX = dx; display.wheelDY = dy
+	      setTimeout(function () {
+	        if (display.wheelStartX == null) { return }
+	        var movedX = scroll.scrollLeft - display.wheelStartX
+	        var movedY = scroll.scrollTop - display.wheelStartY
+	        var sample = (movedY && display.wheelDY && movedY / display.wheelDY) ||
+	          (movedX && display.wheelDX && movedX / display.wheelDX)
+	        display.wheelStartX = display.wheelStartY = null
+	        if (!sample) { return }
+	        wheelPixelsPerUnit = (wheelPixelsPerUnit * wheelSamples + sample) / (wheelSamples + 1)
+	        ++wheelSamples
+	      }, 200)
+	    } else {
+	      display.wheelDX += dx; display.wheelDY += dy
+	    }
+	  }
+	}
+
+	// SCROLLBARS
+
+	// Prepare DOM reads needed to update the scrollbars. Done in one
+	// shot to minimize update/measure roundtrips.
+	function measureForScrollbars(cm) {
+	  var d = cm.display, gutterW = d.gutters.offsetWidth
+	  var docH = Math.round(cm.doc.height + paddingVert(cm.display))
+	  return {
+	    clientHeight: d.scroller.clientHeight,
+	    viewHeight: d.wrapper.clientHeight,
+	    scrollWidth: d.scroller.scrollWidth, clientWidth: d.scroller.clientWidth,
+	    viewWidth: d.wrapper.clientWidth,
+	    barLeft: cm.options.fixedGutter ? gutterW : 0,
+	    docHeight: docH,
+	    scrollHeight: docH + scrollGap(cm) + d.barHeight,
+	    nativeBarWidth: d.nativeBarWidth,
+	    gutterWidth: gutterW
+	  }
+	}
+
+	function NativeScrollbars(place, scroll, cm) {
+	  this.cm = cm
+	  var vert = this.vert = elt("div", [elt("div", null, null, "min-width: 1px")], "CodeMirror-vscrollbar")
+	  var horiz = this.horiz = elt("div", [elt("div", null, null, "height: 100%; min-height: 1px")], "CodeMirror-hscrollbar")
+	  place(vert); place(horiz)
+
+	  on(vert, "scroll", function () {
+	    if (vert.clientHeight) { scroll(vert.scrollTop, "vertical") }
+	  })
+	  on(horiz, "scroll", function () {
+	    if (horiz.clientWidth) { scroll(horiz.scrollLeft, "horizontal") }
+	  })
+
+	  this.checkedZeroWidth = false
+	  // Need to set a minimum width to see the scrollbar on IE7 (but must not set it on IE8).
+	  if (ie && ie_version < 8) { this.horiz.style.minHeight = this.vert.style.minWidth = "18px" }
+	}
+
+	NativeScrollbars.prototype = copyObj({
+	  update: function(measure) {
+	    var needsH = measure.scrollWidth > measure.clientWidth + 1
+	    var needsV = measure.scrollHeight > measure.clientHeight + 1
+	    var sWidth = measure.nativeBarWidth
+
+	    if (needsV) {
+	      this.vert.style.display = "block"
+	      this.vert.style.bottom = needsH ? sWidth + "px" : "0"
+	      var totalHeight = measure.viewHeight - (needsH ? sWidth : 0)
+	      // A bug in IE8 can cause this value to be negative, so guard it.
+	      this.vert.firstChild.style.height =
+	        Math.max(0, measure.scrollHeight - measure.clientHeight + totalHeight) + "px"
+	    } else {
+	      this.vert.style.display = ""
+	      this.vert.firstChild.style.height = "0"
+	    }
+
+	    if (needsH) {
+	      this.horiz.style.display = "block"
+	      this.horiz.style.right = needsV ? sWidth + "px" : "0"
+	      this.horiz.style.left = measure.barLeft + "px"
+	      var totalWidth = measure.viewWidth - measure.barLeft - (needsV ? sWidth : 0)
+	      this.horiz.firstChild.style.width =
+	        (measure.scrollWidth - measure.clientWidth + totalWidth) + "px"
+	    } else {
+	      this.horiz.style.display = ""
+	      this.horiz.firstChild.style.width = "0"
+	    }
+
+	    if (!this.checkedZeroWidth && measure.clientHeight > 0) {
+	      if (sWidth == 0) { this.zeroWidthHack() }
+	      this.checkedZeroWidth = true
+	    }
+
+	    return {right: needsV ? sWidth : 0, bottom: needsH ? sWidth : 0}
+	  },
+	  setScrollLeft: function(pos) {
+	    if (this.horiz.scrollLeft != pos) { this.horiz.scrollLeft = pos }
+	    if (this.disableHoriz) { this.enableZeroWidthBar(this.horiz, this.disableHoriz) }
+	  },
+	  setScrollTop: function(pos) {
+	    if (this.vert.scrollTop != pos) { this.vert.scrollTop = pos }
+	    if (this.disableVert) { this.enableZeroWidthBar(this.vert, this.disableVert) }
+	  },
+	  zeroWidthHack: function() {
+	    var w = mac && !mac_geMountainLion ? "12px" : "18px"
+	    this.horiz.style.height = this.vert.style.width = w
+	    this.horiz.style.pointerEvents = this.vert.style.pointerEvents = "none"
+	    this.disableHoriz = new Delayed
+	    this.disableVert = new Delayed
+	  },
+	  enableZeroWidthBar: function(bar, delay) {
+	    bar.style.pointerEvents = "auto"
+	    function maybeDisable() {
+	      // To find out whether the scrollbar is still visible, we
+	      // check whether the element under the pixel in the bottom
+	      // left corner of the scrollbar box is the scrollbar box
+	      // itself (when the bar is still visible) or its filler child
+	      // (when the bar is hidden). If it is still visible, we keep
+	      // it enabled, if it's hidden, we disable pointer events.
+	      var box = bar.getBoundingClientRect()
+	      var elt = document.elementFromPoint(box.left + 1, box.bottom - 1)
+	      if (elt != bar) { bar.style.pointerEvents = "none" }
+	      else { delay.set(1000, maybeDisable) }
+	    }
+	    delay.set(1000, maybeDisable)
+	  },
+	  clear: function() {
+	    var parent = this.horiz.parentNode
+	    parent.removeChild(this.horiz)
+	    parent.removeChild(this.vert)
+	  }
+	}, NativeScrollbars.prototype)
+
+	function NullScrollbars() {}
+
+	NullScrollbars.prototype = copyObj({
+	  update: function() { return {bottom: 0, right: 0} },
+	  setScrollLeft: function() {},
+	  setScrollTop: function() {},
+	  clear: function() {}
+	}, NullScrollbars.prototype)
+
+	function updateScrollbars(cm, measure) {
+	  if (!measure) { measure = measureForScrollbars(cm) }
+	  var startWidth = cm.display.barWidth, startHeight = cm.display.barHeight
+	  updateScrollbarsInner(cm, measure)
+	  for (var i = 0; i < 4 && startWidth != cm.display.barWidth || startHeight != cm.display.barHeight; i++) {
+	    if (startWidth != cm.display.barWidth && cm.options.lineWrapping)
+	      { updateHeightsInViewport(cm) }
+	    updateScrollbarsInner(cm, measureForScrollbars(cm))
+	    startWidth = cm.display.barWidth; startHeight = cm.display.barHeight
+	  }
+	}
+
+	// Re-synchronize the fake scrollbars with the actual size of the
+	// content.
+	function updateScrollbarsInner(cm, measure) {
+	  var d = cm.display
+	  var sizes = d.scrollbars.update(measure)
+
+	  d.sizer.style.paddingRight = (d.barWidth = sizes.right) + "px"
+	  d.sizer.style.paddingBottom = (d.barHeight = sizes.bottom) + "px"
+	  d.heightForcer.style.borderBottom = sizes.bottom + "px solid transparent"
+
+	  if (sizes.right && sizes.bottom) {
+	    d.scrollbarFiller.style.display = "block"
+	    d.scrollbarFiller.style.height = sizes.bottom + "px"
+	    d.scrollbarFiller.style.width = sizes.right + "px"
+	  } else { d.scrollbarFiller.style.display = "" }
+	  if (sizes.bottom && cm.options.coverGutterNextToScrollbar && cm.options.fixedGutter) {
+	    d.gutterFiller.style.display = "block"
+	    d.gutterFiller.style.height = sizes.bottom + "px"
+	    d.gutterFiller.style.width = measure.gutterWidth + "px"
+	  } else { d.gutterFiller.style.display = "" }
+	}
+
+	var scrollbarModel = {"native": NativeScrollbars, "null": NullScrollbars}
+
+	function initScrollbars(cm) {
+	  if (cm.display.scrollbars) {
+	    cm.display.scrollbars.clear()
+	    if (cm.display.scrollbars.addClass)
+	      { rmClass(cm.display.wrapper, cm.display.scrollbars.addClass) }
+	  }
+
+	  cm.display.scrollbars = new scrollbarModel[cm.options.scrollbarStyle](function (node) {
+	    cm.display.wrapper.insertBefore(node, cm.display.scrollbarFiller)
+	    // Prevent clicks in the scrollbars from killing focus
+	    on(node, "mousedown", function () {
+	      if (cm.state.focused) { setTimeout(function () { return cm.display.input.focus(); }, 0) }
+	    })
+	    node.setAttribute("cm-not-content", "true")
+	  }, function (pos, axis) {
+	    if (axis == "horizontal") { setScrollLeft(cm, pos) }
+	    else { setScrollTop(cm, pos) }
+	  }, cm)
+	  if (cm.display.scrollbars.addClass)
+	    { addClass(cm.display.wrapper, cm.display.scrollbars.addClass) }
+	}
+
+	// SCROLLING THINGS INTO VIEW
+
+	// If an editor sits on the top or bottom of the window, partially
+	// scrolled out of view, this ensures that the cursor is visible.
+	function maybeScrollWindow(cm, coords) {
+	  if (signalDOMEvent(cm, "scrollCursorIntoView")) { return }
+
+	  var display = cm.display, box = display.sizer.getBoundingClientRect(), doScroll = null
+	  if (coords.top + box.top < 0) { doScroll = true }
+	  else if (coords.bottom + box.top > (window.innerHeight || document.documentElement.clientHeight)) { doScroll = false }
+	  if (doScroll != null && !phantom) {
+	    var scrollNode = elt("div", "\u200b", null, ("position: absolute;\n                         top: " + (coords.top - display.viewOffset - paddingTop(cm.display)) + "px;\n                         height: " + (coords.bottom - coords.top + scrollGap(cm) + display.barHeight) + "px;\n                         left: " + (coords.left) + "px; width: 2px;"))
+	    cm.display.lineSpace.appendChild(scrollNode)
+	    scrollNode.scrollIntoView(doScroll)
+	    cm.display.lineSpace.removeChild(scrollNode)
+	  }
+	}
+
+	// Scroll a given position into view (immediately), verifying that
+	// it actually became visible (as line heights are accurately
+	// measured, the position of something may 'drift' during drawing).
+	function scrollPosIntoView(cm, pos, end, margin) {
+	  if (margin == null) { margin = 0 }
+	  var coords
+	  for (var limit = 0; limit < 5; limit++) {
+	    var changed = false
+	    coords = cursorCoords(cm, pos)
+	    var endCoords = !end || end == pos ? coords : cursorCoords(cm, end)
+	    var scrollPos = calculateScrollPos(cm, Math.min(coords.left, endCoords.left),
+	                                       Math.min(coords.top, endCoords.top) - margin,
+	                                       Math.max(coords.left, endCoords.left),
+	                                       Math.max(coords.bottom, endCoords.bottom) + margin)
+	    var startTop = cm.doc.scrollTop, startLeft = cm.doc.scrollLeft
+	    if (scrollPos.scrollTop != null) {
+	      setScrollTop(cm, scrollPos.scrollTop)
+	      if (Math.abs(cm.doc.scrollTop - startTop) > 1) { changed = true }
+	    }
+	    if (scrollPos.scrollLeft != null) {
+	      setScrollLeft(cm, scrollPos.scrollLeft)
+	      if (Math.abs(cm.doc.scrollLeft - startLeft) > 1) { changed = true }
+	    }
+	    if (!changed) { break }
+	  }
+	  return coords
+	}
+
+	// Scroll a given set of coordinates into view (immediately).
+	function scrollIntoView(cm, x1, y1, x2, y2) {
+	  var scrollPos = calculateScrollPos(cm, x1, y1, x2, y2)
+	  if (scrollPos.scrollTop != null) { setScrollTop(cm, scrollPos.scrollTop) }
+	  if (scrollPos.scrollLeft != null) { setScrollLeft(cm, scrollPos.scrollLeft) }
+	}
+
+	// Calculate a new scroll position needed to scroll the given
+	// rectangle into view. Returns an object with scrollTop and
+	// scrollLeft properties. When these are undefined, the
+	// vertical/horizontal position does not need to be adjusted.
+	function calculateScrollPos(cm, x1, y1, x2, y2) {
+	  var display = cm.display, snapMargin = textHeight(cm.display)
+	  if (y1 < 0) { y1 = 0 }
+	  var screentop = cm.curOp && cm.curOp.scrollTop != null ? cm.curOp.scrollTop : display.scroller.scrollTop
+	  var screen = displayHeight(cm), result = {}
+	  if (y2 - y1 > screen) { y2 = y1 + screen }
+	  var docBottom = cm.doc.height + paddingVert(display)
+	  var atTop = y1 < snapMargin, atBottom = y2 > docBottom - snapMargin
+	  if (y1 < screentop) {
+	    result.scrollTop = atTop ? 0 : y1
+	  } else if (y2 > screentop + screen) {
+	    var newTop = Math.min(y1, (atBottom ? docBottom : y2) - screen)
+	    if (newTop != screentop) { result.scrollTop = newTop }
+	  }
+
+	  var screenleft = cm.curOp && cm.curOp.scrollLeft != null ? cm.curOp.scrollLeft : display.scroller.scrollLeft
+	  var screenw = displayWidth(cm) - (cm.options.fixedGutter ? display.gutters.offsetWidth : 0)
+	  var tooWide = x2 - x1 > screenw
+	  if (tooWide) { x2 = x1 + screenw }
+	  if (x1 < 10)
+	    { result.scrollLeft = 0 }
+	  else if (x1 < screenleft)
+	    { result.scrollLeft = Math.max(0, x1 - (tooWide ? 0 : 10)) }
+	  else if (x2 > screenw + screenleft - 3)
+	    { result.scrollLeft = x2 + (tooWide ? 0 : 10) - screenw }
+	  return result
+	}
+
+	// Store a relative adjustment to the scroll position in the current
+	// operation (to be applied when the operation finishes).
+	function addToScrollPos(cm, left, top) {
+	  if (left != null || top != null) { resolveScrollToPos(cm) }
+	  if (left != null)
+	    { cm.curOp.scrollLeft = (cm.curOp.scrollLeft == null ? cm.doc.scrollLeft : cm.curOp.scrollLeft) + left }
+	  if (top != null)
+	    { cm.curOp.scrollTop = (cm.curOp.scrollTop == null ? cm.doc.scrollTop : cm.curOp.scrollTop) + top }
+	}
+
+	// Make sure that at the end of the operation the current cursor is
+	// shown.
+	function ensureCursorVisible(cm) {
+	  resolveScrollToPos(cm)
+	  var cur = cm.getCursor(), from = cur, to = cur
+	  if (!cm.options.lineWrapping) {
+	    from = cur.ch ? Pos(cur.line, cur.ch - 1) : cur
+	    to = Pos(cur.line, cur.ch + 1)
+	  }
+	  cm.curOp.scrollToPos = {from: from, to: to, margin: cm.options.cursorScrollMargin, isCursor: true}
+	}
+
+	// When an operation has its scrollToPos property set, and another
+	// scroll action is applied before the end of the operation, this
+	// 'simulates' scrolling that position into view in a cheap way, so
+	// that the effect of intermediate scroll commands is not ignored.
+	function resolveScrollToPos(cm) {
+	  var range = cm.curOp.scrollToPos
+	  if (range) {
+	    cm.curOp.scrollToPos = null
+	    var from = estimateCoords(cm, range.from), to = estimateCoords(cm, range.to)
+	    var sPos = calculateScrollPos(cm, Math.min(from.left, to.left),
+	                                  Math.min(from.top, to.top) - range.margin,
+	                                  Math.max(from.right, to.right),
+	                                  Math.max(from.bottom, to.bottom) + range.margin)
+	    cm.scrollTo(sPos.scrollLeft, sPos.scrollTop)
+	  }
+	}
+
+	// Operations are used to wrap a series of changes to the editor
+	// state in such a way that each change won't have to update the
+	// cursor and display (which would be awkward, slow, and
+	// error-prone). Instead, display updates are batched and then all
+	// combined and executed at once.
+
+	var nextOpId = 0
+	// Start a new operation.
+	function startOperation(cm) {
+	  cm.curOp = {
+	    cm: cm,
+	    viewChanged: false,      // Flag that indicates that lines might need to be redrawn
+	    startHeight: cm.doc.height, // Used to detect need to update scrollbar
+	    forceUpdate: false,      // Used to force a redraw
+	    updateInput: null,       // Whether to reset the input textarea
+	    typing: false,           // Whether this reset should be careful to leave existing text (for compositing)
+	    changeObjs: null,        // Accumulated changes, for firing change events
+	    cursorActivityHandlers: null, // Set of handlers to fire cursorActivity on
+	    cursorActivityCalled: 0, // Tracks which cursorActivity handlers have been called already
+	    selectionChanged: false, // Whether the selection needs to be redrawn
+	    updateMaxLine: false,    // Set when the widest line needs to be determined anew
+	    scrollLeft: null, scrollTop: null, // Intermediate scroll position, not pushed to DOM yet
+	    scrollToPos: null,       // Used to scroll to a specific position
+	    focus: false,
+	    id: ++nextOpId           // Unique ID
+	  }
+	  pushOperation(cm.curOp)
+	}
+
+	// Finish an operation, updating the display and signalling delayed events
+	function endOperation(cm) {
+	  var op = cm.curOp
+	  finishOperation(op, function (group) {
+	    for (var i = 0; i < group.ops.length; i++)
+	      { group.ops[i].cm.curOp = null }
+	    endOperations(group)
+	  })
+	}
+
+	// The DOM updates done when an operation finishes are batched so
+	// that the minimum number of relayouts are required.
+	function endOperations(group) {
+	  var ops = group.ops
+	  for (var i = 0; i < ops.length; i++) // Read DOM
+	    { endOperation_R1(ops[i]) }
+	  for (var i$1 = 0; i$1 < ops.length; i$1++) // Write DOM (maybe)
+	    { endOperation_W1(ops[i$1]) }
+	  for (var i$2 = 0; i$2 < ops.length; i$2++) // Read DOM
+	    { endOperation_R2(ops[i$2]) }
+	  for (var i$3 = 0; i$3 < ops.length; i$3++) // Write DOM (maybe)
+	    { endOperation_W2(ops[i$3]) }
+	  for (var i$4 = 0; i$4 < ops.length; i$4++) // Read DOM
+	    { endOperation_finish(ops[i$4]) }
+	}
+
+	function endOperation_R1(op) {
+	  var cm = op.cm, display = cm.display
+	  maybeClipScrollbars(cm)
+	  if (op.updateMaxLine) { findMaxLine(cm) }
+
+	  op.mustUpdate = op.viewChanged || op.forceUpdate || op.scrollTop != null ||
+	    op.scrollToPos && (op.scrollToPos.from.line < display.viewFrom ||
+	                       op.scrollToPos.to.line >= display.viewTo) ||
+	    display.maxLineChanged && cm.options.lineWrapping
+	  op.update = op.mustUpdate &&
+	    new DisplayUpdate(cm, op.mustUpdate && {top: op.scrollTop, ensure: op.scrollToPos}, op.forceUpdate)
+	}
+
+	function endOperation_W1(op) {
+	  op.updatedDisplay = op.mustUpdate && updateDisplayIfNeeded(op.cm, op.update)
+	}
+
+	function endOperation_R2(op) {
+	  var cm = op.cm, display = cm.display
+	  if (op.updatedDisplay) { updateHeightsInViewport(cm) }
+
+	  op.barMeasure = measureForScrollbars(cm)
+
+	  // If the max line changed since it was last measured, measure it,
+	  // and ensure the document's width matches it.
+	  // updateDisplay_W2 will use these properties to do the actual resizing
+	  if (display.maxLineChanged && !cm.options.lineWrapping) {
+	    op.adjustWidthTo = measureChar(cm, display.maxLine, display.maxLine.text.length).left + 3
+	    cm.display.sizerWidth = op.adjustWidthTo
+	    op.barMeasure.scrollWidth =
+	      Math.max(display.scroller.clientWidth, display.sizer.offsetLeft + op.adjustWidthTo + scrollGap(cm) + cm.display.barWidth)
+	    op.maxScrollLeft = Math.max(0, display.sizer.offsetLeft + op.adjustWidthTo - displayWidth(cm))
+	  }
+
+	  if (op.updatedDisplay || op.selectionChanged)
+	    { op.preparedSelection = display.input.prepareSelection(op.focus) }
+	}
+
+	function endOperation_W2(op) {
+	  var cm = op.cm
+
+	  if (op.adjustWidthTo != null) {
+	    cm.display.sizer.style.minWidth = op.adjustWidthTo + "px"
+	    if (op.maxScrollLeft < cm.doc.scrollLeft)
+	      { setScrollLeft(cm, Math.min(cm.display.scroller.scrollLeft, op.maxScrollLeft), true) }
+	    cm.display.maxLineChanged = false
+	  }
+
+	  var takeFocus = op.focus && op.focus == activeElt() && (!document.hasFocus || document.hasFocus())
+	  if (op.preparedSelection)
+	    { cm.display.input.showSelection(op.preparedSelection, takeFocus) }
+	  if (op.updatedDisplay || op.startHeight != cm.doc.height)
+	    { updateScrollbars(cm, op.barMeasure) }
+	  if (op.updatedDisplay)
+	    { setDocumentHeight(cm, op.barMeasure) }
+
+	  if (op.selectionChanged) { restartBlink(cm) }
+
+	  if (cm.state.focused && op.updateInput)
+	    { cm.display.input.reset(op.typing) }
+	  if (takeFocus) { ensureFocus(op.cm) }
+	}
+
+	function endOperation_finish(op) {
+	  var cm = op.cm, display = cm.display, doc = cm.doc
+
+	  if (op.updatedDisplay) { postUpdateDisplay(cm, op.update) }
+
+	  // Abort mouse wheel delta measurement, when scrolling explicitly
+	  if (display.wheelStartX != null && (op.scrollTop != null || op.scrollLeft != null || op.scrollToPos))
+	    { display.wheelStartX = display.wheelStartY = null }
+
+	  // Propagate the scroll position to the actual DOM scroller
+	  if (op.scrollTop != null && (display.scroller.scrollTop != op.scrollTop || op.forceScroll)) {
+	    doc.scrollTop = Math.max(0, Math.min(display.scroller.scrollHeight - display.scroller.clientHeight, op.scrollTop))
+	    display.scrollbars.setScrollTop(doc.scrollTop)
+	    display.scroller.scrollTop = doc.scrollTop
+	  }
+	  if (op.scrollLeft != null && (display.scroller.scrollLeft != op.scrollLeft || op.forceScroll)) {
+	    doc.scrollLeft = Math.max(0, Math.min(display.scroller.scrollWidth - display.scroller.clientWidth, op.scrollLeft))
+	    display.scrollbars.setScrollLeft(doc.scrollLeft)
+	    display.scroller.scrollLeft = doc.scrollLeft
+	    alignHorizontally(cm)
+	  }
+	  // If we need to scroll a specific position into view, do so.
+	  if (op.scrollToPos) {
+	    var coords = scrollPosIntoView(cm, clipPos(doc, op.scrollToPos.from),
+	                                   clipPos(doc, op.scrollToPos.to), op.scrollToPos.margin)
+	    if (op.scrollToPos.isCursor && cm.state.focused) { maybeScrollWindow(cm, coords) }
+	  }
+
+	  // Fire events for markers that are hidden/unidden by editing or
+	  // undoing
+	  var hidden = op.maybeHiddenMarkers, unhidden = op.maybeUnhiddenMarkers
+	  if (hidden) { for (var i = 0; i < hidden.length; ++i)
+	    { if (!hidden[i].lines.length) { signal(hidden[i], "hide") } } }
+	  if (unhidden) { for (var i$1 = 0; i$1 < unhidden.length; ++i$1)
+	    { if (unhidden[i$1].lines.length) { signal(unhidden[i$1], "unhide") } } }
+
+	  if (display.wrapper.offsetHeight)
+	    { doc.scrollTop = cm.display.scroller.scrollTop }
+
+	  // Fire change events, and delayed event handlers
+	  if (op.changeObjs)
+	    { signal(cm, "changes", cm, op.changeObjs) }
+	  if (op.update)
+	    { op.update.finish() }
+	}
+
+	// Run the given function in an operation
+	function runInOp(cm, f) {
+	  if (cm.curOp) { return f() }
+	  startOperation(cm)
+	  try { return f() }
+	  finally { endOperation(cm) }
+	}
+	// Wraps a function in an operation. Returns the wrapped function.
+	function operation(cm, f) {
+	  return function() {
+	    if (cm.curOp) { return f.apply(cm, arguments) }
+	    startOperation(cm)
+	    try { return f.apply(cm, arguments) }
+	    finally { endOperation(cm) }
+	  }
+	}
+	// Used to add methods to editor and doc instances, wrapping them in
+	// operations.
+	function methodOp(f) {
+	  return function() {
+	    if (this.curOp) { return f.apply(this, arguments) }
+	    startOperation(this)
+	    try { return f.apply(this, arguments) }
+	    finally { endOperation(this) }
+	  }
+	}
+	function docMethodOp(f) {
+	  return function() {
+	    var cm = this.cm
+	    if (!cm || cm.curOp) { return f.apply(this, arguments) }
+	    startOperation(cm)
+	    try { return f.apply(this, arguments) }
+	    finally { endOperation(cm) }
+	  }
+	}
+
+	// Updates the display.view data structure for a given change to the
+	// document. From and to are in pre-change coordinates. Lendiff is
+	// the amount of lines added or subtracted by the change. This is
+	// used for changes that span multiple lines, or change the way
+	// lines are divided into visual lines. regLineChange (below)
+	// registers single-line changes.
+	function regChange(cm, from, to, lendiff) {
+	  if (from == null) { from = cm.doc.first }
+	  if (to == null) { to = cm.doc.first + cm.doc.size }
+	  if (!lendiff) { lendiff = 0 }
+
+	  var display = cm.display
+	  if (lendiff && to < display.viewTo &&
+	      (display.updateLineNumbers == null || display.updateLineNumbers > from))
+	    { display.updateLineNumbers = from }
+
+	  cm.curOp.viewChanged = true
+
+	  if (from >= display.viewTo) { // Change after
+	    if (sawCollapsedSpans && visualLineNo(cm.doc, from) < display.viewTo)
+	      { resetView(cm) }
+	  } else if (to <= display.viewFrom) { // Change before
+	    if (sawCollapsedSpans && visualLineEndNo(cm.doc, to + lendiff) > display.viewFrom) {
+	      resetView(cm)
+	    } else {
+	      display.viewFrom += lendiff
+	      display.viewTo += lendiff
+	    }
+	  } else if (from <= display.viewFrom && to >= display.viewTo) { // Full overlap
+	    resetView(cm)
+	  } else if (from <= display.viewFrom) { // Top overlap
+	    var cut = viewCuttingPoint(cm, to, to + lendiff, 1)
+	    if (cut) {
+	      display.view = display.view.slice(cut.index)
+	      display.viewFrom = cut.lineN
+	      display.viewTo += lendiff
+	    } else {
+	      resetView(cm)
+	    }
+	  } else if (to >= display.viewTo) { // Bottom overlap
+	    var cut$1 = viewCuttingPoint(cm, from, from, -1)
+	    if (cut$1) {
+	      display.view = display.view.slice(0, cut$1.index)
+	      display.viewTo = cut$1.lineN
+	    } else {
+	      resetView(cm)
+	    }
+	  } else { // Gap in the middle
+	    var cutTop = viewCuttingPoint(cm, from, from, -1)
+	    var cutBot = viewCuttingPoint(cm, to, to + lendiff, 1)
+	    if (cutTop && cutBot) {
+	      display.view = display.view.slice(0, cutTop.index)
+	        .concat(buildViewArray(cm, cutTop.lineN, cutBot.lineN))
+	        .concat(display.view.slice(cutBot.index))
+	      display.viewTo += lendiff
+	    } else {
+	      resetView(cm)
+	    }
+	  }
+
+	  var ext = display.externalMeasured
+	  if (ext) {
+	    if (to < ext.lineN)
+	      { ext.lineN += lendiff }
+	    else if (from < ext.lineN + ext.size)
+	      { display.externalMeasured = null }
+	  }
+	}
+
+	// Register a change to a single line. Type must be one of "text",
+	// "gutter", "class", "widget"
+	function regLineChange(cm, line, type) {
+	  cm.curOp.viewChanged = true
+	  var display = cm.display, ext = cm.display.externalMeasured
+	  if (ext && line >= ext.lineN && line < ext.lineN + ext.size)
+	    { display.externalMeasured = null }
+
+	  if (line < display.viewFrom || line >= display.viewTo) { return }
+	  var lineView = display.view[findViewIndex(cm, line)]
+	  if (lineView.node == null) { return }
+	  var arr = lineView.changes || (lineView.changes = [])
+	  if (indexOf(arr, type) == -1) { arr.push(type) }
+	}
+
+	// Clear the view.
+	function resetView(cm) {
+	  cm.display.viewFrom = cm.display.viewTo = cm.doc.first
+	  cm.display.view = []
+	  cm.display.viewOffset = 0
+	}
+
+	function viewCuttingPoint(cm, oldN, newN, dir) {
+	  var index = findViewIndex(cm, oldN), diff, view = cm.display.view
+	  if (!sawCollapsedSpans || newN == cm.doc.first + cm.doc.size)
+	    { return {index: index, lineN: newN} }
+	  var n = cm.display.viewFrom
+	  for (var i = 0; i < index; i++)
+	    { n += view[i].size }
+	  if (n != oldN) {
+	    if (dir > 0) {
+	      if (index == view.length - 1) { return null }
+	      diff = (n + view[index].size) - oldN
+	      index++
+	    } else {
+	      diff = n - oldN
+	    }
+	    oldN += diff; newN += diff
+	  }
+	  while (visualLineNo(cm.doc, newN) != newN) {
+	    if (index == (dir < 0 ? 0 : view.length - 1)) { return null }
+	    newN += dir * view[index - (dir < 0 ? 1 : 0)].size
+	    index += dir
+	  }
+	  return {index: index, lineN: newN}
+	}
+
+	// Force the view to cover a given range, adding empty view element
+	// or clipping off existing ones as needed.
+	function adjustView(cm, from, to) {
+	  var display = cm.display, view = display.view
+	  if (view.length == 0 || from >= display.viewTo || to <= display.viewFrom) {
+	    display.view = buildViewArray(cm, from, to)
+	    display.viewFrom = from
+	  } else {
+	    if (display.viewFrom > from)
+	      { display.view = buildViewArray(cm, from, display.viewFrom).concat(display.view) }
+	    else if (display.viewFrom < from)
+	      { display.view = display.view.slice(findViewIndex(cm, from)) }
+	    display.viewFrom = from
+	    if (display.viewTo < to)
+	      { display.view = display.view.concat(buildViewArray(cm, display.viewTo, to)) }
+	    else if (display.viewTo > to)
+	      { display.view = display.view.slice(0, findViewIndex(cm, to)) }
+	  }
+	  display.viewTo = to
+	}
+
+	// Count the number of lines in the view whose DOM representation is
+	// out of date (or nonexistent).
+	function countDirtyView(cm) {
+	  var view = cm.display.view, dirty = 0
+	  for (var i = 0; i < view.length; i++) {
+	    var lineView = view[i]
+	    if (!lineView.hidden && (!lineView.node || lineView.changes)) { ++dirty }
+	  }
+	  return dirty
+	}
+
+	// HIGHLIGHT WORKER
+
+	function startWorker(cm, time) {
+	  if (cm.doc.mode.startState && cm.doc.frontier < cm.display.viewTo)
+	    { cm.state.highlight.set(time, bind(highlightWorker, cm)) }
+	}
+
+	function highlightWorker(cm) {
+	  var doc = cm.doc
+	  if (doc.frontier < doc.first) { doc.frontier = doc.first }
+	  if (doc.frontier >= cm.display.viewTo) { return }
+	  var end = +new Date + cm.options.workTime
+	  var state = copyState(doc.mode, getStateBefore(cm, doc.frontier))
+	  var changedLines = []
+
+	  doc.iter(doc.frontier, Math.min(doc.first + doc.size, cm.display.viewTo + 500), function (line) {
+	    if (doc.frontier >= cm.display.viewFrom) { // Visible
+	      var oldStyles = line.styles, tooLong = line.text.length > cm.options.maxHighlightLength
+	      var highlighted = highlightLine(cm, line, tooLong ? copyState(doc.mode, state) : state, true)
+	      line.styles = highlighted.styles
+	      var oldCls = line.styleClasses, newCls = highlighted.classes
+	      if (newCls) { line.styleClasses = newCls }
+	      else if (oldCls) { line.styleClasses = null }
+	      var ischange = !oldStyles || oldStyles.length != line.styles.length ||
+	        oldCls != newCls && (!oldCls || !newCls || oldCls.bgClass != newCls.bgClass || oldCls.textClass != newCls.textClass)
+	      for (var i = 0; !ischange && i < oldStyles.length; ++i) { ischange = oldStyles[i] != line.styles[i] }
+	      if (ischange) { changedLines.push(doc.frontier) }
+	      line.stateAfter = tooLong ? state : copyState(doc.mode, state)
+	    } else {
+	      if (line.text.length <= cm.options.maxHighlightLength)
+	        { processLine(cm, line.text, state) }
+	      line.stateAfter = doc.frontier % 5 == 0 ? copyState(doc.mode, state) : null
+	    }
+	    ++doc.frontier
+	    if (+new Date > end) {
+	      startWorker(cm, cm.options.workDelay)
+	      return true
+	    }
+	  })
+	  if (changedLines.length) { runInOp(cm, function () {
+	    for (var i = 0; i < changedLines.length; i++)
+	      { regLineChange(cm, changedLines[i], "text") }
+	  }) }
+	}
+
+	// DISPLAY DRAWING
+
+	function DisplayUpdate(cm, viewport, force) {
+	  var display = cm.display
+
+	  this.viewport = viewport
+	  // Store some values that we'll need later (but don't want to force a relayout for)
+	  this.visible = visibleLines(display, cm.doc, viewport)
+	  this.editorIsHidden = !display.wrapper.offsetWidth
+	  this.wrapperHeight = display.wrapper.clientHeight
+	  this.wrapperWidth = display.wrapper.clientWidth
+	  this.oldDisplayWidth = displayWidth(cm)
+	  this.force = force
+	  this.dims = getDimensions(cm)
+	  this.events = []
+	}
+
+	DisplayUpdate.prototype.signal = function(emitter, type) {
+	  if (hasHandler(emitter, type))
+	    { this.events.push(arguments) }
+	}
+	DisplayUpdate.prototype.finish = function() {
+	  var this$1 = this;
+
+	  for (var i = 0; i < this.events.length; i++)
+	    { signal.apply(null, this$1.events[i]) }
+	}
+
+	function maybeClipScrollbars(cm) {
+	  var display = cm.display
+	  if (!display.scrollbarsClipped && display.scroller.offsetWidth) {
+	    display.nativeBarWidth = display.scroller.offsetWidth - display.scroller.clientWidth
+	    display.heightForcer.style.height = scrollGap(cm) + "px"
+	    display.sizer.style.marginBottom = -display.nativeBarWidth + "px"
+	    display.sizer.style.borderRightWidth = scrollGap(cm) + "px"
+	    display.scrollbarsClipped = true
+	  }
+	}
+
+	// Does the actual updating of the line display. Bails out
+	// (returning false) when there is nothing to be done and forced is
+	// false.
+	function updateDisplayIfNeeded(cm, update) {
+	  var display = cm.display, doc = cm.doc
+
+	  if (update.editorIsHidden) {
+	    resetView(cm)
+	    return false
+	  }
+
+	  // Bail out if the visible area is already rendered and nothing changed.
+	  if (!update.force &&
+	      update.visible.from >= display.viewFrom && update.visible.to <= display.viewTo &&
+	      (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo) &&
+	      display.renderedView == display.view && countDirtyView(cm) == 0)
+	    { return false }
+
+	  if (maybeUpdateLineNumberWidth(cm)) {
+	    resetView(cm)
+	    update.dims = getDimensions(cm)
+	  }
+
+	  // Compute a suitable new viewport (from & to)
+	  var end = doc.first + doc.size
+	  var from = Math.max(update.visible.from - cm.options.viewportMargin, doc.first)
+	  var to = Math.min(end, update.visible.to + cm.options.viewportMargin)
+	  if (display.viewFrom < from && from - display.viewFrom < 20) { from = Math.max(doc.first, display.viewFrom) }
+	  if (display.viewTo > to && display.viewTo - to < 20) { to = Math.min(end, display.viewTo) }
+	  if (sawCollapsedSpans) {
+	    from = visualLineNo(cm.doc, from)
+	    to = visualLineEndNo(cm.doc, to)
+	  }
+
+	  var different = from != display.viewFrom || to != display.viewTo ||
+	    display.lastWrapHeight != update.wrapperHeight || display.lastWrapWidth != update.wrapperWidth
+	  adjustView(cm, from, to)
+
+	  display.viewOffset = heightAtLine(getLine(cm.doc, display.viewFrom))
+	  // Position the mover div to align with the current scroll position
+	  cm.display.mover.style.top = display.viewOffset + "px"
+
+	  var toUpdate = countDirtyView(cm)
+	  if (!different && toUpdate == 0 && !update.force && display.renderedView == display.view &&
+	      (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo))
+	    { return false }
+
+	  // For big changes, we hide the enclosing element during the
+	  // update, since that speeds up the operations on most browsers.
+	  var focused = activeElt()
+	  if (toUpdate > 4) { display.lineDiv.style.display = "none" }
+	  patchDisplay(cm, display.updateLineNumbers, update.dims)
+	  if (toUpdate > 4) { display.lineDiv.style.display = "" }
+	  display.renderedView = display.view
+	  // There might have been a widget with a focused element that got
+	  // hidden or updated, if so re-focus it.
+	  if (focused && activeElt() != focused && focused.offsetHeight) { focused.focus() }
+
+	  // Prevent selection and cursors from interfering with the scroll
+	  // width and height.
+	  removeChildren(display.cursorDiv)
+	  removeChildren(display.selectionDiv)
+	  display.gutters.style.height = display.sizer.style.minHeight = 0
+
+	  if (different) {
+	    display.lastWrapHeight = update.wrapperHeight
+	    display.lastWrapWidth = update.wrapperWidth
+	    startWorker(cm, 400)
+	  }
+
+	  display.updateLineNumbers = null
+
+	  return true
+	}
+
+	function postUpdateDisplay(cm, update) {
+	  var viewport = update.viewport
+
+	  for (var first = true;; first = false) {
+	    if (!first || !cm.options.lineWrapping || update.oldDisplayWidth == displayWidth(cm)) {
+	      // Clip forced viewport to actual scrollable area.
+	      if (viewport && viewport.top != null)
+	        { viewport = {top: Math.min(cm.doc.height + paddingVert(cm.display) - displayHeight(cm), viewport.top)} }
+	      // Updated line heights might result in the drawn area not
+	      // actually covering the viewport. Keep looping until it does.
+	      update.visible = visibleLines(cm.display, cm.doc, viewport)
+	      if (update.visible.from >= cm.display.viewFrom && update.visible.to <= cm.display.viewTo)
+	        { break }
+	    }
+	    if (!updateDisplayIfNeeded(cm, update)) { break }
+	    updateHeightsInViewport(cm)
+	    var barMeasure = measureForScrollbars(cm)
+	    updateSelection(cm)
+	    updateScrollbars(cm, barMeasure)
+	    setDocumentHeight(cm, barMeasure)
+	  }
+
+	  update.signal(cm, "update", cm)
+	  if (cm.display.viewFrom != cm.display.reportedViewFrom || cm.display.viewTo != cm.display.reportedViewTo) {
+	    update.signal(cm, "viewportChange", cm, cm.display.viewFrom, cm.display.viewTo)
+	    cm.display.reportedViewFrom = cm.display.viewFrom; cm.display.reportedViewTo = cm.display.viewTo
+	  }
+	}
+
+	function updateDisplaySimple(cm, viewport) {
+	  var update = new DisplayUpdate(cm, viewport)
+	  if (updateDisplayIfNeeded(cm, update)) {
+	    updateHeightsInViewport(cm)
+	    postUpdateDisplay(cm, update)
+	    var barMeasure = measureForScrollbars(cm)
+	    updateSelection(cm)
+	    updateScrollbars(cm, barMeasure)
+	    setDocumentHeight(cm, barMeasure)
+	    update.finish()
+	  }
+	}
+
+	// Sync the actual display DOM structure with display.view, removing
+	// nodes for lines that are no longer in view, and creating the ones
+	// that are not there yet, and updating the ones that are out of
+	// date.
+	function patchDisplay(cm, updateNumbersFrom, dims) {
+	  var display = cm.display, lineNumbers = cm.options.lineNumbers
+	  var container = display.lineDiv, cur = container.firstChild
+
+	  function rm(node) {
+	    var next = node.nextSibling
+	    // Works around a throw-scroll bug in OS X Webkit
+	    if (webkit && mac && cm.display.currentWheelTarget == node)
+	      { node.style.display = "none" }
+	    else
+	      { node.parentNode.removeChild(node) }
+	    return next
+	  }
+
+	  var view = display.view, lineN = display.viewFrom
+	  // Loop over the elements in the view, syncing cur (the DOM nodes
+	  // in display.lineDiv) with the view as we go.
+	  for (var i = 0; i < view.length; i++) {
+	    var lineView = view[i]
+	    if (lineView.hidden) {
+	    } else if (!lineView.node || lineView.node.parentNode != container) { // Not drawn yet
+	      var node = buildLineElement(cm, lineView, lineN, dims)
+	      container.insertBefore(node, cur)
+	    } else { // Already drawn
+	      while (cur != lineView.node) { cur = rm(cur) }
+	      var updateNumber = lineNumbers && updateNumbersFrom != null &&
+	        updateNumbersFrom <= lineN && lineView.lineNumber
+	      if (lineView.changes) {
+	        if (indexOf(lineView.changes, "gutter") > -1) { updateNumber = false }
+	        updateLineForChanges(cm, lineView, lineN, dims)
+	      }
+	      if (updateNumber) {
+	        removeChildren(lineView.lineNumber)
+	        lineView.lineNumber.appendChild(document.createTextNode(lineNumberFor(cm.options, lineN)))
+	      }
+	      cur = lineView.node.nextSibling
+	    }
+	    lineN += lineView.size
+	  }
+	  while (cur) { cur = rm(cur) }
+	}
+
+	function updateGutterSpace(cm) {
+	  var width = cm.display.gutters.offsetWidth
+	  cm.display.sizer.style.marginLeft = width + "px"
+	}
+
+	function setDocumentHeight(cm, measure) {
+	  cm.display.sizer.style.minHeight = measure.docHeight + "px"
+	  cm.display.heightForcer.style.top = measure.docHeight + "px"
+	  cm.display.gutters.style.height = (measure.docHeight + cm.display.barHeight + scrollGap(cm)) + "px"
+	}
+
+	// Rebuild the gutter elements, ensure the margin to the left of the
+	// code matches their width.
+	function updateGutters(cm) {
+	  var gutters = cm.display.gutters, specs = cm.options.gutters
+	  removeChildren(gutters)
+	  var i = 0
+	  for (; i < specs.length; ++i) {
+	    var gutterClass = specs[i]
+	    var gElt = gutters.appendChild(elt("div", null, "CodeMirror-gutter " + gutterClass))
+	    if (gutterClass == "CodeMirror-linenumbers") {
+	      cm.display.lineGutter = gElt
+	      gElt.style.width = (cm.display.lineNumWidth || 1) + "px"
+	    }
+	  }
+	  gutters.style.display = i ? "" : "none"
+	  updateGutterSpace(cm)
+	}
+
+	// Make sure the gutters options contains the element
+	// "CodeMirror-linenumbers" when the lineNumbers option is true.
+	function setGuttersForLineNumbers(options) {
+	  var found = indexOf(options.gutters, "CodeMirror-linenumbers")
+	  if (found == -1 && options.lineNumbers) {
+	    options.gutters = options.gutters.concat(["CodeMirror-linenumbers"])
+	  } else if (found > -1 && !options.lineNumbers) {
+	    options.gutters = options.gutters.slice(0)
+	    options.gutters.splice(found, 1)
+	  }
+	}
+
+	// Selection objects are immutable. A new one is created every time
+	// the selection changes. A selection is one or more non-overlapping
+	// (and non-touching) ranges, sorted, and an integer that indicates
+	// which one is the primary selection (the one that's scrolled into
+	// view, that getCursor returns, etc).
+	function Selection(ranges, primIndex) {
+	  this.ranges = ranges
+	  this.primIndex = primIndex
+	}
+
+	Selection.prototype = {
+	  primary: function() { return this.ranges[this.primIndex] },
+	  equals: function(other) {
+	    var this$1 = this;
+
+	    if (other == this) { return true }
+	    if (other.primIndex != this.primIndex || other.ranges.length != this.ranges.length) { return false }
+	    for (var i = 0; i < this.ranges.length; i++) {
+	      var here = this$1.ranges[i], there = other.ranges[i]
+	      if (cmp(here.anchor, there.anchor) != 0 || cmp(here.head, there.head) != 0) { return false }
+	    }
+	    return true
+	  },
+	  deepCopy: function() {
+	    var this$1 = this;
+
+	    var out = []
+	    for (var i = 0; i < this.ranges.length; i++)
+	      { out[i] = new Range(copyPos(this$1.ranges[i].anchor), copyPos(this$1.ranges[i].head)) }
+	    return new Selection(out, this.primIndex)
+	  },
+	  somethingSelected: function() {
+	    var this$1 = this;
+
+	    for (var i = 0; i < this.ranges.length; i++)
+	      { if (!this$1.ranges[i].empty()) { return true } }
+	    return false
+	  },
+	  contains: function(pos, end) {
+	    var this$1 = this;
+
+	    if (!end) { end = pos }
+	    for (var i = 0; i < this.ranges.length; i++) {
+	      var range = this$1.ranges[i]
+	      if (cmp(end, range.from()) >= 0 && cmp(pos, range.to()) <= 0)
+	        { return i }
+	    }
+	    return -1
+	  }
+	}
+
+	function Range(anchor, head) {
+	  this.anchor = anchor; this.head = head
+	}
+
+	Range.prototype = {
+	  from: function() { return minPos(this.anchor, this.head) },
+	  to: function() { return maxPos(this.anchor, this.head) },
+	  empty: function() {
+	    return this.head.line == this.anchor.line && this.head.ch == this.anchor.ch
+	  }
+	}
+
+	// Take an unsorted, potentially overlapping set of ranges, and
+	// build a selection out of it. 'Consumes' ranges array (modifying
+	// it).
+	function normalizeSelection(ranges, primIndex) {
+	  var prim = ranges[primIndex]
+	  ranges.sort(function (a, b) { return cmp(a.from(), b.from()); })
+	  primIndex = indexOf(ranges, prim)
+	  for (var i = 1; i < ranges.length; i++) {
+	    var cur = ranges[i], prev = ranges[i - 1]
+	    if (cmp(prev.to(), cur.from()) >= 0) {
+	      var from = minPos(prev.from(), cur.from()), to = maxPos(prev.to(), cur.to())
+	      var inv = prev.empty() ? cur.from() == cur.head : prev.from() == prev.head
+	      if (i <= primIndex) { --primIndex }
+	      ranges.splice(--i, 2, new Range(inv ? to : from, inv ? from : to))
+	    }
+	  }
+	  return new Selection(ranges, primIndex)
+	}
+
+	function simpleSelection(anchor, head) {
+	  return new Selection([new Range(anchor, head || anchor)], 0)
+	}
+
+	// Compute the position of the end of a change (its 'to' property
+	// refers to the pre-change end).
+	function changeEnd(change) {
+	  if (!change.text) { return change.to }
+	  return Pos(change.from.line + change.text.length - 1,
+	             lst(change.text).length + (change.text.length == 1 ? change.from.ch : 0))
+	}
+
+	// Adjust a position to refer to the post-change position of the
+	// same text, or the end of the change if the change covers it.
+	function adjustForChange(pos, change) {
+	  if (cmp(pos, change.from) < 0) { return pos }
+	  if (cmp(pos, change.to) <= 0) { return changeEnd(change) }
+
+	  var line = pos.line + change.text.length - (change.to.line - change.from.line) - 1, ch = pos.ch
+	  if (pos.line == change.to.line) { ch += changeEnd(change).ch - change.to.ch }
+	  return Pos(line, ch)
+	}
+
+	function computeSelAfterChange(doc, change) {
+	  var out = []
+	  for (var i = 0; i < doc.sel.ranges.length; i++) {
+	    var range = doc.sel.ranges[i]
+	    out.push(new Range(adjustForChange(range.anchor, change),
+	                       adjustForChange(range.head, change)))
+	  }
+	  return normalizeSelection(out, doc.sel.primIndex)
+	}
+
+	function offsetPos(pos, old, nw) {
+	  if (pos.line == old.line)
+	    { return Pos(nw.line, pos.ch - old.ch + nw.ch) }
+	  else
+	    { return Pos(nw.line + (pos.line - old.line), pos.ch) }
+	}
+
+	// Used by replaceSelections to allow moving the selection to the
+	// start or around the replaced test. Hint may be "start" or "around".
+	function computeReplacedSel(doc, changes, hint) {
+	  var out = []
+	  var oldPrev = Pos(doc.first, 0), newPrev = oldPrev
+	  for (var i = 0; i < changes.length; i++) {
+	    var change = changes[i]
+	    var from = offsetPos(change.from, oldPrev, newPrev)
+	    var to = offsetPos(changeEnd(change), oldPrev, newPrev)
+	    oldPrev = change.to
+	    newPrev = to
+	    if (hint == "around") {
+	      var range = doc.sel.ranges[i], inv = cmp(range.head, range.anchor) < 0
+	      out[i] = new Range(inv ? to : from, inv ? from : to)
+	    } else {
+	      out[i] = new Range(from, from)
+	    }
+	  }
+	  return new Selection(out, doc.sel.primIndex)
+	}
+
+	// Used to get the editor into a consistent state again when options change.
+
+	function loadMode(cm) {
+	  cm.doc.mode = getMode(cm.options, cm.doc.modeOption)
+	  resetModeState(cm)
+	}
+
+	function resetModeState(cm) {
+	  cm.doc.iter(function (line) {
+	    if (line.stateAfter) { line.stateAfter = null }
+	    if (line.styles) { line.styles = null }
+	  })
+	  cm.doc.frontier = cm.doc.first
+	  startWorker(cm, 100)
+	  cm.state.modeGen++
+	  if (cm.curOp) { regChange(cm) }
+	}
+
+	// DOCUMENT DATA STRUCTURE
+
+	// By default, updates that start and end at the beginning of a line
+	// are treated specially, in order to make the association of line
+	// widgets and marker elements with the text behave more intuitive.
+	function isWholeLineUpdate(doc, change) {
+	  return change.from.ch == 0 && change.to.ch == 0 && lst(change.text) == "" &&
+	    (!doc.cm || doc.cm.options.wholeLineUpdateBefore)
+	}
+
+	// Perform a change on the document data structure.
+	function updateDoc(doc, change, markedSpans, estimateHeight) {
+	  function spansFor(n) {return markedSpans ? markedSpans[n] : null}
+	  function update(line, text, spans) {
+	    updateLine(line, text, spans, estimateHeight)
+	    signalLater(line, "change", line, change)
+	  }
+	  function linesFor(start, end) {
+	    var result = []
+	    for (var i = start; i < end; ++i)
+	      { result.push(new Line(text[i], spansFor(i), estimateHeight)) }
+	    return result
+	  }
+
+	  var from = change.from, to = change.to, text = change.text
+	  var firstLine = getLine(doc, from.line), lastLine = getLine(doc, to.line)
+	  var lastText = lst(text), lastSpans = spansFor(text.length - 1), nlines = to.line - from.line
+
+	  // Adjust the line structure
+	  if (change.full) {
+	    doc.insert(0, linesFor(0, text.length))
+	    doc.remove(text.length, doc.size - text.length)
+	  } else if (isWholeLineUpdate(doc, change)) {
+	    // This is a whole-line replace. Treated specially to make
+	    // sure line objects move the way they are supposed to.
+	    var added = linesFor(0, text.length - 1)
+	    update(lastLine, lastLine.text, lastSpans)
+	    if (nlines) { doc.remove(from.line, nlines) }
+	    if (added.length) { doc.insert(from.line, added) }
+	  } else if (firstLine == lastLine) {
+	    if (text.length == 1) {
+	      update(firstLine, firstLine.text.slice(0, from.ch) + lastText + firstLine.text.slice(to.ch), lastSpans)
+	    } else {
+	      var added$1 = linesFor(1, text.length - 1)
+	      added$1.push(new Line(lastText + firstLine.text.slice(to.ch), lastSpans, estimateHeight))
+	      update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0))
+	      doc.insert(from.line + 1, added$1)
+	    }
+	  } else if (text.length == 1) {
+	    update(firstLine, firstLine.text.slice(0, from.ch) + text[0] + lastLine.text.slice(to.ch), spansFor(0))
+	    doc.remove(from.line + 1, nlines)
+	  } else {
+	    update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0))
+	    update(lastLine, lastText + lastLine.text.slice(to.ch), lastSpans)
+	    var added$2 = linesFor(1, text.length - 1)
+	    if (nlines > 1) { doc.remove(from.line + 1, nlines - 1) }
+	    doc.insert(from.line + 1, added$2)
+	  }
+
+	  signalLater(doc, "change", doc, change)
+	}
+
+	// Call f for all linked documents.
+	function linkedDocs(doc, f, sharedHistOnly) {
+	  function propagate(doc, skip, sharedHist) {
+	    if (doc.linked) { for (var i = 0; i < doc.linked.length; ++i) {
+	      var rel = doc.linked[i]
+	      if (rel.doc == skip) { continue }
+	      var shared = sharedHist && rel.sharedHist
+	      if (sharedHistOnly && !shared) { continue }
+	      f(rel.doc, shared)
+	      propagate(rel.doc, doc, shared)
+	    } }
+	  }
+	  propagate(doc, null, true)
+	}
+
+	// Attach a document to an editor.
+	function attachDoc(cm, doc) {
+	  if (doc.cm) { throw new Error("This document is already in use.") }
+	  cm.doc = doc
+	  doc.cm = cm
+	  estimateLineHeights(cm)
+	  loadMode(cm)
+	  if (!cm.options.lineWrapping) { findMaxLine(cm) }
+	  cm.options.mode = doc.modeOption
+	  regChange(cm)
+	}
+
+	function History(startGen) {
+	  // Arrays of change events and selections. Doing something adds an
+	  // event to done and clears undo. Undoing moves events from done
+	  // to undone, redoing moves them in the other direction.
+	  this.done = []; this.undone = []
+	  this.undoDepth = Infinity
+	  // Used to track when changes can be merged into a single undo
+	  // event
+	  this.lastModTime = this.lastSelTime = 0
+	  this.lastOp = this.lastSelOp = null
+	  this.lastOrigin = this.lastSelOrigin = null
+	  // Used by the isClean() method
+	  this.generation = this.maxGeneration = startGen || 1
+	}
+
+	// Create a history change event from an updateDoc-style change
+	// object.
+	function historyChangeFromChange(doc, change) {
+	  var histChange = {from: copyPos(change.from), to: changeEnd(change), text: getBetween(doc, change.from, change.to)}
+	  attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1)
+	  linkedDocs(doc, function (doc) { return attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1); }, true)
+	  return histChange
+	}
+
+	// Pop all selection events off the end of a history array. Stop at
+	// a change event.
+	function clearSelectionEvents(array) {
+	  while (array.length) {
+	    var last = lst(array)
+	    if (last.ranges) { array.pop() }
+	    else { break }
+	  }
+	}
+
+	// Find the top change event in the history. Pop off selection
+	// events that are in the way.
+	function lastChangeEvent(hist, force) {
+	  if (force) {
+	    clearSelectionEvents(hist.done)
+	    return lst(hist.done)
+	  } else if (hist.done.length && !lst(hist.done).ranges) {
+	    return lst(hist.done)
+	  } else if (hist.done.length > 1 && !hist.done[hist.done.length - 2].ranges) {
+	    hist.done.pop()
+	    return lst(hist.done)
+	  }
+	}
+
+	// Register a change in the history. Merges changes that are within
+	// a single operation, or are close together with an origin that
+	// allows merging (starting with "+") into a single event.
+	function addChangeToHistory(doc, change, selAfter, opId) {
+	  var hist = doc.history
+	  hist.undone.length = 0
+	  var time = +new Date, cur
+	  var last
+
+	  if ((hist.lastOp == opId ||
+	       hist.lastOrigin == change.origin && change.origin &&
+	       ((change.origin.charAt(0) == "+" && doc.cm && hist.lastModTime > time - doc.cm.options.historyEventDelay) ||
+	        change.origin.charAt(0) == "*")) &&
+	      (cur = lastChangeEvent(hist, hist.lastOp == opId))) {
+	    // Merge this change into the last event
+	    last = lst(cur.changes)
+	    if (cmp(change.from, change.to) == 0 && cmp(change.from, last.to) == 0) {
+	      // Optimized case for simple insertion -- don't want to add
+	      // new changesets for every character typed
+	      last.to = changeEnd(change)
+	    } else {
+	      // Add new sub-event
+	      cur.changes.push(historyChangeFromChange(doc, change))
+	    }
+	  } else {
+	    // Can not be merged, start a new event.
+	    var before = lst(hist.done)
+	    if (!before || !before.ranges)
+	      { pushSelectionToHistory(doc.sel, hist.done) }
+	    cur = {changes: [historyChangeFromChange(doc, change)],
+	           generation: hist.generation}
+	    hist.done.push(cur)
+	    while (hist.done.length > hist.undoDepth) {
+	      hist.done.shift()
+	      if (!hist.done[0].ranges) { hist.done.shift() }
+	    }
+	  }
+	  hist.done.push(selAfter)
+	  hist.generation = ++hist.maxGeneration
+	  hist.lastModTime = hist.lastSelTime = time
+	  hist.lastOp = hist.lastSelOp = opId
+	  hist.lastOrigin = hist.lastSelOrigin = change.origin
+
+	  if (!last) { signal(doc, "historyAdded") }
+	}
+
+	function selectionEventCanBeMerged(doc, origin, prev, sel) {
+	  var ch = origin.charAt(0)
+	  return ch == "*" ||
+	    ch == "+" &&
+	    prev.ranges.length == sel.ranges.length &&
+	    prev.somethingSelected() == sel.somethingSelected() &&
+	    new Date - doc.history.lastSelTime <= (doc.cm ? doc.cm.options.historyEventDelay : 500)
+	}
+
+	// Called whenever the selection changes, sets the new selection as
+	// the pending selection in the history, and pushes the old pending
+	// selection into the 'done' array when it was significantly
+	// different (in number of selected ranges, emptiness, or time).
+	function addSelectionToHistory(doc, sel, opId, options) {
+	  var hist = doc.history, origin = options && options.origin
+
+	  // A new event is started when the previous origin does not match
+	  // the current, or the origins don't allow matching. Origins
+	  // starting with * are always merged, those starting with + are
+	  // merged when similar and close together in time.
+	  if (opId == hist.lastSelOp ||
+	      (origin && hist.lastSelOrigin == origin &&
+	       (hist.lastModTime == hist.lastSelTime && hist.lastOrigin == origin ||
+	        selectionEventCanBeMerged(doc, origin, lst(hist.done), sel))))
+	    { hist.done[hist.done.length - 1] = sel }
+	  else
+	    { pushSelectionToHistory(sel, hist.done) }
+
+	  hist.lastSelTime = +new Date
+	  hist.lastSelOrigin = origin
+	  hist.lastSelOp = opId
+	  if (options && options.clearRedo !== false)
+	    { clearSelectionEvents(hist.undone) }
+	}
+
+	function pushSelectionToHistory(sel, dest) {
+	  var top = lst(dest)
+	  if (!(top && top.ranges && top.equals(sel)))
+	    { dest.push(sel) }
+	}
+
+	// Used to store marked span information in the history.
+	function attachLocalSpans(doc, change, from, to) {
+	  var existing = change["spans_" + doc.id], n = 0
+	  doc.iter(Math.max(doc.first, from), Math.min(doc.first + doc.size, to), function (line) {
+	    if (line.markedSpans)
+	      { (existing || (existing = change["spans_" + doc.id] = {}))[n] = line.markedSpans }
+	    ++n
+	  })
+	}
+
+	// When un/re-doing restores text containing marked spans, those
+	// that have been explicitly cleared should not be restored.
+	function removeClearedSpans(spans) {
+	  if (!spans) { return null }
+	  var out
+	  for (var i = 0; i < spans.length; ++i) {
+	    if (spans[i].marker.explicitlyCleared) { if (!out) { out = spans.slice(0, i) } }
+	    else if (out) { out.push(spans[i]) }
+	  }
+	  return !out ? spans : out.length ? out : null
+	}
+
+	// Retrieve and filter the old marked spans stored in a change event.
+	function getOldSpans(doc, change) {
+	  var found = change["spans_" + doc.id]
+	  if (!found) { return null }
+	  var nw = []
+	  for (var i = 0; i < change.text.length; ++i)
+	    { nw.push(removeClearedSpans(found[i])) }
+	  return nw
+	}
+
+	// Used for un/re-doing changes from the history. Combines the
+	// result of computing the existing spans with the set of spans that
+	// existed in the history (so that deleting around a span and then
+	// undoing brings back the span).
+	function mergeOldSpans(doc, change) {
+	  var old = getOldSpans(doc, change)
+	  var stretched = stretchSpansOverChange(doc, change)
+	  if (!old) { return stretched }
+	  if (!stretched) { return old }
+
+	  for (var i = 0; i < old.length; ++i) {
+	    var oldCur = old[i], stretchCur = stretched[i]
+	    if (oldCur && stretchCur) {
+	      spans: for (var j = 0; j < stretchCur.length; ++j) {
+	        var span = stretchCur[j]
+	        for (var k = 0; k < oldCur.length; ++k)
+	          { if (oldCur[k].marker == span.marker) { continue spans } }
+	        oldCur.push(span)
+	      }
+	    } else if (stretchCur) {
+	      old[i] = stretchCur
+	    }
+	  }
+	  return old
+	}
+
+	// Used both to provide a JSON-safe object in .getHistory, and, when
+	// detaching a document, to split the history in two
+	function copyHistoryArray(events, newGroup, instantiateSel) {
+	  var copy = []
+	  for (var i = 0; i < events.length; ++i) {
+	    var event = events[i]
+	    if (event.ranges) {
+	      copy.push(instantiateSel ? Selection.prototype.deepCopy.call(event) : event)
+	      continue
+	    }
+	    var changes = event.changes, newChanges = []
+	    copy.push({changes: newChanges})
+	    for (var j = 0; j < changes.length; ++j) {
+	      var change = changes[j], m = (void 0)
+	      newChanges.push({from: change.from, to: change.to, text: change.text})
+	      if (newGroup) { for (var prop in change) { if (m = prop.match(/^spans_(\d+)$/)) {
+	        if (indexOf(newGroup, Number(m[1])) > -1) {
+	          lst(newChanges)[prop] = change[prop]
+	          delete change[prop]
+	        }
+	      } } }
+	    }
+	  }
+	  return copy
+	}
+
+	// The 'scroll' parameter given to many of these indicated whether
+	// the new cursor position should be scrolled into view after
+	// modifying the selection.
+
+	// If shift is held or the extend flag is set, extends a range to
+	// include a given position (and optionally a second position).
+	// Otherwise, simply returns the range between the given positions.
+	// Used for cursor motion and such.
+	function extendRange(doc, range, head, other) {
+	  if (doc.cm && doc.cm.display.shift || doc.extend) {
+	    var anchor = range.anchor
+	    if (other) {
+	      var posBefore = cmp(head, anchor) < 0
+	      if (posBefore != (cmp(other, anchor) < 0)) {
+	        anchor = head
+	        head = other
+	      } else if (posBefore != (cmp(head, other) < 0)) {
+	        head = other
+	      }
+	    }
+	    return new Range(anchor, head)
+	  } else {
+	    return new Range(other || head, head)
+	  }
+	}
+
+	// Extend the primary selection range, discard the rest.
+	function extendSelection(doc, head, other, options) {
+	  setSelection(doc, new Selection([extendRange(doc, doc.sel.primary(), head, other)], 0), options)
+	}
+
+	// Extend all selections (pos is an array of selections with length
+	// equal the number of selections)
+	function extendSelections(doc, heads, options) {
+	  var out = []
+	  for (var i = 0; i < doc.sel.ranges.length; i++)
+	    { out[i] = extendRange(doc, doc.sel.ranges[i], heads[i], null) }
+	  var newSel = normalizeSelection(out, doc.sel.primIndex)
+	  setSelection(doc, newSel, options)
+	}
+
+	// Updates a single range in the selection.
+	function replaceOneSelection(doc, i, range, options) {
+	  var ranges = doc.sel.ranges.slice(0)
+	  ranges[i] = range
+	  setSelection(doc, normalizeSelection(ranges, doc.sel.primIndex), options)
+	}
+
+	// Reset the selection to a single range.
+	function setSimpleSelection(doc, anchor, head, options) {
+	  setSelection(doc, simpleSelection(anchor, head), options)
+	}
+
+	// Give beforeSelectionChange handlers a change to influence a
+	// selection update.
+	function filterSelectionChange(doc, sel, options) {
+	  var obj = {
+	    ranges: sel.ranges,
+	    update: function(ranges) {
+	      var this$1 = this;
+
+	      this.ranges = []
+	      for (var i = 0; i < ranges.length; i++)
+	        { this$1.ranges[i] = new Range(clipPos(doc, ranges[i].anchor),
+	                                   clipPos(doc, ranges[i].head)) }
+	    },
+	    origin: options && options.origin
+	  }
+	  signal(doc, "beforeSelectionChange", doc, obj)
+	  if (doc.cm) { signal(doc.cm, "beforeSelectionChange", doc.cm, obj) }
+	  if (obj.ranges != sel.ranges) { return normalizeSelection(obj.ranges, obj.ranges.length - 1) }
+	  else { return sel }
+	}
+
+	function setSelectionReplaceHistory(doc, sel, options) {
+	  var done = doc.history.done, last = lst(done)
+	  if (last && last.ranges) {
+	    done[done.length - 1] = sel
+	    setSelectionNoUndo(doc, sel, options)
+	  } else {
+	    setSelection(doc, sel, options)
+	  }
+	}
+
+	// Set a new selection.
+	function setSelection(doc, sel, options) {
+	  setSelectionNoUndo(doc, sel, options)
+	  addSelectionToHistory(doc, doc.sel, doc.cm ? doc.cm.curOp.id : NaN, options)
+	}
+
+	function setSelectionNoUndo(doc, sel, options) {
+	  if (hasHandler(doc, "beforeSelectionChange") || doc.cm && hasHandler(doc.cm, "beforeSelectionChange"))
+	    { sel = filterSelectionChange(doc, sel, options) }
+
+	  var bias = options && options.bias ||
+	    (cmp(sel.primary().head, doc.sel.primary().head) < 0 ? -1 : 1)
+	  setSelectionInner(doc, skipAtomicInSelection(doc, sel, bias, true))
+
+	  if (!(options && options.scroll === false) && doc.cm)
+	    { ensureCursorVisible(doc.cm) }
+	}
+
+	function setSelectionInner(doc, sel) {
+	  if (sel.equals(doc.sel)) { return }
+
+	  doc.sel = sel
+
+	  if (doc.cm) {
+	    doc.cm.curOp.updateInput = doc.cm.curOp.selectionChanged = true
+	    signalCursorActivity(doc.cm)
+	  }
+	  signalLater(doc, "cursorActivity", doc)
+	}
+
+	// Verify that the selection does not partially select any atomic
+	// marked ranges.
+	function reCheckSelection(doc) {
+	  setSelectionInner(doc, skipAtomicInSelection(doc, doc.sel, null, false), sel_dontScroll)
+	}
+
+	// Return a selection that does not partially select any atomic
+	// ranges.
+	function skipAtomicInSelection(doc, sel, bias, mayClear) {
+	  var out
+	  for (var i = 0; i < sel.ranges.length; i++) {
+	    var range = sel.ranges[i]
+	    var old = sel.ranges.length == doc.sel.ranges.length && doc.sel.ranges[i]
+	    var newAnchor = skipAtomic(doc, range.anchor, old && old.anchor, bias, mayClear)
+	    var newHead = skipAtomic(doc, range.head, old && old.head, bias, mayClear)
+	    if (out || newAnchor != range.anchor || newHead != range.head) {
+	      if (!out) { out = sel.ranges.slice(0, i) }
+	      out[i] = new Range(newAnchor, newHead)
+	    }
+	  }
+	  return out ? normalizeSelection(out, sel.primIndex) : sel
+	}
+
+	function skipAtomicInner(doc, pos, oldPos, dir, mayClear) {
+	  var line = getLine(doc, pos.line)
+	  if (line.markedSpans) { for (var i = 0; i < line.markedSpans.length; ++i) {
+	    var sp = line.markedSpans[i], m = sp.marker
+	    if ((sp.from == null || (m.inclusiveLeft ? sp.from <= pos.ch : sp.from < pos.ch)) &&
+	        (sp.to == null || (m.inclusiveRight ? sp.to >= pos.ch : sp.to > pos.ch))) {
+	      if (mayClear) {
+	        signal(m, "beforeCursorEnter")
+	        if (m.explicitlyCleared) {
+	          if (!line.markedSpans) { break }
+	          else {--i; continue}
+	        }
+	      }
+	      if (!m.atomic) { continue }
+
+	      if (oldPos) {
+	        var near = m.find(dir < 0 ? 1 : -1), diff = (void 0)
+	        if (dir < 0 ? m.inclusiveRight : m.inclusiveLeft)
+	          { near = movePos(doc, near, -dir, near && near.line == pos.line ? line : null) }
+	        if (near && near.line == pos.line && (diff = cmp(near, oldPos)) && (dir < 0 ? diff < 0 : diff > 0))
+	          { return skipAtomicInner(doc, near, pos, dir, mayClear) }
+	      }
+
+	      var far = m.find(dir < 0 ? -1 : 1)
+	      if (dir < 0 ? m.inclusiveLeft : m.inclusiveRight)
+	        { far = movePos(doc, far, dir, far.line == pos.line ? line : null) }
+	      return far ? skipAtomicInner(doc, far, pos, dir, mayClear) : null
+	    }
+	  } }
+	  return pos
+	}
+
+	// Ensure a given position is not inside an atomic range.
+	function skipAtomic(doc, pos, oldPos, bias, mayClear) {
+	  var dir = bias || 1
+	  var found = skipAtomicInner(doc, pos, oldPos, dir, mayClear) ||
+	      (!mayClear && skipAtomicInner(doc, pos, oldPos, dir, true)) ||
+	      skipAtomicInner(doc, pos, oldPos, -dir, mayClear) ||
+	      (!mayClear && skipAtomicInner(doc, pos, oldPos, -dir, true))
+	  if (!found) {
+	    doc.cantEdit = true
+	    return Pos(doc.first, 0)
+	  }
+	  return found
+	}
+
+	function movePos(doc, pos, dir, line) {
+	  if (dir < 0 && pos.ch == 0) {
+	    if (pos.line > doc.first) { return clipPos(doc, Pos(pos.line - 1)) }
+	    else { return null }
+	  } else if (dir > 0 && pos.ch == (line || getLine(doc, pos.line)).text.length) {
+	    if (pos.line < doc.first + doc.size - 1) { return Pos(pos.line + 1, 0) }
+	    else { return null }
+	  } else {
+	    return new Pos(pos.line, pos.ch + dir)
+	  }
+	}
+
+	function selectAll(cm) {
+	  cm.setSelection(Pos(cm.firstLine(), 0), Pos(cm.lastLine()), sel_dontScroll)
+	}
+
+	// UPDATING
+
+	// Allow "beforeChange" event handlers to influence a change
+	function filterChange(doc, change, update) {
+	  var obj = {
+	    canceled: false,
+	    from: change.from,
+	    to: change.to,
+	    text: change.text,
+	    origin: change.origin,
+	    cancel: function () { return obj.canceled = true; }
+	  }
+	  if (update) { obj.update = function (from, to, text, origin) {
+	    if (from) { obj.from = clipPos(doc, from) }
+	    if (to) { obj.to = clipPos(doc, to) }
+	    if (text) { obj.text = text }
+	    if (origin !== undefined) { obj.origin = origin }
+	  } }
+	  signal(doc, "beforeChange", doc, obj)
+	  if (doc.cm) { signal(doc.cm, "beforeChange", doc.cm, obj) }
+
+	  if (obj.canceled) { return null }
+	  return {from: obj.from, to: obj.to, text: obj.text, origin: obj.origin}
+	}
+
+	// Apply a change to a document, and add it to the document's
+	// history, and propagating it to all linked documents.
+	function makeChange(doc, change, ignoreReadOnly) {
+	  if (doc.cm) {
+	    if (!doc.cm.curOp) { return operation(doc.cm, makeChange)(doc, change, ignoreReadOnly) }
+	    if (doc.cm.state.suppressEdits) { return }
+	  }
+
+	  if (hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange")) {
+	    change = filterChange(doc, change, true)
+	    if (!change) { return }
+	  }
+
+	  // Possibly split or suppress the update based on the presence
+	  // of read-only spans in its range.
+	  var split = sawReadOnlySpans && !ignoreReadOnly && removeReadOnlyRanges(doc, change.from, change.to)
+	  if (split) {
+	    for (var i = split.length - 1; i >= 0; --i)
+	      { makeChangeInner(doc, {from: split[i].from, to: split[i].to, text: i ? [""] : change.text}) }
+	  } else {
+	    makeChangeInner(doc, change)
+	  }
+	}
+
+	function makeChangeInner(doc, change) {
+	  if (change.text.length == 1 && change.text[0] == "" && cmp(change.from, change.to) == 0) { return }
+	  var selAfter = computeSelAfterChange(doc, change)
+	  addChangeToHistory(doc, change, selAfter, doc.cm ? doc.cm.curOp.id : NaN)
+
+	  makeChangeSingleDoc(doc, change, selAfter, stretchSpansOverChange(doc, change))
+	  var rebased = []
+
+	  linkedDocs(doc, function (doc, sharedHist) {
+	    if (!sharedHist && indexOf(rebased, doc.history) == -1) {
+	      rebaseHist(doc.history, change)
+	      rebased.push(doc.history)
+	    }
+	    makeChangeSingleDoc(doc, change, null, stretchSpansOverChange(doc, change))
+	  })
+	}
+
+	// Revert a change stored in a document's history.
+	function makeChangeFromHistory(doc, type, allowSelectionOnly) {
+	  if (doc.cm && doc.cm.state.suppressEdits && !allowSelectionOnly) { return }
+
+	  var hist = doc.history, event, selAfter = doc.sel
+	  var source = type == "undo" ? hist.done : hist.undone, dest = type == "undo" ? hist.undone : hist.done
+
+	  // Verify that there is a useable event (so that ctrl-z won't
+	  // needlessly clear selection events)
+	  var i = 0
+	  for (; i < source.length; i++) {
+	    event = source[i]
+	    if (allowSelectionOnly ? event.ranges && !event.equals(doc.sel) : !event.ranges)
+	      { break }
+	  }
+	  if (i == source.length) { return }
+	  hist.lastOrigin = hist.lastSelOrigin = null
+
+	  for (;;) {
+	    event = source.pop()
+	    if (event.ranges) {
+	      pushSelectionToHistory(event, dest)
+	      if (allowSelectionOnly && !event.equals(doc.sel)) {
+	        setSelection(doc, event, {clearRedo: false})
+	        return
+	      }
+	      selAfter = event
+	    }
+	    else { break }
+	  }
+
+	  // Build up a reverse change object to add to the opposite history
+	  // stack (redo when undoing, and vice versa).
+	  var antiChanges = []
+	  pushSelectionToHistory(selAfter, dest)
+	  dest.push({changes: antiChanges, generation: hist.generation})
+	  hist.generation = event.generation || ++hist.maxGeneration
+
+	  var filter = hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange")
+
+	  var loop = function ( i ) {
+	    var change = event.changes[i]
+	    change.origin = type
+	    if (filter && !filterChange(doc, change, false)) {
+	      source.length = 0
+	      return {}
+	    }
+
+	    antiChanges.push(historyChangeFromChange(doc, change))
+
+	    var after = i ? computeSelAfterChange(doc, change) : lst(source)
+	    makeChangeSingleDoc(doc, change, after, mergeOldSpans(doc, change))
+	    if (!i && doc.cm) { doc.cm.scrollIntoView({from: change.from, to: changeEnd(change)}) }
+	    var rebased = []
+
+	    // Propagate to the linked documents
+	    linkedDocs(doc, function (doc, sharedHist) {
+	      if (!sharedHist && indexOf(rebased, doc.history) == -1) {
+	        rebaseHist(doc.history, change)
+	        rebased.push(doc.history)
+	      }
+	      makeChangeSingleDoc(doc, change, null, mergeOldSpans(doc, change))
+	    })
+	  };
+
+	  for (var i$1 = event.changes.length - 1; i$1 >= 0; --i$1) {
+	    var returned = loop( i$1 );
+
+	    if ( returned ) return returned.v;
+	  }
+	}
+
+	// Sub-views need their line numbers shifted when text is added
+	// above or below them in the parent document.
+	function shiftDoc(doc, distance) {
+	  if (distance == 0) { return }
+	  doc.first += distance
+	  doc.sel = new Selection(map(doc.sel.ranges, function (range) { return new Range(
+	    Pos(range.anchor.line + distance, range.anchor.ch),
+	    Pos(range.head.line + distance, range.head.ch)
+	  ); }), doc.sel.primIndex)
+	  if (doc.cm) {
+	    regChange(doc.cm, doc.first, doc.first - distance, distance)
+	    for (var d = doc.cm.display, l = d.viewFrom; l < d.viewTo; l++)
+	      { regLineChange(doc.cm, l, "gutter") }
+	  }
+	}
+
+	// More lower-level change function, handling only a single document
+	// (not linked ones).
+	function makeChangeSingleDoc(doc, change, selAfter, spans) {
+	  if (doc.cm && !doc.cm.curOp)
+	    { return operation(doc.cm, makeChangeSingleDoc)(doc, change, selAfter, spans) }
+
+	  if (change.to.line < doc.first) {
+	    shiftDoc(doc, change.text.length - 1 - (change.to.line - change.from.line))
+	    return
+	  }
+	  if (change.from.line > doc.lastLine()) { return }
+
+	  // Clip the change to the size of this doc
+	  if (change.from.line < doc.first) {
+	    var shift = change.text.length - 1 - (doc.first - change.from.line)
+	    shiftDoc(doc, shift)
+	    change = {from: Pos(doc.first, 0), to: Pos(change.to.line + shift, change.to.ch),
+	              text: [lst(change.text)], origin: change.origin}
+	  }
+	  var last = doc.lastLine()
+	  if (change.to.line > last) {
+	    change = {from: change.from, to: Pos(last, getLine(doc, last).text.length),
+	              text: [change.text[0]], origin: change.origin}
+	  }
+
+	  change.removed = getBetween(doc, change.from, change.to)
+
+	  if (!selAfter) { selAfter = computeSelAfterChange(doc, change) }
+	  if (doc.cm) { makeChangeSingleDocInEditor(doc.cm, change, spans) }
+	  else { updateDoc(doc, change, spans) }
+	  setSelectionNoUndo(doc, selAfter, sel_dontScroll)
+	}
+
+	// Handle the interaction of a change to a document with the editor
+	// that this document is part of.
+	function makeChangeSingleDocInEditor(cm, change, spans) {
+	  var doc = cm.doc, display = cm.display, from = change.from, to = change.to
+
+	  var recomputeMaxLength = false, checkWidthStart = from.line
+	  if (!cm.options.lineWrapping) {
+	    checkWidthStart = lineNo(visualLine(getLine(doc, from.line)))
+	    doc.iter(checkWidthStart, to.line + 1, function (line) {
+	      if (line == display.maxLine) {
+	        recomputeMaxLength = true
+	        return true
+	      }
+	    })
+	  }
+
+	  if (doc.sel.contains(change.from, change.to) > -1)
+	    { signalCursorActivity(cm) }
+
+	  updateDoc(doc, change, spans, estimateHeight(cm))
+
+	  if (!cm.options.lineWrapping) {
+	    doc.iter(checkWidthStart, from.line + change.text.length, function (line) {
+	      var len = lineLength(line)
+	      if (len > display.maxLineLength) {
+	        display.maxLine = line
+	        display.maxLineLength = len
+	        display.maxLineChanged = true
+	        recomputeMaxLength = false
+	      }
+	    })
+	    if (recomputeMaxLength) { cm.curOp.updateMaxLine = true }
+	  }
+
+	  // Adjust frontier, schedule worker
+	  doc.frontier = Math.min(doc.frontier, from.line)
+	  startWorker(cm, 400)
+
+	  var lendiff = change.text.length - (to.line - from.line) - 1
+	  // Remember that these lines changed, for updating the display
+	  if (change.full)
+	    { regChange(cm) }
+	  else if (from.line == to.line && change.text.length == 1 && !isWholeLineUpdate(cm.doc, change))
+	    { regLineChange(cm, from.line, "text") }
+	  else
+	    { regChange(cm, from.line, to.line + 1, lendiff) }
+
+	  var changesHandler = hasHandler(cm, "changes"), changeHandler = hasHandler(cm, "change")
+	  if (changeHandler || changesHandler) {
+	    var obj = {
+	      from: from, to: to,
+	      text: change.text,
+	      removed: change.removed,
+	      origin: change.origin
+	    }
+	    if (changeHandler) { signalLater(cm, "change", cm, obj) }
+	    if (changesHandler) { (cm.curOp.changeObjs || (cm.curOp.changeObjs = [])).push(obj) }
+	  }
+	  cm.display.selForContextMenu = null
+	}
+
+	function replaceRange(doc, code, from, to, origin) {
+	  if (!to) { to = from }
+	  if (cmp(to, from) < 0) { var tmp = to; to = from; from = tmp }
+	  if (typeof code == "string") { code = doc.splitLines(code) }
+	  makeChange(doc, {from: from, to: to, text: code, origin: origin})
+	}
+
+	// Rebasing/resetting history to deal with externally-sourced changes
+
+	function rebaseHistSelSingle(pos, from, to, diff) {
+	  if (to < pos.line) {
+	    pos.line += diff
+	  } else if (from < pos.line) {
+	    pos.line = from
+	    pos.ch = 0
+	  }
+	}
+
+	// Tries to rebase an array of history events given a change in the
+	// document. If the change touches the same lines as the event, the
+	// event, and everything 'behind' it, is discarded. If the change is
+	// before the event, the event's positions are updated. Uses a
+	// copy-on-write scheme for the positions, to avoid having to
+	// reallocate them all on every rebase, but also avoid problems with
+	// shared position objects being unsafely updated.
+	function rebaseHistArray(array, from, to, diff) {
+	  for (var i = 0; i < array.length; ++i) {
+	    var sub = array[i], ok = true
+	    if (sub.ranges) {
+	      if (!sub.copied) { sub = array[i] = sub.deepCopy(); sub.copied = true }
+	      for (var j = 0; j < sub.ranges.length; j++) {
+	        rebaseHistSelSingle(sub.ranges[j].anchor, from, to, diff)
+	        rebaseHistSelSingle(sub.ranges[j].head, from, to, diff)
+	      }
+	      continue
+	    }
+	    for (var j$1 = 0; j$1 < sub.changes.length; ++j$1) {
+	      var cur = sub.changes[j$1]
+	      if (to < cur.from.line) {
+	        cur.from = Pos(cur.from.line + diff, cur.from.ch)
+	        cur.to = Pos(cur.to.line + diff, cur.to.ch)
+	      } else if (from <= cur.to.line) {
+	        ok = false
+	        break
+	      }
+	    }
+	    if (!ok) {
+	      array.splice(0, i + 1)
+	      i = 0
+	    }
+	  }
+	}
+
+	function rebaseHist(hist, change) {
+	  var from = change.from.line, to = change.to.line, diff = change.text.length - (to - from) - 1
+	  rebaseHistArray(hist.done, from, to, diff)
+	  rebaseHistArray(hist.undone, from, to, diff)
+	}
+
+	// Utility for applying a change to a line by handle or number,
+	// returning the number and optionally registering the line as
+	// changed.
+	function changeLine(doc, handle, changeType, op) {
+	  var no = handle, line = handle
+	  if (typeof handle == "number") { line = getLine(doc, clipLine(doc, handle)) }
+	  else { no = lineNo(handle) }
+	  if (no == null) { return null }
+	  if (op(line, no) && doc.cm) { regLineChange(doc.cm, no, changeType) }
+	  return line
+	}
+
+	// The document is represented as a BTree consisting of leaves, with
+	// chunk of lines in them, and branches, with up to ten leaves or
+	// other branch nodes below them. The top node is always a branch
+	// node, and is the document object itself (meaning it has
+	// additional methods and properties).
+	//
+	// All nodes have parent links. The tree is used both to go from
+	// line numbers to line objects, and to go from objects to numbers.
+	// It also indexes by height, and is used to convert between height
+	// and line object, and to find the total height of the document.
+	//
+	// See also http://marijnhaverbeke.nl/blog/codemirror-line-tree.html
+
+	function LeafChunk(lines) {
+	  var this$1 = this;
+
+	  this.lines = lines
+	  this.parent = null
+	  var height = 0
+	  for (var i = 0; i < lines.length; ++i) {
+	    lines[i].parent = this$1
+	    height += lines[i].height
+	  }
+	  this.height = height
+	}
+
+	LeafChunk.prototype = {
+	  chunkSize: function() { return this.lines.length },
+	  // Remove the n lines at offset 'at'.
+	  removeInner: function(at, n) {
+	    var this$1 = this;
+
+	    for (var i = at, e = at + n; i < e; ++i) {
+	      var line = this$1.lines[i]
+	      this$1.height -= line.height
+	      cleanUpLine(line)
+	      signalLater(line, "delete")
+	    }
+	    this.lines.splice(at, n)
+	  },
+	  // Helper used to collapse a small branch into a single leaf.
+	  collapse: function(lines) {
+	    lines.push.apply(lines, this.lines)
+	  },
+	  // Insert the given array of lines at offset 'at', count them as
+	  // having the given height.
+	  insertInner: function(at, lines, height) {
+	    var this$1 = this;
+
+	    this.height += height
+	    this.lines = this.lines.slice(0, at).concat(lines).concat(this.lines.slice(at))
+	    for (var i = 0; i < lines.length; ++i) { lines[i].parent = this$1 }
+	  },
+	  // Used to iterate over a part of the tree.
+	  iterN: function(at, n, op) {
+	    var this$1 = this;
+
+	    for (var e = at + n; at < e; ++at)
+	      { if (op(this$1.lines[at])) { return true } }
+	  }
+	}
+
+	function BranchChunk(children) {
+	  var this$1 = this;
+
+	  this.children = children
+	  var size = 0, height = 0
+	  for (var i = 0; i < children.length; ++i) {
+	    var ch = children[i]
+	    size += ch.chunkSize(); height += ch.height
+	    ch.parent = this$1
+	  }
+	  this.size = size
+	  this.height = height
+	  this.parent = null
+	}
+
+	BranchChunk.prototype = {
+	  chunkSize: function() { return this.size },
+	  removeInner: function(at, n) {
+	    var this$1 = this;
+
+	    this.size -= n
+	    for (var i = 0; i < this.children.length; ++i) {
+	      var child = this$1.children[i], sz = child.chunkSize()
+	      if (at < sz) {
+	        var rm = Math.min(n, sz - at), oldHeight = child.height
+	        child.removeInner(at, rm)
+	        this$1.height -= oldHeight - child.height
+	        if (sz == rm) { this$1.children.splice(i--, 1); child.parent = null }
+	        if ((n -= rm) == 0) { break }
+	        at = 0
+	      } else { at -= sz }
+	    }
+	    // If the result is smaller than 25 lines, ensure that it is a
+	    // single leaf node.
+	    if (this.size - n < 25 &&
+	        (this.children.length > 1 || !(this.children[0] instanceof LeafChunk))) {
+	      var lines = []
+	      this.collapse(lines)
+	      this.children = [new LeafChunk(lines)]
+	      this.children[0].parent = this
+	    }
+	  },
+	  collapse: function(lines) {
+	    var this$1 = this;
+
+	    for (var i = 0; i < this.children.length; ++i) { this$1.children[i].collapse(lines) }
+	  },
+	  insertInner: function(at, lines, height) {
+	    var this$1 = this;
+
+	    this.size += lines.length
+	    this.height += height
+	    for (var i = 0; i < this.children.length; ++i) {
+	      var child = this$1.children[i], sz = child.chunkSize()
+	      if (at <= sz) {
+	        child.insertInner(at, lines, height)
+	        if (child.lines && child.lines.length > 50) {
+	          // To avoid memory thrashing when child.lines is huge (e.g. first view of a large file), it's never spliced.
+	          // Instead, small slices are taken. They're taken in order because sequential memory accesses are fastest.
+	          var remaining = child.lines.length % 25 + 25
+	          for (var pos = remaining; pos < child.lines.length;) {
+	            var leaf = new LeafChunk(child.lines.slice(pos, pos += 25))
+	            child.height -= leaf.height
+	            this$1.children.splice(++i, 0, leaf)
+	            leaf.parent = this$1
+	          }
+	          child.lines = child.lines.slice(0, remaining)
+	          this$1.maybeSpill()
+	        }
+	        break
+	      }
+	      at -= sz
+	    }
+	  },
+	  // When a node has grown, check whether it should be split.
+	  maybeSpill: function() {
+	    if (this.children.length <= 10) { return }
+	    var me = this
+	    do {
+	      var spilled = me.children.splice(me.children.length - 5, 5)
+	      var sibling = new BranchChunk(spilled)
+	      if (!me.parent) { // Become the parent node
+	        var copy = new BranchChunk(me.children)
+	        copy.parent = me
+	        me.children = [copy, sibling]
+	        me = copy
+	     } else {
+	        me.size -= sibling.size
+	        me.height -= sibling.height
+	        var myIndex = indexOf(me.parent.children, me)
+	        me.parent.children.splice(myIndex + 1, 0, sibling)
+	      }
+	      sibling.parent = me.parent
+	    } while (me.children.length > 10)
+	    me.parent.maybeSpill()
+	  },
+	  iterN: function(at, n, op) {
+	    var this$1 = this;
+
+	    for (var i = 0; i < this.children.length; ++i) {
+	      var child = this$1.children[i], sz = child.chunkSize()
+	      if (at < sz) {
+	        var used = Math.min(n, sz - at)
+	        if (child.iterN(at, used, op)) { return true }
+	        if ((n -= used) == 0) { break }
+	        at = 0
+	      } else { at -= sz }
+	    }
+	  }
+	}
+
+	// Line widgets are block elements displayed above or below a line.
+
+	function LineWidget(doc, node, options) {
+	  var this$1 = this;
+
+	  if (options) { for (var opt in options) { if (options.hasOwnProperty(opt))
+	    { this$1[opt] = options[opt] } } }
+	  this.doc = doc
+	  this.node = node
+	}
+	eventMixin(LineWidget)
+
+	function adjustScrollWhenAboveVisible(cm, line, diff) {
+	  if (heightAtLine(line) < ((cm.curOp && cm.curOp.scrollTop) || cm.doc.scrollTop))
+	    { addToScrollPos(cm, null, diff) }
+	}
+
+	LineWidget.prototype.clear = function() {
+	  var this$1 = this;
+
+	  var cm = this.doc.cm, ws = this.line.widgets, line = this.line, no = lineNo(line)
+	  if (no == null || !ws) { return }
+	  for (var i = 0; i < ws.length; ++i) { if (ws[i] == this$1) { ws.splice(i--, 1) } }
+	  if (!ws.length) { line.widgets = null }
+	  var height = widgetHeight(this)
+	  updateLineHeight(line, Math.max(0, line.height - height))
+	  if (cm) { runInOp(cm, function () {
+	    adjustScrollWhenAboveVisible(cm, line, -height)
+	    regLineChange(cm, no, "widget")
+	  }) }
+	}
+	LineWidget.prototype.changed = function() {
+	  var oldH = this.height, cm = this.doc.cm, line = this.line
+	  this.height = null
+	  var diff = widgetHeight(this) - oldH
+	  if (!diff) { return }
+	  updateLineHeight(line, line.height + diff)
+	  if (cm) { runInOp(cm, function () {
+	    cm.curOp.forceUpdate = true
+	    adjustScrollWhenAboveVisible(cm, line, diff)
+	  }) }
+	}
+
+	function addLineWidget(doc, handle, node, options) {
+	  var widget = new LineWidget(doc, node, options)
+	  var cm = doc.cm
+	  if (cm && widget.noHScroll) { cm.display.alignWidgets = true }
+	  changeLine(doc, handle, "widget", function (line) {
+	    var widgets = line.widgets || (line.widgets = [])
+	    if (widget.insertAt == null) { widgets.push(widget) }
+	    else { widgets.splice(Math.min(widgets.length - 1, Math.max(0, widget.insertAt)), 0, widget) }
+	    widget.line = line
+	    if (cm && !lineIsHidden(doc, line)) {
+	      var aboveVisible = heightAtLine(line) < doc.scrollTop
+	      updateLineHeight(line, line.height + widgetHeight(widget))
+	      if (aboveVisible) { addToScrollPos(cm, null, widget.height) }
+	      cm.curOp.forceUpdate = true
+	    }
+	    return true
+	  })
+	  return widget
+	}
+
+	// TEXTMARKERS
+
+	// Created with markText and setBookmark methods. A TextMarker is a
+	// handle that can be used to clear or find a marked position in the
+	// document. Line objects hold arrays (markedSpans) containing
+	// {from, to, marker} object pointing to such marker objects, and
+	// indicating that such a marker is present on that line. Multiple
+	// lines may point to the same marker when it spans across lines.
+	// The spans will have null for their from/to properties when the
+	// marker continues beyond the start/end of the line. Markers have
+	// links back to the lines they currently touch.
+
+	// Collapsed markers have unique ids, in order to be able to order
+	// them, which is needed for uniquely determining an outer marker
+	// when they overlap (they may nest, but not partially overlap).
+	var nextMarkerId = 0
+
+	function TextMarker(doc, type) {
+	  this.lines = []
+	  this.type = type
+	  this.doc = doc
+	  this.id = ++nextMarkerId
+	}
+	eventMixin(TextMarker)
+
+	// Clear the marker.
+	TextMarker.prototype.clear = function() {
+	  var this$1 = this;
+
+	  if (this.explicitlyCleared) { return }
+	  var cm = this.doc.cm, withOp = cm && !cm.curOp
+	  if (withOp) { startOperation(cm) }
+	  if (hasHandler(this, "clear")) {
+	    var found = this.find()
+	    if (found) { signalLater(this, "clear", found.from, found.to) }
+	  }
+	  var min = null, max = null
+	  for (var i = 0; i < this.lines.length; ++i) {
+	    var line = this$1.lines[i]
+	    var span = getMarkedSpanFor(line.markedSpans, this$1)
+	    if (cm && !this$1.collapsed) { regLineChange(cm, lineNo(line), "text") }
+	    else if (cm) {
+	      if (span.to != null) { max = lineNo(line) }
+	      if (span.from != null) { min = lineNo(line) }
+	    }
+	    line.markedSpans = removeMarkedSpan(line.markedSpans, span)
+	    if (span.from == null && this$1.collapsed && !lineIsHidden(this$1.doc, line) && cm)
+	      { updateLineHeight(line, textHeight(cm.display)) }
+	  }
+	  if (cm && this.collapsed && !cm.options.lineWrapping) { for (var i$1 = 0; i$1 < this.lines.length; ++i$1) {
+	    var visual = visualLine(this$1.lines[i$1]), len = lineLength(visual)
+	    if (len > cm.display.maxLineLength) {
+	      cm.display.maxLine = visual
+	      cm.display.maxLineLength = len
+	      cm.display.maxLineChanged = true
+	    }
+	  } }
+
+	  if (min != null && cm && this.collapsed) { regChange(cm, min, max + 1) }
+	  this.lines.length = 0
+	  this.explicitlyCleared = true
+	  if (this.atomic && this.doc.cantEdit) {
+	    this.doc.cantEdit = false
+	    if (cm) { reCheckSelection(cm.doc) }
+	  }
+	  if (cm) { signalLater(cm, "markerCleared", cm, this) }
+	  if (withOp) { endOperation(cm) }
+	  if (this.parent) { this.parent.clear() }
+	}
+
+	// Find the position of the marker in the document. Returns a {from,
+	// to} object by default. Side can be passed to get a specific side
+	// -- 0 (both), -1 (left), or 1 (right). When lineObj is true, the
+	// Pos objects returned contain a line object, rather than a line
+	// number (used to prevent looking up the same line twice).
+	TextMarker.prototype.find = function(side, lineObj) {
+	  var this$1 = this;
+
+	  if (side == null && this.type == "bookmark") { side = 1 }
+	  var from, to
+	  for (var i = 0; i < this.lines.length; ++i) {
+	    var line = this$1.lines[i]
+	    var span = getMarkedSpanFor(line.markedSpans, this$1)
+	    if (span.from != null) {
+	      from = Pos(lineObj ? line : lineNo(line), span.from)
+	      if (side == -1) { return from }
+	    }
+	    if (span.to != null) {
+	      to = Pos(lineObj ? line : lineNo(line), span.to)
+	      if (side == 1) { return to }
+	    }
+	  }
+	  return from && {from: from, to: to}
+	}
+
+	// Signals that the marker's widget changed, and surrounding layout
+	// should be recomputed.
+	TextMarker.prototype.changed = function() {
+	  var pos = this.find(-1, true), widget = this, cm = this.doc.cm
+	  if (!pos || !cm) { return }
+	  runInOp(cm, function () {
+	    var line = pos.line, lineN = lineNo(pos.line)
+	    var view = findViewForLine(cm, lineN)
+	    if (view) {
+	      clearLineMeasurementCacheFor(view)
+	      cm.curOp.selectionChanged = cm.curOp.forceUpdate = true
+	    }
+	    cm.curOp.updateMaxLine = true
+	    if (!lineIsHidden(widget.doc, line) && widget.height != null) {
+	      var oldHeight = widget.height
+	      widget.height = null
+	      var dHeight = widgetHeight(widget) - oldHeight
+	      if (dHeight)
+	        { updateLineHeight(line, line.height + dHeight) }
+	    }
+	  })
+	}
+
+	TextMarker.prototype.attachLine = function(line) {
+	  if (!this.lines.length && this.doc.cm) {
+	    var op = this.doc.cm.curOp
+	    if (!op.maybeHiddenMarkers || indexOf(op.maybeHiddenMarkers, this) == -1)
+	      { (op.maybeUnhiddenMarkers || (op.maybeUnhiddenMarkers = [])).push(this) }
+	  }
+	  this.lines.push(line)
+	}
+	TextMarker.prototype.detachLine = function(line) {
+	  this.lines.splice(indexOf(this.lines, line), 1)
+	  if (!this.lines.length && this.doc.cm) {
+	    var op = this.doc.cm.curOp
+	    ;(op.maybeHiddenMarkers || (op.maybeHiddenMarkers = [])).push(this)
+	  }
+	}
+
+	// Create a marker, wire it up to the right lines, and
+	function markText(doc, from, to, options, type) {
+	  // Shared markers (across linked documents) are handled separately
+	  // (markTextShared will call out to this again, once per
+	  // document).
+	  if (options && options.shared) { return markTextShared(doc, from, to, options, type) }
+	  // Ensure we are in an operation.
+	  if (doc.cm && !doc.cm.curOp) { return operation(doc.cm, markText)(doc, from, to, options, type) }
+
+	  var marker = new TextMarker(doc, type), diff = cmp(from, to)
+	  if (options) { copyObj(options, marker, false) }
+	  // Don't connect empty markers unless clearWhenEmpty is false
+	  if (diff > 0 || diff == 0 && marker.clearWhenEmpty !== false)
+	    { return marker }
+	  if (marker.replacedWith) {
+	    // Showing up as a widget implies collapsed (widget replaces text)
+	    marker.collapsed = true
+	    marker.widgetNode = elt("span", [marker.replacedWith], "CodeMirror-widget")
+	    if (!options.handleMouseEvents) { marker.widgetNode.setAttribute("cm-ignore-events", "true") }
+	    if (options.insertLeft) { marker.widgetNode.insertLeft = true }
+	  }
+	  if (marker.collapsed) {
+	    if (conflictingCollapsedRange(doc, from.line, from, to, marker) ||
+	        from.line != to.line && conflictingCollapsedRange(doc, to.line, from, to, marker))
+	      { throw new Error("Inserting collapsed marker partially overlapping an existing one") }
+	    seeCollapsedSpans()
+	  }
+
+	  if (marker.addToHistory)
+	    { addChangeToHistory(doc, {from: from, to: to, origin: "markText"}, doc.sel, NaN) }
+
+	  var curLine = from.line, cm = doc.cm, updateMaxLine
+	  doc.iter(curLine, to.line + 1, function (line) {
+	    if (cm && marker.collapsed && !cm.options.lineWrapping && visualLine(line) == cm.display.maxLine)
+	      { updateMaxLine = true }
+	    if (marker.collapsed && curLine != from.line) { updateLineHeight(line, 0) }
+	    addMarkedSpan(line, new MarkedSpan(marker,
+	                                       curLine == from.line ? from.ch : null,
+	                                       curLine == to.line ? to.ch : null))
+	    ++curLine
+	  })
+	  // lineIsHidden depends on the presence of the spans, so needs a second pass
+	  if (marker.collapsed) { doc.iter(from.line, to.line + 1, function (line) {
+	    if (lineIsHidden(doc, line)) { updateLineHeight(line, 0) }
+	  }) }
+
+	  if (marker.clearOnEnter) { on(marker, "beforeCursorEnter", function () { return marker.clear(); }) }
+
+	  if (marker.readOnly) {
+	    seeReadOnlySpans()
+	    if (doc.history.done.length || doc.history.undone.length)
+	      { doc.clearHistory() }
+	  }
+	  if (marker.collapsed) {
+	    marker.id = ++nextMarkerId
+	    marker.atomic = true
+	  }
+	  if (cm) {
+	    // Sync editor state
+	    if (updateMaxLine) { cm.curOp.updateMaxLine = true }
+	    if (marker.collapsed)
+	      { regChange(cm, from.line, to.line + 1) }
+	    else if (marker.className || marker.title || marker.startStyle || marker.endStyle || marker.css)
+	      { for (var i = from.line; i <= to.line; i++) { regLineChange(cm, i, "text") } }
+	    if (marker.atomic) { reCheckSelection(cm.doc) }
+	    signalLater(cm, "markerAdded", cm, marker)
+	  }
+	  return marker
+	}
+
+	// SHARED TEXTMARKERS
+
+	// A shared marker spans multiple linked documents. It is
+	// implemented as a meta-marker-object controlling multiple normal
+	// markers.
+	function SharedTextMarker(markers, primary) {
+	  var this$1 = this;
+
+	  this.markers = markers
+	  this.primary = primary
+	  for (var i = 0; i < markers.length; ++i)
+	    { markers[i].parent = this$1 }
+	}
+	eventMixin(SharedTextMarker)
+
+	SharedTextMarker.prototype.clear = function() {
+	  var this$1 = this;
+
+	  if (this.explicitlyCleared) { return }
+	  this.explicitlyCleared = true
+	  for (var i = 0; i < this.markers.length; ++i)
+	    { this$1.markers[i].clear() }
+	  signalLater(this, "clear")
+	}
+	SharedTextMarker.prototype.find = function(side, lineObj) {
+	  return this.primary.find(side, lineObj)
+	}
+
+	function markTextShared(doc, from, to, options, type) {
+	  options = copyObj(options)
+	  options.shared = false
+	  var markers = [markText(doc, from, to, options, type)], primary = markers[0]
+	  var widget = options.widgetNode
+	  linkedDocs(doc, function (doc) {
+	    if (widget) { options.widgetNode = widget.cloneNode(true) }
+	    markers.push(markText(doc, clipPos(doc, from), clipPos(doc, to), options, type))
+	    for (var i = 0; i < doc.linked.length; ++i)
+	      { if (doc.linked[i].isParent) { return } }
+	    primary = lst(markers)
+	  })
+	  return new SharedTextMarker(markers, primary)
+	}
+
+	function findSharedMarkers(doc) {
+	  return doc.findMarks(Pos(doc.first, 0), doc.clipPos(Pos(doc.lastLine())), function (m) { return m.parent; })
+	}
+
+	function copySharedMarkers(doc, markers) {
+	  for (var i = 0; i < markers.length; i++) {
+	    var marker = markers[i], pos = marker.find()
+	    var mFrom = doc.clipPos(pos.from), mTo = doc.clipPos(pos.to)
+	    if (cmp(mFrom, mTo)) {
+	      var subMark = markText(doc, mFrom, mTo, marker.primary, marker.primary.type)
+	      marker.markers.push(subMark)
+	      subMark.parent = marker
+	    }
+	  }
+	}
+
+	function detachSharedMarkers(markers) {
+	  var loop = function ( i ) {
+	    var marker = markers[i], linked = [marker.primary.doc]
+	    linkedDocs(marker.primary.doc, function (d) { return linked.push(d); })
+	    for (var j = 0; j < marker.markers.length; j++) {
+	      var subMarker = marker.markers[j]
+	      if (indexOf(linked, subMarker.doc) == -1) {
+	        subMarker.parent = null
+	        marker.markers.splice(j--, 1)
+	      }
+	    }
+	  };
+
+	  for (var i = 0; i < markers.length; i++) loop( i );
+	}
+
+	var nextDocId = 0
+	var Doc = function(text, mode, firstLine, lineSep) {
+	  if (!(this instanceof Doc)) { return new Doc(text, mode, firstLine, lineSep) }
+	  if (firstLine == null) { firstLine = 0 }
+
+	  BranchChunk.call(this, [new LeafChunk([new Line("", null)])])
+	  this.first = firstLine
+	  this.scrollTop = this.scrollLeft = 0
+	  this.cantEdit = false
+	  this.cleanGeneration = 1
+	  this.frontier = firstLine
+	  var start = Pos(firstLine, 0)
+	  this.sel = simpleSelection(start)
+	  this.history = new History(null)
+	  this.id = ++nextDocId
+	  this.modeOption = mode
+	  this.lineSep = lineSep
+	  this.extend = false
+
+	  if (typeof text == "string") { text = this.splitLines(text) }
+	  updateDoc(this, {from: start, to: start, text: text})
+	  setSelection(this, simpleSelection(start), sel_dontScroll)
+	}
+
+	Doc.prototype = createObj(BranchChunk.prototype, {
+	  constructor: Doc,
+	  // Iterate over the document. Supports two forms -- with only one
+	  // argument, it calls that for each line in the document. With
+	  // three, it iterates over the range given by the first two (with
+	  // the second being non-inclusive).
+	  iter: function(from, to, op) {
+	    if (op) { this.iterN(from - this.first, to - from, op) }
+	    else { this.iterN(this.first, this.first + this.size, from) }
+	  },
+
+	  // Non-public interface for adding and removing lines.
+	  insert: function(at, lines) {
+	    var height = 0
+	    for (var i = 0; i < lines.length; ++i) { height += lines[i].height }
+	    this.insertInner(at - this.first, lines, height)
+	  },
+	  remove: function(at, n) { this.removeInner(at - this.first, n) },
+
+	  // From here, the methods are part of the public interface. Most
+	  // are also available from CodeMirror (editor) instances.
+
+	  getValue: function(lineSep) {
+	    var lines = getLines(this, this.first, this.first + this.size)
+	    if (lineSep === false) { return lines }
+	    return lines.join(lineSep || this.lineSeparator())
+	  },
+	  setValue: docMethodOp(function(code) {
+	    var top = Pos(this.first, 0), last = this.first + this.size - 1
+	    makeChange(this, {from: top, to: Pos(last, getLine(this, last).text.length),
+	                      text: this.splitLines(code), origin: "setValue", full: true}, true)
+	    setSelection(this, simpleSelection(top))
+	  }),
+	  replaceRange: function(code, from, to, origin) {
+	    from = clipPos(this, from)
+	    to = to ? clipPos(this, to) : from
+	    replaceRange(this, code, from, to, origin)
+	  },
+	  getRange: function(from, to, lineSep) {
+	    var lines = getBetween(this, clipPos(this, from), clipPos(this, to))
+	    if (lineSep === false) { return lines }
+	    return lines.join(lineSep || this.lineSeparator())
+	  },
+
+	  getLine: function(line) {var l = this.getLineHandle(line); return l && l.text},
+
+	  getLineHandle: function(line) {if (isLine(this, line)) { return getLine(this, line) }},
+	  getLineNumber: function(line) {return lineNo(line)},
+
+	  getLineHandleVisualStart: function(line) {
+	    if (typeof line == "number") { line = getLine(this, line) }
+	    return visualLine(line)
+	  },
+
+	  lineCount: function() {return this.size},
+	  firstLine: function() {return this.first},
+	  lastLine: function() {return this.first + this.size - 1},
+
+	  clipPos: function(pos) {return clipPos(this, pos)},
+
+	  getCursor: function(start) {
+	    var range = this.sel.primary(), pos
+	    if (start == null || start == "head") { pos = range.head }
+	    else if (start == "anchor") { pos = range.anchor }
+	    else if (start == "end" || start == "to" || start === false) { pos = range.to() }
+	    else { pos = range.from() }
+	    return pos
+	  },
+	  listSelections: function() { return this.sel.ranges },
+	  somethingSelected: function() {return this.sel.somethingSelected()},
+
+	  setCursor: docMethodOp(function(line, ch, options) {
+	    setSimpleSelection(this, clipPos(this, typeof line == "number" ? Pos(line, ch || 0) : line), null, options)
+	  }),
+	  setSelection: docMethodOp(function(anchor, head, options) {
+	    setSimpleSelection(this, clipPos(this, anchor), clipPos(this, head || anchor), options)
+	  }),
+	  extendSelection: docMethodOp(function(head, other, options) {
+	    extendSelection(this, clipPos(this, head), other && clipPos(this, other), options)
+	  }),
+	  extendSelections: docMethodOp(function(heads, options) {
+	    extendSelections(this, clipPosArray(this, heads), options)
+	  }),
+	  extendSelectionsBy: docMethodOp(function(f, options) {
+	    var heads = map(this.sel.ranges, f)
+	    extendSelections(this, clipPosArray(this, heads), options)
+	  }),
+	  setSelections: docMethodOp(function(ranges, primary, options) {
+	    var this$1 = this;
+
+	    if (!ranges.length) { return }
+	    var out = []
+	    for (var i = 0; i < ranges.length; i++)
+	      { out[i] = new Range(clipPos(this$1, ranges[i].anchor),
+	                         clipPos(this$1, ranges[i].head)) }
+	    if (primary == null) { primary = Math.min(ranges.length - 1, this.sel.primIndex) }
+	    setSelection(this, normalizeSelection(out, primary), options)
+	  }),
+	  addSelection: docMethodOp(function(anchor, head, options) {
+	    var ranges = this.sel.ranges.slice(0)
+	    ranges.push(new Range(clipPos(this, anchor), clipPos(this, head || anchor)))
+	    setSelection(this, normalizeSelection(ranges, ranges.length - 1), options)
+	  }),
+
+	  getSelection: function(lineSep) {
+	    var this$1 = this;
+
+	    var ranges = this.sel.ranges, lines
+	    for (var i = 0; i < ranges.length; i++) {
+	      var sel = getBetween(this$1, ranges[i].from(), ranges[i].to())
+	      lines = lines ? lines.concat(sel) : sel
+	    }
+	    if (lineSep === false) { return lines }
+	    else { return lines.join(lineSep || this.lineSeparator()) }
+	  },
+	  getSelections: function(lineSep) {
+	    var this$1 = this;
+
+	    var parts = [], ranges = this.sel.ranges
+	    for (var i = 0; i < ranges.length; i++) {
+	      var sel = getBetween(this$1, ranges[i].from(), ranges[i].to())
+	      if (lineSep !== false) { sel = sel.join(lineSep || this$1.lineSeparator()) }
+	      parts[i] = sel
+	    }
+	    return parts
+	  },
+	  replaceSelection: function(code, collapse, origin) {
+	    var dup = []
+	    for (var i = 0; i < this.sel.ranges.length; i++)
+	      { dup[i] = code }
+	    this.replaceSelections(dup, collapse, origin || "+input")
+	  },
+	  replaceSelections: docMethodOp(function(code, collapse, origin) {
+	    var this$1 = this;
+
+	    var changes = [], sel = this.sel
+	    for (var i = 0; i < sel.ranges.length; i++) {
+	      var range = sel.ranges[i]
+	      changes[i] = {from: range.from(), to: range.to(), text: this$1.splitLines(code[i]), origin: origin}
+	    }
+	    var newSel = collapse && collapse != "end" && computeReplacedSel(this, changes, collapse)
+	    for (var i$1 = changes.length - 1; i$1 >= 0; i$1--)
+	      { makeChange(this$1, changes[i$1]) }
+	    if (newSel) { setSelectionReplaceHistory(this, newSel) }
+	    else if (this.cm) { ensureCursorVisible(this.cm) }
+	  }),
+	  undo: docMethodOp(function() {makeChangeFromHistory(this, "undo")}),
+	  redo: docMethodOp(function() {makeChangeFromHistory(this, "redo")}),
+	  undoSelection: docMethodOp(function() {makeChangeFromHistory(this, "undo", true)}),
+	  redoSelection: docMethodOp(function() {makeChangeFromHistory(this, "redo", true)}),
+
+	  setExtending: function(val) {this.extend = val},
+	  getExtending: function() {return this.extend},
+
+	  historySize: function() {
+	    var hist = this.history, done = 0, undone = 0
+	    for (var i = 0; i < hist.done.length; i++) { if (!hist.done[i].ranges) { ++done } }
+	    for (var i$1 = 0; i$1 < hist.undone.length; i$1++) { if (!hist.undone[i$1].ranges) { ++undone } }
+	    return {undo: done, redo: undone}
+	  },
+	  clearHistory: function() {this.history = new History(this.history.maxGeneration)},
+
+	  markClean: function() {
+	    this.cleanGeneration = this.changeGeneration(true)
+	  },
+	  changeGeneration: function(forceSplit) {
+	    if (forceSplit)
+	      { this.history.lastOp = this.history.lastSelOp = this.history.lastOrigin = null }
+	    return this.history.generation
+	  },
+	  isClean: function (gen) {
+	    return this.history.generation == (gen || this.cleanGeneration)
+	  },
+
+	  getHistory: function() {
+	    return {done: copyHistoryArray(this.history.done),
+	            undone: copyHistoryArray(this.history.undone)}
+	  },
+	  setHistory: function(histData) {
+	    var hist = this.history = new History(this.history.maxGeneration)
+	    hist.done = copyHistoryArray(histData.done.slice(0), null, true)
+	    hist.undone = copyHistoryArray(histData.undone.slice(0), null, true)
+	  },
+
+	  setGutterMarker: docMethodOp(function(line, gutterID, value) {
+	    return changeLine(this, line, "gutter", function (line) {
+	      var markers = line.gutterMarkers || (line.gutterMarkers = {})
+	      markers[gutterID] = value
+	      if (!value && isEmpty(markers)) { line.gutterMarkers = null }
+	      return true
+	    })
+	  }),
+
+	  clearGutter: docMethodOp(function(gutterID) {
+	    var this$1 = this;
+
+	    var i = this.first
+	    this.iter(function (line) {
+	      if (line.gutterMarkers && line.gutterMarkers[gutterID]) {
+	        changeLine(this$1, line, "gutter", function () {
+	          line.gutterMarkers[gutterID] = null
+	          if (isEmpty(line.gutterMarkers)) { line.gutterMarkers = null }
+	          return true
+	        })
+	      }
+	      ++i
+	    })
+	  }),
+
+	  lineInfo: function(line) {
+	    var n
+	    if (typeof line == "number") {
+	      if (!isLine(this, line)) { return null }
+	      n = line
+	      line = getLine(this, line)
+	      if (!line) { return null }
+	    } else {
+	      n = lineNo(line)
+	      if (n == null) { return null }
+	    }
+	    return {line: n, handle: line, text: line.text, gutterMarkers: line.gutterMarkers,
+	            textClass: line.textClass, bgClass: line.bgClass, wrapClass: line.wrapClass,
+	            widgets: line.widgets}
+	  },
+
+	  addLineClass: docMethodOp(function(handle, where, cls) {
+	    return changeLine(this, handle, where == "gutter" ? "gutter" : "class", function (line) {
+	      var prop = where == "text" ? "textClass"
+	               : where == "background" ? "bgClass"
+	               : where == "gutter" ? "gutterClass" : "wrapClass"
+	      if (!line[prop]) { line[prop] = cls }
+	      else if (classTest(cls).test(line[prop])) { return false }
+	      else { line[prop] += " " + cls }
+	      return true
+	    })
+	  }),
+	  removeLineClass: docMethodOp(function(handle, where, cls) {
+	    return changeLine(this, handle, where == "gutter" ? "gutter" : "class", function (line) {
+	      var prop = where == "text" ? "textClass"
+	               : where == "background" ? "bgClass"
+	               : where == "gutter" ? "gutterClass" : "wrapClass"
+	      var cur = line[prop]
+	      if (!cur) { return false }
+	      else if (cls == null) { line[prop] = null }
+	      else {
+	        var found = cur.match(classTest(cls))
+	        if (!found) { return false }
+	        var end = found.index + found[0].length
+	        line[prop] = cur.slice(0, found.index) + (!found.index || end == cur.length ? "" : " ") + cur.slice(end) || null
+	      }
+	      return true
+	    })
+	  }),
+
+	  addLineWidget: docMethodOp(function(handle, node, options) {
+	    return addLineWidget(this, handle, node, options)
+	  }),
+	  removeLineWidget: function(widget) { widget.clear() },
+
+	  markText: function(from, to, options) {
+	    return markText(this, clipPos(this, from), clipPos(this, to), options, options && options.type || "range")
+	  },
+	  setBookmark: function(pos, options) {
+	    var realOpts = {replacedWith: options && (options.nodeType == null ? options.widget : options),
+	                    insertLeft: options && options.insertLeft,
+	                    clearWhenEmpty: false, shared: options && options.shared,
+	                    handleMouseEvents: options && options.handleMouseEvents}
+	    pos = clipPos(this, pos)
+	    return markText(this, pos, pos, realOpts, "bookmark")
+	  },
+	  findMarksAt: function(pos) {
+	    pos = clipPos(this, pos)
+	    var markers = [], spans = getLine(this, pos.line).markedSpans
+	    if (spans) { for (var i = 0; i < spans.length; ++i) {
+	      var span = spans[i]
+	      if ((span.from == null || span.from <= pos.ch) &&
+	          (span.to == null || span.to >= pos.ch))
+	        { markers.push(span.marker.parent || span.marker) }
+	    } }
+	    return markers
+	  },
+	  findMarks: function(from, to, filter) {
+	    from = clipPos(this, from); to = clipPos(this, to)
+	    var found = [], lineNo = from.line
+	    this.iter(from.line, to.line + 1, function (line) {
+	      var spans = line.markedSpans
+	      if (spans) { for (var i = 0; i < spans.length; i++) {
+	        var span = spans[i]
+	        if (!(span.to != null && lineNo == from.line && from.ch >= span.to ||
+	              span.from == null && lineNo != from.line ||
+	              span.from != null && lineNo == to.line && span.from >= to.ch) &&
+	            (!filter || filter(span.marker)))
+	          { found.push(span.marker.parent || span.marker) }
+	      } }
+	      ++lineNo
+	    })
+	    return found
+	  },
+	  getAllMarks: function() {
+	    var markers = []
+	    this.iter(function (line) {
+	      var sps = line.markedSpans
+	      if (sps) { for (var i = 0; i < sps.length; ++i)
+	        { if (sps[i].from != null) { markers.push(sps[i].marker) } } }
+	    })
+	    return markers
+	  },
+
+	  posFromIndex: function(off) {
+	    var ch, lineNo = this.first, sepSize = this.lineSeparator().length
+	    this.iter(function (line) {
+	      var sz = line.text.length + sepSize
+	      if (sz > off) { ch = off; return true }
+	      off -= sz
+	      ++lineNo
+	    })
+	    return clipPos(this, Pos(lineNo, ch))
+	  },
+	  indexFromPos: function (coords) {
+	    coords = clipPos(this, coords)
+	    var index = coords.ch
+	    if (coords.line < this.first || coords.ch < 0) { return 0 }
+	    var sepSize = this.lineSeparator().length
+	    this.iter(this.first, coords.line, function (line) { // iter aborts when callback returns a truthy value
+	      index += line.text.length + sepSize
+	    })
+	    return index
+	  },
+
+	  copy: function(copyHistory) {
+	    var doc = new Doc(getLines(this, this.first, this.first + this.size),
+	                      this.modeOption, this.first, this.lineSep)
+	    doc.scrollTop = this.scrollTop; doc.scrollLeft = this.scrollLeft
+	    doc.sel = this.sel
+	    doc.extend = false
+	    if (copyHistory) {
+	      doc.history.undoDepth = this.history.undoDepth
+	      doc.setHistory(this.getHistory())
+	    }
+	    return doc
+	  },
+
+	  linkedDoc: function(options) {
+	    if (!options) { options = {} }
+	    var from = this.first, to = this.first + this.size
+	    if (options.from != null && options.from > from) { from = options.from }
+	    if (options.to != null && options.to < to) { to = options.to }
+	    var copy = new Doc(getLines(this, from, to), options.mode || this.modeOption, from, this.lineSep)
+	    if (options.sharedHist) { copy.history = this.history
+	    ; }(this.linked || (this.linked = [])).push({doc: copy, sharedHist: options.sharedHist})
+	    copy.linked = [{doc: this, isParent: true, sharedHist: options.sharedHist}]
+	    copySharedMarkers(copy, findSharedMarkers(this))
+	    return copy
+	  },
+	  unlinkDoc: function(other) {
+	    var this$1 = this;
+
+	    if (other instanceof CodeMirror) { other = other.doc }
+	    if (this.linked) { for (var i = 0; i < this.linked.length; ++i) {
+	      var link = this$1.linked[i]
+	      if (link.doc != other) { continue }
+	      this$1.linked.splice(i, 1)
+	      other.unlinkDoc(this$1)
+	      detachSharedMarkers(findSharedMarkers(this$1))
+	      break
+	    } }
+	    // If the histories were shared, split them again
+	    if (other.history == this.history) {
+	      var splitIds = [other.id]
+	      linkedDocs(other, function (doc) { return splitIds.push(doc.id); }, true)
+	      other.history = new History(null)
+	      other.history.done = copyHistoryArray(this.history.done, splitIds)
+	      other.history.undone = copyHistoryArray(this.history.undone, splitIds)
+	    }
+	  },
+	  iterLinkedDocs: function(f) {linkedDocs(this, f)},
+
+	  getMode: function() {return this.mode},
+	  getEditor: function() {return this.cm},
+
+	  splitLines: function(str) {
+	    if (this.lineSep) { return str.split(this.lineSep) }
+	    return splitLinesAuto(str)
+	  },
+	  lineSeparator: function() { return this.lineSep || "\n" }
+	})
+
+	// Public alias.
+	Doc.prototype.eachLine = Doc.prototype.iter
+
+	// Kludge to work around strange IE behavior where it'll sometimes
+	// re-fire a series of drag-related events right after the drop (#1551)
+	var lastDrop = 0
+
+	function onDrop(e) {
+	  var cm = this
+	  clearDragCursor(cm)
+	  if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e))
+	    { return }
+	  e_preventDefault(e)
+	  if (ie) { lastDrop = +new Date }
+	  var pos = posFromMouse(cm, e, true), files = e.dataTransfer.files
+	  if (!pos || cm.isReadOnly()) { return }
+	  // Might be a file drop, in which case we simply extract the text
+	  // and insert it.
+	  if (files && files.length && window.FileReader && window.File) {
+	    var n = files.length, text = Array(n), read = 0
+	    var loadFile = function (file, i) {
+	      if (cm.options.allowDropFileTypes &&
+	          indexOf(cm.options.allowDropFileTypes, file.type) == -1)
+	        { return }
+
+	      var reader = new FileReader
+	      reader.onload = operation(cm, function () {
+	        var content = reader.result
+	        if (/[\x00-\x08\x0e-\x1f]{2}/.test(content)) { content = "" }
+	        text[i] = content
+	        if (++read == n) {
+	          pos = clipPos(cm.doc, pos)
+	          var change = {from: pos, to: pos,
+	                        text: cm.doc.splitLines(text.join(cm.doc.lineSeparator())),
+	                        origin: "paste"}
+	          makeChange(cm.doc, change)
+	          setSelectionReplaceHistory(cm.doc, simpleSelection(pos, changeEnd(change)))
+	        }
+	      })
+	      reader.readAsText(file)
+	    }
+	    for (var i = 0; i < n; ++i) { loadFile(files[i], i) }
+	  } else { // Normal drop
+	    // Don't do a replace if the drop happened inside of the selected text.
+	    if (cm.state.draggingText && cm.doc.sel.contains(pos) > -1) {
+	      cm.state.draggingText(e)
+	      // Ensure the editor is re-focused
+	      setTimeout(function () { return cm.display.input.focus(); }, 20)
+	      return
+	    }
+	    try {
+	      var text$1 = e.dataTransfer.getData("Text")
+	      if (text$1) {
+	        var selected
+	        if (cm.state.draggingText && !cm.state.draggingText.copy)
+	          { selected = cm.listSelections() }
+	        setSelectionNoUndo(cm.doc, simpleSelection(pos, pos))
+	        if (selected) { for (var i$1 = 0; i$1 < selected.length; ++i$1)
+	          { replaceRange(cm.doc, "", selected[i$1].anchor, selected[i$1].head, "drag") } }
+	        cm.replaceSelection(text$1, "around", "paste")
+	        cm.display.input.focus()
+	      }
+	    }
+	    catch(e){}
+	  }
+	}
+
+	function onDragStart(cm, e) {
+	  if (ie && (!cm.state.draggingText || +new Date - lastDrop < 100)) { e_stop(e); return }
+	  if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) { return }
+
+	  e.dataTransfer.setData("Text", cm.getSelection())
+	  e.dataTransfer.effectAllowed = "copyMove"
+
+	  // Use dummy image instead of default browsers image.
+	  // Recent Safari (~6.0.2) have a tendency to segfault when this happens, so we don't do it there.
+	  if (e.dataTransfer.setDragImage && !safari) {
+	    var img = elt("img", null, null, "position: fixed; left: 0; top: 0;")
+	    img.src = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=="
+	    if (presto) {
+	      img.width = img.height = 1
+	      cm.display.wrapper.appendChild(img)
+	      // Force a relayout, or Opera won't use our image for some obscure reason
+	      img._top = img.offsetTop
+	    }
+	    e.dataTransfer.setDragImage(img, 0, 0)
+	    if (presto) { img.parentNode.removeChild(img) }
+	  }
+	}
+
+	function onDragOver(cm, e) {
+	  var pos = posFromMouse(cm, e)
+	  if (!pos) { return }
+	  var frag = document.createDocumentFragment()
+	  drawSelectionCursor(cm, pos, frag)
+	  if (!cm.display.dragCursor) {
+	    cm.display.dragCursor = elt("div", null, "CodeMirror-cursors CodeMirror-dragcursors")
+	    cm.display.lineSpace.insertBefore(cm.display.dragCursor, cm.display.cursorDiv)
+	  }
+	  removeChildrenAndAdd(cm.display.dragCursor, frag)
+	}
+
+	function clearDragCursor(cm) {
+	  if (cm.display.dragCursor) {
+	    cm.display.lineSpace.removeChild(cm.display.dragCursor)
+	    cm.display.dragCursor = null
+	  }
+	}
+
+	// These must be handled carefully, because naively registering a
+	// handler for each editor will cause the editors to never be
+	// garbage collected.
+
+	function forEachCodeMirror(f) {
+	  if (!document.body.getElementsByClassName) { return }
+	  var byClass = document.body.getElementsByClassName("CodeMirror")
+	  for (var i = 0; i < byClass.length; i++) {
+	    var cm = byClass[i].CodeMirror
+	    if (cm) { f(cm) }
+	  }
+	}
+
+	var globalsRegistered = false
+	function ensureGlobalHandlers() {
+	  if (globalsRegistered) { return }
+	  registerGlobalHandlers()
+	  globalsRegistered = true
+	}
+	function registerGlobalHandlers() {
+	  // When the window resizes, we need to refresh active editors.
+	  var resizeTimer
+	  on(window, "resize", function () {
+	    if (resizeTimer == null) { resizeTimer = setTimeout(function () {
+	      resizeTimer = null
+	      forEachCodeMirror(onResize)
+	    }, 100) }
+	  })
+	  // When the window loses focus, we want to show the editor as blurred
+	  on(window, "blur", function () { return forEachCodeMirror(onBlur); })
+	}
+	// Called when the window resizes
+	function onResize(cm) {
+	  var d = cm.display
+	  if (d.lastWrapHeight == d.wrapper.clientHeight && d.lastWrapWidth == d.wrapper.clientWidth)
+	    { return }
+	  // Might be a text scaling operation, clear size caches.
+	  d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null
+	  d.scrollbarsClipped = false
+	  cm.setSize()
+	}
+
+	var keyNames = {
+	  3: "Enter", 8: "Backspace", 9: "Tab", 13: "Enter", 16: "Shift", 17: "Ctrl", 18: "Alt",
+	  19: "Pause", 20: "CapsLock", 27: "Esc", 32: "Space", 33: "PageUp", 34: "PageDown", 35: "End",
+	  36: "Home", 37: "Left", 38: "Up", 39: "Right", 40: "Down", 44: "PrintScrn", 45: "Insert",
+	  46: "Delete", 59: ";", 61: "=", 91: "Mod", 92: "Mod", 93: "Mod",
+	  106: "*", 107: "=", 109: "-", 110: ".", 111: "/", 127: "Delete",
+	  173: "-", 186: ";", 187: "=", 188: ",", 189: "-", 190: ".", 191: "/", 192: "`", 219: "[", 220: "\\",
+	  221: "]", 222: "'", 63232: "Up", 63233: "Down", 63234: "Left", 63235: "Right", 63272: "Delete",
+	  63273: "Home", 63275: "End", 63276: "PageUp", 63277: "PageDown", 63302: "Insert"
+	}
+
+	// Number keys
+	for (var i = 0; i < 10; i++) { keyNames[i + 48] = keyNames[i + 96] = String(i) }
+	// Alphabetic keys
+	for (var i$1 = 65; i$1 <= 90; i$1++) { keyNames[i$1] = String.fromCharCode(i$1) }
+	// Function keys
+	for (var i$2 = 1; i$2 <= 12; i$2++) { keyNames[i$2 + 111] = keyNames[i$2 + 63235] = "F" + i$2 }
+
+	var keyMap = {}
+
+	keyMap.basic = {
+	  "Left": "goCharLeft", "Right": "goCharRight", "Up": "goLineUp", "Down": "goLineDown",
+	  "End": "goLineEnd", "Home": "goLineStartSmart", "PageUp": "goPageUp", "PageDown": "goPageDown",
+	  "Delete": "delCharAfter", "Backspace": "delCharBefore", "Shift-Backspace": "delCharBefore",
+	  "Tab": "defaultTab", "Shift-Tab": "indentAuto",
+	  "Enter": "newlineAndIndent", "Insert": "toggleOverwrite",
+	  "Esc": "singleSelection"
+	}
+	// Note that the save and find-related commands aren't defined by
+	// default. User code or addons can define them. Unknown commands
+	// are simply ignored.
+	keyMap.pcDefault = {
+	  "Ctrl-A": "selectAll", "Ctrl-D": "deleteLine", "Ctrl-Z": "undo", "Shift-Ctrl-Z": "redo", "Ctrl-Y": "redo",
+	  "Ctrl-Home": "goDocStart", "Ctrl-End": "goDocEnd", "Ctrl-Up": "goLineUp", "Ctrl-Down": "goLineDown",
+	  "Ctrl-Left": "goGroupLeft", "Ctrl-Right": "goGroupRight", "Alt-Left": "goLineStart", "Alt-Right": "goLineEnd",
+	  "Ctrl-Backspace": "delGroupBefore", "Ctrl-Delete": "delGroupAfter", "Ctrl-S": "save", "Ctrl-F": "find",
+	  "Ctrl-G": "findNext", "Shift-Ctrl-G": "findPrev", "Shift-Ctrl-F": "replace", "Shift-Ctrl-R": "replaceAll",
+	  "Ctrl-[": "indentLess", "Ctrl-]": "indentMore",
+	  "Ctrl-U": "undoSelection", "Shift-Ctrl-U": "redoSelection", "Alt-U": "redoSelection",
+	  fallthrough: "basic"
+	}
+	// Very basic readline/emacs-style bindings, which are standard on Mac.
+	keyMap.emacsy = {
+	  "Ctrl-F": "goCharRight", "Ctrl-B": "goCharLeft", "Ctrl-P": "goLineUp", "Ctrl-N": "goLineDown",
+	  "Alt-F": "goWordRight", "Alt-B": "goWordLeft", "Ctrl-A": "goLineStart", "Ctrl-E": "goLineEnd",
+	  "Ctrl-V": "goPageDown", "Shift-Ctrl-V": "goPageUp", "Ctrl-D": "delCharAfter", "Ctrl-H": "delCharBefore",
+	  "Alt-D": "delWordAfter", "Alt-Backspace": "delWordBefore", "Ctrl-K": "killLine", "Ctrl-T": "transposeChars",
+	  "Ctrl-O": "openLine"
+	}
+	keyMap.macDefault = {
+	  "Cmd-A": "selectAll", "Cmd-D": "deleteLine", "Cmd-Z": "undo", "Shift-Cmd-Z": "redo", "Cmd-Y": "redo",
+	  "Cmd-Home": "goDocStart", "Cmd-Up": "goDocStart", "Cmd-End": "goDocEnd", "Cmd-Down": "goDocEnd", "Alt-Left": "goGroupLeft",
+	  "Alt-Right": "goGroupRight", "Cmd-Left": "goLineLeft", "Cmd-Right": "goLineRight", "Alt-Backspace": "delGroupBefore",
+	  "Ctrl-Alt-Backspace": "delGroupAfter", "Alt-Delete": "delGroupAfter", "Cmd-S": "save", "Cmd-F": "find",
+	  "Cmd-G": "findNext", "Shift-Cmd-G": "findPrev", "Cmd-Alt-F": "replace", "Shift-Cmd-Alt-F": "replaceAll",
+	  "Cmd-[": "indentLess", "Cmd-]": "indentMore", "Cmd-Backspace": "delWrappedLineLeft", "Cmd-Delete": "delWrappedLineRight",
+	  "Cmd-U": "undoSelection", "Shift-Cmd-U": "redoSelection", "Ctrl-Up": "goDocStart", "Ctrl-Down": "goDocEnd",
+	  fallthrough: ["basic", "emacsy"]
+	}
+	keyMap["default"] = mac ? keyMap.macDefault : keyMap.pcDefault
+
+	// KEYMAP DISPATCH
+
+	function normalizeKeyName(name) {
+	  var parts = name.split(/-(?!$)/)
+	  name = parts[parts.length - 1]
+	  var alt, ctrl, shift, cmd
+	  for (var i = 0; i < parts.length - 1; i++) {
+	    var mod = parts[i]
+	    if (/^(cmd|meta|m)$/i.test(mod)) { cmd = true }
+	    else if (/^a(lt)?$/i.test(mod)) { alt = true }
+	    else if (/^(c|ctrl|control)$/i.test(mod)) { ctrl = true }
+	    else if (/^s(hift)?$/i.test(mod)) { shift = true }
+	    else { throw new Error("Unrecognized modifier name: " + mod) }
+	  }
+	  if (alt) { name = "Alt-" + name }
+	  if (ctrl) { name = "Ctrl-" + name }
+	  if (cmd) { name = "Cmd-" + name }
+	  if (shift) { name = "Shift-" + name }
+	  return name
+	}
+
+	// This is a kludge to keep keymaps mostly working as raw objects
+	// (backwards compatibility) while at the same time support features
+	// like normalization and multi-stroke key bindings. It compiles a
+	// new normalized keymap, and then updates the old object to reflect
+	// this.
+	function normalizeKeyMap(keymap) {
+	  var copy = {}
+	  for (var keyname in keymap) { if (keymap.hasOwnProperty(keyname)) {
+	    var value = keymap[keyname]
+	    if (/^(name|fallthrough|(de|at)tach)$/.test(keyname)) { continue }
+	    if (value == "...") { delete keymap[keyname]; continue }
+
+	    var keys = map(keyname.split(" "), normalizeKeyName)
+	    for (var i = 0; i < keys.length; i++) {
+	      var val = (void 0), name = (void 0)
+	      if (i == keys.length - 1) {
+	        name = keys.join(" ")
+	        val = value
+	      } else {
+	        name = keys.slice(0, i + 1).join(" ")
+	        val = "..."
+	      }
+	      var prev = copy[name]
+	      if (!prev) { copy[name] = val }
+	      else if (prev != val) { throw new Error("Inconsistent bindings for " + name) }
+	    }
+	    delete keymap[keyname]
+	  } }
+	  for (var prop in copy) { keymap[prop] = copy[prop] }
+	  return keymap
+	}
+
+	function lookupKey(key, map, handle, context) {
+	  map = getKeyMap(map)
+	  var found = map.call ? map.call(key, context) : map[key]
+	  if (found === false) { return "nothing" }
+	  if (found === "...") { return "multi" }
+	  if (found != null && handle(found)) { return "handled" }
+
+	  if (map.fallthrough) {
+	    if (Object.prototype.toString.call(map.fallthrough) != "[object Array]")
+	      { return lookupKey(key, map.fallthrough, handle, context) }
+	    for (var i = 0; i < map.fallthrough.length; i++) {
+	      var result = lookupKey(key, map.fallthrough[i], handle, context)
+	      if (result) { return result }
+	    }
+	  }
+	}
+
+	// Modifier key presses don't count as 'real' key presses for the
+	// purpose of keymap fallthrough.
+	function isModifierKey(value) {
+	  var name = typeof value == "string" ? value : keyNames[value.keyCode]
+	  return name == "Ctrl" || name == "Alt" || name == "Shift" || name == "Mod"
+	}
+
+	// Look up the name of a key as indicated by an event object.
+	function keyName(event, noShift) {
+	  if (presto && event.keyCode == 34 && event["char"]) { return false }
+	  var base = keyNames[event.keyCode], name = base
+	  if (name == null || event.altGraphKey) { return false }
+	  if (event.altKey && base != "Alt") { name = "Alt-" + name }
+	  if ((flipCtrlCmd ? event.metaKey : event.ctrlKey) && base != "Ctrl") { name = "Ctrl-" + name }
+	  if ((flipCtrlCmd ? event.ctrlKey : event.metaKey) && base != "Cmd") { name = "Cmd-" + name }
+	  if (!noShift && event.shiftKey && base != "Shift") { name = "Shift-" + name }
+	  return name
+	}
+
+	function getKeyMap(val) {
+	  return typeof val == "string" ? keyMap[val] : val
+	}
+
+	// Helper for deleting text near the selection(s), used to implement
+	// backspace, delete, and similar functionality.
+	function deleteNearSelection(cm, compute) {
+	  var ranges = cm.doc.sel.ranges, kill = []
+	  // Build up a set of ranges to kill first, merging overlapping
+	  // ranges.
+	  for (var i = 0; i < ranges.length; i++) {
+	    var toKill = compute(ranges[i])
+	    while (kill.length && cmp(toKill.from, lst(kill).to) <= 0) {
+	      var replaced = kill.pop()
+	      if (cmp(replaced.from, toKill.from) < 0) {
+	        toKill.from = replaced.from
+	        break
+	      }
+	    }
+	    kill.push(toKill)
+	  }
+	  // Next, remove those actual ranges.
+	  runInOp(cm, function () {
+	    for (var i = kill.length - 1; i >= 0; i--)
+	      { replaceRange(cm.doc, "", kill[i].from, kill[i].to, "+delete") }
+	    ensureCursorVisible(cm)
+	  })
+	}
+
+	// Commands are parameter-less actions that can be performed on an
+	// editor, mostly used for keybindings.
+	var commands = {
+	  selectAll: selectAll,
+	  singleSelection: function (cm) { return cm.setSelection(cm.getCursor("anchor"), cm.getCursor("head"), sel_dontScroll); },
+	  killLine: function (cm) { return deleteNearSelection(cm, function (range) {
+	    if (range.empty()) {
+	      var len = getLine(cm.doc, range.head.line).text.length
+	      if (range.head.ch == len && range.head.line < cm.lastLine())
+	        { return {from: range.head, to: Pos(range.head.line + 1, 0)} }
+	      else
+	        { return {from: range.head, to: Pos(range.head.line, len)} }
+	    } else {
+	      return {from: range.from(), to: range.to()}
+	    }
+	  }); },
+	  deleteLine: function (cm) { return deleteNearSelection(cm, function (range) { return ({
+	    from: Pos(range.from().line, 0),
+	    to: clipPos(cm.doc, Pos(range.to().line + 1, 0))
+	  }); }); },
+	  delLineLeft: function (cm) { return deleteNearSelection(cm, function (range) { return ({
+	    from: Pos(range.from().line, 0), to: range.from()
+	  }); }); },
+	  delWrappedLineLeft: function (cm) { return deleteNearSelection(cm, function (range) {
+	    var top = cm.charCoords(range.head, "div").top + 5
+	    var leftPos = cm.coordsChar({left: 0, top: top}, "div")
+	    return {from: leftPos, to: range.from()}
+	  }); },
+	  delWrappedLineRight: function (cm) { return deleteNearSelection(cm, function (range) {
+	    var top = cm.charCoords(range.head, "div").top + 5
+	    var rightPos = cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div")
+	    return {from: range.from(), to: rightPos }
+	  }); },
+	  undo: function (cm) { return cm.undo(); },
+	  redo: function (cm) { return cm.redo(); },
+	  undoSelection: function (cm) { return cm.undoSelection(); },
+	  redoSelection: function (cm) { return cm.redoSelection(); },
+	  goDocStart: function (cm) { return cm.extendSelection(Pos(cm.firstLine(), 0)); },
+	  goDocEnd: function (cm) { return cm.extendSelection(Pos(cm.lastLine())); },
+	  goLineStart: function (cm) { return cm.extendSelectionsBy(function (range) { return lineStart(cm, range.head.line); },
+	    {origin: "+move", bias: 1}
+	  ); },
+	  goLineStartSmart: function (cm) { return cm.extendSelectionsBy(function (range) { return lineStartSmart(cm, range.head); },
+	    {origin: "+move", bias: 1}
+	  ); },
+	  goLineEnd: function (cm) { return cm.extendSelectionsBy(function (range) { return lineEnd(cm, range.head.line); },
+	    {origin: "+move", bias: -1}
+	  ); },
+	  goLineRight: function (cm) { return cm.extendSelectionsBy(function (range) {
+	    var top = cm.charCoords(range.head, "div").top + 5
+	    return cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div")
+	  }, sel_move); },
+	  goLineLeft: function (cm) { return cm.extendSelectionsBy(function (range) {
+	    var top = cm.charCoords(range.head, "div").top + 5
+	    return cm.coordsChar({left: 0, top: top}, "div")
+	  }, sel_move); },
+	  goLineLeftSmart: function (cm) { return cm.extendSelectionsBy(function (range) {
+	    var top = cm.charCoords(range.head, "div").top + 5
+	    var pos = cm.coordsChar({left: 0, top: top}, "div")
+	    if (pos.ch < cm.getLine(pos.line).search(/\S/)) { return lineStartSmart(cm, range.head) }
+	    return pos
+	  }, sel_move); },
+	  goLineUp: function (cm) { return cm.moveV(-1, "line"); },
+	  goLineDown: function (cm) { return cm.moveV(1, "line"); },
+	  goPageUp: function (cm) { return cm.moveV(-1, "page"); },
+	  goPageDown: function (cm) { return cm.moveV(1, "page"); },
+	  goCharLeft: function (cm) { return cm.moveH(-1, "char"); },
+	  goCharRight: function (cm) { return cm.moveH(1, "char"); },
+	  goColumnLeft: function (cm) { return cm.moveH(-1, "column"); },
+	  goColumnRight: function (cm) { return cm.moveH(1, "column"); },
+	  goWordLeft: function (cm) { return cm.moveH(-1, "word"); },
+	  goGroupRight: function (cm) { return cm.moveH(1, "group"); },
+	  goGroupLeft: function (cm) { return cm.moveH(-1, "group"); },
+	  goWordRight: function (cm) { return cm.moveH(1, "word"); },
+	  delCharBefore: function (cm) { return cm.deleteH(-1, "char"); },
+	  delCharAfter: function (cm) { return cm.deleteH(1, "char"); },
+	  delWordBefore: function (cm) { return cm.deleteH(-1, "word"); },
+	  delWordAfter: function (cm) { return cm.deleteH(1, "word"); },
+	  delGroupBefore: function (cm) { return cm.deleteH(-1, "group"); },
+	  delGroupAfter: function (cm) { return cm.deleteH(1, "group"); },
+	  indentAuto: function (cm) { return cm.indentSelection("smart"); },
+	  indentMore: function (cm) { return cm.indentSelection("add"); },
+	  indentLess: function (cm) { return cm.indentSelection("subtract"); },
+	  insertTab: function (cm) { return cm.replaceSelection("\t"); },
+	  insertSoftTab: function (cm) {
+	    var spaces = [], ranges = cm.listSelections(), tabSize = cm.options.tabSize
+	    for (var i = 0; i < ranges.length; i++) {
+	      var pos = ranges[i].from()
+	      var col = countColumn(cm.getLine(pos.line), pos.ch, tabSize)
+	      spaces.push(spaceStr(tabSize - col % tabSize))
+	    }
+	    cm.replaceSelections(spaces)
+	  },
+	  defaultTab: function (cm) {
+	    if (cm.somethingSelected()) { cm.indentSelection("add") }
+	    else { cm.execCommand("insertTab") }
+	  },
+	  // Swap the two chars left and right of each selection's head.
+	  // Move cursor behind the two swapped characters afterwards.
+	  //
+	  // Doesn't consider line feeds a character.
+	  // Doesn't scan more than one line above to find a character.
+	  // Doesn't do anything on an empty line.
+	  // Doesn't do anything with non-empty selections.
+	  transposeChars: function (cm) { return runInOp(cm, function () {
+	    var ranges = cm.listSelections(), newSel = []
+	    for (var i = 0; i < ranges.length; i++) {
+	      if (!ranges[i].empty()) { continue }
+	      var cur = ranges[i].head, line = getLine(cm.doc, cur.line).text
+	      if (line) {
+	        if (cur.ch == line.length) { cur = new Pos(cur.line, cur.ch - 1) }
+	        if (cur.ch > 0) {
+	          cur = new Pos(cur.line, cur.ch + 1)
+	          cm.replaceRange(line.charAt(cur.ch - 1) + line.charAt(cur.ch - 2),
+	                          Pos(cur.line, cur.ch - 2), cur, "+transpose")
+	        } else if (cur.line > cm.doc.first) {
+	          var prev = getLine(cm.doc, cur.line - 1).text
+	          if (prev) {
+	            cur = new Pos(cur.line, 1)
+	            cm.replaceRange(line.charAt(0) + cm.doc.lineSeparator() +
+	                            prev.charAt(prev.length - 1),
+	                            Pos(cur.line - 1, prev.length - 1), cur, "+transpose")
+	          }
+	        }
+	      }
+	      newSel.push(new Range(cur, cur))
+	    }
+	    cm.setSelections(newSel)
+	  }); },
+	  newlineAndIndent: function (cm) { return runInOp(cm, function () {
+	    var sels = cm.listSelections()
+	    for (var i = sels.length - 1; i >= 0; i--)
+	      { cm.replaceRange(cm.doc.lineSeparator(), sels[i].anchor, sels[i].head, "+input") }
+	    sels = cm.listSelections()
+	    for (var i$1 = 0; i$1 < sels.length; i$1++)
+	      { cm.indentLine(sels[i$1].from().line, null, true) }
+	    ensureCursorVisible(cm)
+	  }); },
+	  openLine: function (cm) { return cm.replaceSelection("\n", "start"); },
+	  toggleOverwrite: function (cm) { return cm.toggleOverwrite(); }
+	}
+
+
+	function lineStart(cm, lineN) {
+	  var line = getLine(cm.doc, lineN)
+	  var visual = visualLine(line)
+	  if (visual != line) { lineN = lineNo(visual) }
+	  var order = getOrder(visual)
+	  var ch = !order ? 0 : order[0].level % 2 ? lineRight(visual) : lineLeft(visual)
+	  return Pos(lineN, ch)
+	}
+	function lineEnd(cm, lineN) {
+	  var merged, line = getLine(cm.doc, lineN)
+	  while (merged = collapsedSpanAtEnd(line)) {
+	    line = merged.find(1, true).line
+	    lineN = null
+	  }
+	  var order = getOrder(line)
+	  var ch = !order ? line.text.length : order[0].level % 2 ? lineLeft(line) : lineRight(line)
+	  return Pos(lineN == null ? lineNo(line) : lineN, ch)
+	}
+	function lineStartSmart(cm, pos) {
+	  var start = lineStart(cm, pos.line)
+	  var line = getLine(cm.doc, start.line)
+	  var order = getOrder(line)
+	  if (!order || order[0].level == 0) {
+	    var firstNonWS = Math.max(0, line.text.search(/\S/))
+	    var inWS = pos.line == start.line && pos.ch <= firstNonWS && pos.ch
+	    return Pos(start.line, inWS ? 0 : firstNonWS)
+	  }
+	  return start
+	}
+
+	// Run a handler that was bound to a key.
+	function doHandleBinding(cm, bound, dropShift) {
+	  if (typeof bound == "string") {
+	    bound = commands[bound]
+	    if (!bound) { return false }
+	  }
+	  // Ensure previous input has been read, so that the handler sees a
+	  // consistent view of the document
+	  cm.display.input.ensurePolled()
+	  var prevShift = cm.display.shift, done = false
+	  try {
+	    if (cm.isReadOnly()) { cm.state.suppressEdits = true }
+	    if (dropShift) { cm.display.shift = false }
+	    done = bound(cm) != Pass
+	  } finally {
+	    cm.display.shift = prevShift
+	    cm.state.suppressEdits = false
+	  }
+	  return done
+	}
+
+	function lookupKeyForEditor(cm, name, handle) {
+	  for (var i = 0; i < cm.state.keyMaps.length; i++) {
+	    var result = lookupKey(name, cm.state.keyMaps[i], handle, cm)
+	    if (result) { return result }
+	  }
+	  return (cm.options.extraKeys && lookupKey(name, cm.options.extraKeys, handle, cm))
+	    || lookupKey(name, cm.options.keyMap, handle, cm)
+	}
+
+	var stopSeq = new Delayed
+	function dispatchKey(cm, name, e, handle) {
+	  var seq = cm.state.keySeq
+	  if (seq) {
+	    if (isModifierKey(name)) { return "handled" }
+	    stopSeq.set(50, function () {
+	      if (cm.state.keySeq == seq) {
+	        cm.state.keySeq = null
+	        cm.display.input.reset()
+	      }
+	    })
+	    name = seq + " " + name
+	  }
+	  var result = lookupKeyForEditor(cm, name, handle)
+
+	  if (result == "multi")
+	    { cm.state.keySeq = name }
+	  if (result == "handled")
+	    { signalLater(cm, "keyHandled", cm, name, e) }
+
+	  if (result == "handled" || result == "multi") {
+	    e_preventDefault(e)
+	    restartBlink(cm)
+	  }
+
+	  if (seq && !result && /\'$/.test(name)) {
+	    e_preventDefault(e)
+	    return true
+	  }
+	  return !!result
+	}
+
+	// Handle a key from the keydown event.
+	function handleKeyBinding(cm, e) {
+	  var name = keyName(e, true)
+	  if (!name) { return false }
+
+	  if (e.shiftKey && !cm.state.keySeq) {
+	    // First try to resolve full name (including 'Shift-'). Failing
+	    // that, see if there is a cursor-motion command (starting with
+	    // 'go') bound to the keyname without 'Shift-'.
+	    return dispatchKey(cm, "Shift-" + name, e, function (b) { return doHandleBinding(cm, b, true); })
+	        || dispatchKey(cm, name, e, function (b) {
+	             if (typeof b == "string" ? /^go[A-Z]/.test(b) : b.motion)
+	               { return doHandleBinding(cm, b) }
+	           })
+	  } else {
+	    return dispatchKey(cm, name, e, function (b) { return doHandleBinding(cm, b); })
+	  }
+	}
+
+	// Handle a key from the keypress event
+	function handleCharBinding(cm, e, ch) {
+	  return dispatchKey(cm, "'" + ch + "'", e, function (b) { return doHandleBinding(cm, b, true); })
+	}
+
+	var lastStoppedKey = null
+	function onKeyDown(e) {
+	  var cm = this
+	  cm.curOp.focus = activeElt()
+	  if (signalDOMEvent(cm, e)) { return }
+	  // IE does strange things with escape.
+	  if (ie && ie_version < 11 && e.keyCode == 27) { e.returnValue = false }
+	  var code = e.keyCode
+	  cm.display.shift = code == 16 || e.shiftKey
+	  var handled = handleKeyBinding(cm, e)
+	  if (presto) {
+	    lastStoppedKey = handled ? code : null
+	    // Opera has no cut event... we try to at least catch the key combo
+	    if (!handled && code == 88 && !hasCopyEvent && (mac ? e.metaKey : e.ctrlKey))
+	      { cm.replaceSelection("", null, "cut") }
+	  }
+
+	  // Turn mouse into crosshair when Alt is held on Mac.
+	  if (code == 18 && !/\bCodeMirror-crosshair\b/.test(cm.display.lineDiv.className))
+	    { showCrossHair(cm) }
+	}
+
+	function showCrossHair(cm) {
+	  var lineDiv = cm.display.lineDiv
+	  addClass(lineDiv, "CodeMirror-crosshair")
+
+	  function up(e) {
+	    if (e.keyCode == 18 || !e.altKey) {
+	      rmClass(lineDiv, "CodeMirror-crosshair")
+	      off(document, "keyup", up)
+	      off(document, "mouseover", up)
+	    }
+	  }
+	  on(document, "keyup", up)
+	  on(document, "mouseover", up)
+	}
+
+	function onKeyUp(e) {
+	  if (e.keyCode == 16) { this.doc.sel.shift = false }
+	  signalDOMEvent(this, e)
+	}
+
+	function onKeyPress(e) {
+	  var cm = this
+	  if (eventInWidget(cm.display, e) || signalDOMEvent(cm, e) || e.ctrlKey && !e.altKey || mac && e.metaKey) { return }
+	  var keyCode = e.keyCode, charCode = e.charCode
+	  if (presto && keyCode == lastStoppedKey) {lastStoppedKey = null; e_preventDefault(e); return}
+	  if ((presto && (!e.which || e.which < 10)) && handleKeyBinding(cm, e)) { return }
+	  var ch = String.fromCharCode(charCode == null ? keyCode : charCode)
+	  // Some browsers fire keypress events for backspace
+	  if (ch == "\x08") { return }
+	  if (handleCharBinding(cm, e, ch)) { return }
+	  cm.display.input.onKeyPress(e)
+	}
+
+	// A mouse down can be a single click, double click, triple click,
+	// start of selection drag, start of text drag, new cursor
+	// (ctrl-click), rectangle drag (alt-drag), or xwin
+	// middle-click-paste. Or it might be a click on something we should
+	// not interfere with, such as a scrollbar or widget.
+	function onMouseDown(e) {
+	  var cm = this, display = cm.display
+	  if (signalDOMEvent(cm, e) || display.activeTouch && display.input.supportsTouch()) { return }
+	  display.input.ensurePolled()
+	  display.shift = e.shiftKey
+
+	  if (eventInWidget(display, e)) {
+	    if (!webkit) {
+	      // Briefly turn off draggability, to allow widgets to do
+	      // normal dragging things.
+	      display.scroller.draggable = false
+	      setTimeout(function () { return display.scroller.draggable = true; }, 100)
+	    }
+	    return
+	  }
+	  if (clickInGutter(cm, e)) { return }
+	  var start = posFromMouse(cm, e)
+	  window.focus()
+
+	  switch (e_button(e)) {
+	  case 1:
+	    // #3261: make sure, that we're not starting a second selection
+	    if (cm.state.selectingText)
+	      { cm.state.selectingText(e) }
+	    else if (start)
+	      { leftButtonDown(cm, e, start) }
+	    else if (e_target(e) == display.scroller)
+	      { e_preventDefault(e) }
+	    break
+	  case 2:
+	    if (webkit) { cm.state.lastMiddleDown = +new Date }
+	    if (start) { extendSelection(cm.doc, start) }
+	    setTimeout(function () { return display.input.focus(); }, 20)
+	    e_preventDefault(e)
+	    break
+	  case 3:
+	    if (captureRightClick) { onContextMenu(cm, e) }
+	    else { delayBlurEvent(cm) }
+	    break
+	  }
+	}
+
+	var lastClick;
+	var lastDoubleClick;
+	function leftButtonDown(cm, e, start) {
+	  if (ie) { setTimeout(bind(ensureFocus, cm), 0) }
+	  else { cm.curOp.focus = activeElt() }
+
+	  var now = +new Date, type
+	  if (lastDoubleClick && lastDoubleClick.time > now - 400 && cmp(lastDoubleClick.pos, start) == 0) {
+	    type = "triple"
+	  } else if (lastClick && lastClick.time > now - 400 && cmp(lastClick.pos, start) == 0) {
+	    type = "double"
+	    lastDoubleClick = {time: now, pos: start}
+	  } else {
+	    type = "single"
+	    lastClick = {time: now, pos: start}
+	  }
+
+	  var sel = cm.doc.sel, modifier = mac ? e.metaKey : e.ctrlKey, contained
+	  if (cm.options.dragDrop && dragAndDrop && !cm.isReadOnly() &&
+	      type == "single" && (contained = sel.contains(start)) > -1 &&
+	      (cmp((contained = sel.ranges[contained]).from(), start) < 0 || start.xRel > 0) &&
+	      (cmp(contained.to(), start) > 0 || start.xRel < 0))
+	    { leftButtonStartDrag(cm, e, start, modifier) }
+	  else
+	    { leftButtonSelect(cm, e, start, type, modifier) }
+	}
+
+	// Start a text drag. When it ends, see if any dragging actually
+	// happen, and treat as a click if it didn't.
+	function leftButtonStartDrag(cm, e, start, modifier) {
+	  var display = cm.display, startTime = +new Date
+	  var dragEnd = operation(cm, function (e2) {
+	    if (webkit) { display.scroller.draggable = false }
+	    cm.state.draggingText = false
+	    off(document, "mouseup", dragEnd)
+	    off(display.scroller, "drop", dragEnd)
+	    if (Math.abs(e.clientX - e2.clientX) + Math.abs(e.clientY - e2.clientY) < 10) {
+	      e_preventDefault(e2)
+	      if (!modifier && +new Date - 200 < startTime)
+	        { extendSelection(cm.doc, start) }
+	      // Work around unexplainable focus problem in IE9 (#2127) and Chrome (#3081)
+	      if (webkit || ie && ie_version == 9)
+	        { setTimeout(function () {document.body.focus(); display.input.focus()}, 20) }
+	      else
+	        { display.input.focus() }
+	    }
+	  })
+	  // Let the drag handler handle this.
+	  if (webkit) { display.scroller.draggable = true }
+	  cm.state.draggingText = dragEnd
+	  dragEnd.copy = mac ? e.altKey : e.ctrlKey
+	  // IE's approach to draggable
+	  if (display.scroller.dragDrop) { display.scroller.dragDrop() }
+	  on(document, "mouseup", dragEnd)
+	  on(display.scroller, "drop", dragEnd)
+	}
+
+	// Normal selection, as opposed to text dragging.
+	function leftButtonSelect(cm, e, start, type, addNew) {
+	  var display = cm.display, doc = cm.doc
+	  e_preventDefault(e)
+
+	  var ourRange, ourIndex, startSel = doc.sel, ranges = startSel.ranges
+	  if (addNew && !e.shiftKey) {
+	    ourIndex = doc.sel.contains(start)
+	    if (ourIndex > -1)
+	      { ourRange = ranges[ourIndex] }
+	    else
+	      { ourRange = new Range(start, start) }
+	  } else {
+	    ourRange = doc.sel.primary()
+	    ourIndex = doc.sel.primIndex
+	  }
+
+	  if (chromeOS ? e.shiftKey && e.metaKey : e.altKey) {
+	    type = "rect"
+	    if (!addNew) { ourRange = new Range(start, start) }
+	    start = posFromMouse(cm, e, true, true)
+	    ourIndex = -1
+	  } else if (type == "double") {
+	    var word = cm.findWordAt(start)
+	    if (cm.display.shift || doc.extend)
+	      { ourRange = extendRange(doc, ourRange, word.anchor, word.head) }
+	    else
+	      { ourRange = word }
+	  } else if (type == "triple") {
+	    var line = new Range(Pos(start.line, 0), clipPos(doc, Pos(start.line + 1, 0)))
+	    if (cm.display.shift || doc.extend)
+	      { ourRange = extendRange(doc, ourRange, line.anchor, line.head) }
+	    else
+	      { ourRange = line }
+	  } else {
+	    ourRange = extendRange(doc, ourRange, start)
+	  }
+
+	  if (!addNew) {
+	    ourIndex = 0
+	    setSelection(doc, new Selection([ourRange], 0), sel_mouse)
+	    startSel = doc.sel
+	  } else if (ourIndex == -1) {
+	    ourIndex = ranges.length
+	    setSelection(doc, normalizeSelection(ranges.concat([ourRange]), ourIndex),
+	                 {scroll: false, origin: "*mouse"})
+	  } else if (ranges.length > 1 && ranges[ourIndex].empty() && type == "single" && !e.shiftKey) {
+	    setSelection(doc, normalizeSelection(ranges.slice(0, ourIndex).concat(ranges.slice(ourIndex + 1)), 0),
+	                 {scroll: false, origin: "*mouse"})
+	    startSel = doc.sel
+	  } else {
+	    replaceOneSelection(doc, ourIndex, ourRange, sel_mouse)
+	  }
+
+	  var lastPos = start
+	  function extendTo(pos) {
+	    if (cmp(lastPos, pos) == 0) { return }
+	    lastPos = pos
+
+	    if (type == "rect") {
+	      var ranges = [], tabSize = cm.options.tabSize
+	      var startCol = countColumn(getLine(doc, start.line).text, start.ch, tabSize)
+	      var posCol = countColumn(getLine(doc, pos.line).text, pos.ch, tabSize)
+	      var left = Math.min(startCol, posCol), right = Math.max(startCol, posCol)
+	      for (var line = Math.min(start.line, pos.line), end = Math.min(cm.lastLine(), Math.max(start.line, pos.line));
+	           line <= end; line++) {
+	        var text = getLine(doc, line).text, leftPos = findColumn(text, left, tabSize)
+	        if (left == right)
+	          { ranges.push(new Range(Pos(line, leftPos), Pos(line, leftPos))) }
+	        else if (text.length > leftPos)
+	          { ranges.push(new Range(Pos(line, leftPos), Pos(line, findColumn(text, right, tabSize)))) }
+	      }
+	      if (!ranges.length) { ranges.push(new Range(start, start)) }
+	      setSelection(doc, normalizeSelection(startSel.ranges.slice(0, ourIndex).concat(ranges), ourIndex),
+	                   {origin: "*mouse", scroll: false})
+	      cm.scrollIntoView(pos)
+	    } else {
+	      var oldRange = ourRange
+	      var anchor = oldRange.anchor, head = pos
+	      if (type != "single") {
+	        var range
+	        if (type == "double")
+	          { range = cm.findWordAt(pos) }
+	        else
+	          { range = new Range(Pos(pos.line, 0), clipPos(doc, Pos(pos.line + 1, 0))) }
+	        if (cmp(range.anchor, anchor) > 0) {
+	          head = range.head
+	          anchor = minPos(oldRange.from(), range.anchor)
+	        } else {
+	          head = range.anchor
+	          anchor = maxPos(oldRange.to(), range.head)
+	        }
+	      }
+	      var ranges$1 = startSel.ranges.slice(0)
+	      ranges$1[ourIndex] = new Range(clipPos(doc, anchor), head)
+	      setSelection(doc, normalizeSelection(ranges$1, ourIndex), sel_mouse)
+	    }
+	  }
+
+	  var editorSize = display.wrapper.getBoundingClientRect()
+	  // Used to ensure timeout re-tries don't fire when another extend
+	  // happened in the meantime (clearTimeout isn't reliable -- at
+	  // least on Chrome, the timeouts still happen even when cleared,
+	  // if the clear happens after their scheduled firing time).
+	  var counter = 0
+
+	  function extend(e) {
+	    var curCount = ++counter
+	    var cur = posFromMouse(cm, e, true, type == "rect")
+	    if (!cur) { return }
+	    if (cmp(cur, lastPos) != 0) {
+	      cm.curOp.focus = activeElt()
+	      extendTo(cur)
+	      var visible = visibleLines(display, doc)
+	      if (cur.line >= visible.to || cur.line < visible.from)
+	        { setTimeout(operation(cm, function () {if (counter == curCount) { extend(e) }}), 150) }
+	    } else {
+	      var outside = e.clientY < editorSize.top ? -20 : e.clientY > editorSize.bottom ? 20 : 0
+	      if (outside) { setTimeout(operation(cm, function () {
+	        if (counter != curCount) { return }
+	        display.scroller.scrollTop += outside
+	        extend(e)
+	      }), 50) }
+	    }
+	  }
+
+	  function done(e) {
+	    cm.state.selectingText = false
+	    counter = Infinity
+	    e_preventDefault(e)
+	    display.input.focus()
+	    off(document, "mousemove", move)
+	    off(document, "mouseup", up)
+	    doc.history.lastSelOrigin = null
+	  }
+
+	  var move = operation(cm, function (e) {
+	    if (!e_button(e)) { done(e) }
+	    else { extend(e) }
+	  })
+	  var up = operation(cm, done)
+	  cm.state.selectingText = up
+	  on(document, "mousemove", move)
+	  on(document, "mouseup", up)
+	}
+
+
+	// Determines whether an event happened in the gutter, and fires the
+	// handlers for the corresponding event.
+	function gutterEvent(cm, e, type, prevent) {
+	  var mX, mY
+	  try { mX = e.clientX; mY = e.clientY }
+	  catch(e) { return false }
+	  if (mX >= Math.floor(cm.display.gutters.getBoundingClientRect().right)) { return false }
+	  if (prevent) { e_preventDefault(e) }
+
+	  var display = cm.display
+	  var lineBox = display.lineDiv.getBoundingClientRect()
+
+	  if (mY > lineBox.bottom || !hasHandler(cm, type)) { return e_defaultPrevented(e) }
+	  mY -= lineBox.top - display.viewOffset
+
+	  for (var i = 0; i < cm.options.gutters.length; ++i) {
+	    var g = display.gutters.childNodes[i]
+	    if (g && g.getBoundingClientRect().right >= mX) {
+	      var line = lineAtHeight(cm.doc, mY)
+	      var gutter = cm.options.gutters[i]
+	      signal(cm, type, cm, line, gutter, e)
+	      return e_defaultPrevented(e)
+	    }
+	  }
+	}
+
+	function clickInGutter(cm, e) {
+	  return gutterEvent(cm, e, "gutterClick", true)
+	}
+
+	// CONTEXT MENU HANDLING
+
+	// To make the context menu work, we need to briefly unhide the
+	// textarea (making it as unobtrusive as possible) to let the
+	// right-click take effect on it.
+	function onContextMenu(cm, e) {
+	  if (eventInWidget(cm.display, e) || contextMenuInGutter(cm, e)) { return }
+	  if (signalDOMEvent(cm, e, "contextmenu")) { return }
+	  cm.display.input.onContextMenu(e)
+	}
+
+	function contextMenuInGutter(cm, e) {
+	  if (!hasHandler(cm, "gutterContextMenu")) { return false }
+	  return gutterEvent(cm, e, "gutterContextMenu", false)
+	}
+
+	function themeChanged(cm) {
+	  cm.display.wrapper.className = cm.display.wrapper.className.replace(/\s*cm-s-\S+/g, "") +
+	    cm.options.theme.replace(/(^|\s)\s*/g, " cm-s-")
+	  clearCaches(cm)
+	}
+
+	var Init = {toString: function(){return "CodeMirror.Init"}}
+
+	var defaults = {}
+	var optionHandlers = {}
+
+	function defineOptions(CodeMirror) {
+	  var optionHandlers = CodeMirror.optionHandlers
+
+	  function option(name, deflt, handle, notOnInit) {
+	    CodeMirror.defaults[name] = deflt
+	    if (handle) { optionHandlers[name] =
+	      notOnInit ? function (cm, val, old) {if (old != Init) { handle(cm, val, old) }} : handle }
+	  }
+
+	  CodeMirror.defineOption = option
+
+	  // Passed to option handlers when there is no old value.
+	  CodeMirror.Init = Init
+
+	  // These two are, on init, called from the constructor because they
+	  // have to be initialized before the editor can start at all.
+	  option("value", "", function (cm, val) { return cm.setValue(val); }, true)
+	  option("mode", null, function (cm, val) {
+	    cm.doc.modeOption = val
+	    loadMode(cm)
+	  }, true)
+
+	  option("indentUnit", 2, loadMode, true)
+	  option("indentWithTabs", false)
+	  option("smartIndent", true)
+	  option("tabSize", 4, function (cm) {
+	    resetModeState(cm)
+	    clearCaches(cm)
+	    regChange(cm)
+	  }, true)
+	  option("lineSeparator", null, function (cm, val) {
+	    cm.doc.lineSep = val
+	    if (!val) { return }
+	    var newBreaks = [], lineNo = cm.doc.first
+	    cm.doc.iter(function (line) {
+	      for (var pos = 0;;) {
+	        var found = line.text.indexOf(val, pos)
+	        if (found == -1) { break }
+	        pos = found + val.length
+	        newBreaks.push(Pos(lineNo, found))
+	      }
+	      lineNo++
+	    })
+	    for (var i = newBreaks.length - 1; i >= 0; i--)
+	      { replaceRange(cm.doc, val, newBreaks[i], Pos(newBreaks[i].line, newBreaks[i].ch + val.length)) }
+	  })
+	  option("specialChars", /[\u0000-\u001f\u007f\u00ad\u200b-\u200f\u2028\u2029\ufeff]/g, function (cm, val, old) {
+	    cm.state.specialChars = new RegExp(val.source + (val.test("\t") ? "" : "|\t"), "g")
+	    if (old != Init) { cm.refresh() }
+	  })
+	  option("specialCharPlaceholder", defaultSpecialCharPlaceholder, function (cm) { return cm.refresh(); }, true)
+	  option("electricChars", true)
+	  option("inputStyle", mobile ? "contenteditable" : "textarea", function () {
+	    throw new Error("inputStyle can not (yet) be changed in a running editor") // FIXME
+	  }, true)
+	  option("spellcheck", false, function (cm, val) { return cm.getInputField().spellcheck = val; }, true)
+	  option("rtlMoveVisually", !windows)
+	  option("wholeLineUpdateBefore", true)
+
+	  option("theme", "default", function (cm) {
+	    themeChanged(cm)
+	    guttersChanged(cm)
+	  }, true)
+	  option("keyMap", "default", function (cm, val, old) {
+	    var next = getKeyMap(val)
+	    var prev = old != Init && getKeyMap(old)
+	    if (prev && prev.detach) { prev.detach(cm, next) }
+	    if (next.attach) { next.attach(cm, prev || null) }
+	  })
+	  option("extraKeys", null)
+
+	  option("lineWrapping", false, wrappingChanged, true)
+	  option("gutters", [], function (cm) {
+	    setGuttersForLineNumbers(cm.options)
+	    guttersChanged(cm)
+	  }, true)
+	  option("fixedGutter", true, function (cm, val) {
+	    cm.display.gutters.style.left = val ? compensateForHScroll(cm.display) + "px" : "0"
+	    cm.refresh()
+	  }, true)
+	  option("coverGutterNextToScrollbar", false, function (cm) { return updateScrollbars(cm); }, true)
+	  option("scrollbarStyle", "native", function (cm) {
+	    initScrollbars(cm)
+	    updateScrollbars(cm)
+	    cm.display.scrollbars.setScrollTop(cm.doc.scrollTop)
+	    cm.display.scrollbars.setScrollLeft(cm.doc.scrollLeft)
+	  }, true)
+	  option("lineNumbers", false, function (cm) {
+	    setGuttersForLineNumbers(cm.options)
+	    guttersChanged(cm)
+	  }, true)
+	  option("firstLineNumber", 1, guttersChanged, true)
+	  option("lineNumberFormatter", function (integer) { return integer; }, guttersChanged, true)
+	  option("showCursorWhenSelecting", false, updateSelection, true)
+
+	  option("resetSelectionOnContextMenu", true)
+	  option("lineWiseCopyCut", true)
+
+	  option("readOnly", false, function (cm, val) {
+	    if (val == "nocursor") {
+	      onBlur(cm)
+	      cm.display.input.blur()
+	      cm.display.disabled = true
+	    } else {
+	      cm.display.disabled = false
+	    }
+	    cm.display.input.readOnlyChanged(val)
+	  })
+	  option("disableInput", false, function (cm, val) {if (!val) { cm.display.input.reset() }}, true)
+	  option("dragDrop", true, dragDropChanged)
+	  option("allowDropFileTypes", null)
+
+	  option("cursorBlinkRate", 530)
+	  option("cursorScrollMargin", 0)
+	  option("cursorHeight", 1, updateSelection, true)
+	  option("singleCursorHeightPerLine", true, updateSelection, true)
+	  option("workTime", 100)
+	  option("workDelay", 100)
+	  option("flattenSpans", true, resetModeState, true)
+	  option("addModeClass", false, resetModeState, true)
+	  option("pollInterval", 100)
+	  option("undoDepth", 200, function (cm, val) { return cm.doc.history.undoDepth = val; })
+	  option("historyEventDelay", 1250)
+	  option("viewportMargin", 10, function (cm) { return cm.refresh(); }, true)
+	  option("maxHighlightLength", 10000, resetModeState, true)
+	  option("moveInputWithCursor", true, function (cm, val) {
+	    if (!val) { cm.display.input.resetPosition() }
+	  })
+
+	  option("tabindex", null, function (cm, val) { return cm.display.input.getField().tabIndex = val || ""; })
+	  option("autofocus", null)
+	}
+
+	function guttersChanged(cm) {
+	  updateGutters(cm)
+	  regChange(cm)
+	  setTimeout(function () { return alignHorizontally(cm); }, 20)
+	}
+
+	function dragDropChanged(cm, value, old) {
+	  var wasOn = old && old != Init
+	  if (!value != !wasOn) {
+	    var funcs = cm.display.dragFunctions
+	    var toggle = value ? on : off
+	    toggle(cm.display.scroller, "dragstart", funcs.start)
+	    toggle(cm.display.scroller, "dragenter", funcs.enter)
+	    toggle(cm.display.scroller, "dragover", funcs.over)
+	    toggle(cm.display.scroller, "dragleave", funcs.leave)
+	    toggle(cm.display.scroller, "drop", funcs.drop)
+	  }
+	}
+
+	function wrappingChanged(cm) {
+	  if (cm.options.lineWrapping) {
+	    addClass(cm.display.wrapper, "CodeMirror-wrap")
+	    cm.display.sizer.style.minWidth = ""
+	    cm.display.sizerWidth = null
+	  } else {
+	    rmClass(cm.display.wrapper, "CodeMirror-wrap")
+	    findMaxLine(cm)
+	  }
+	  estimateLineHeights(cm)
+	  regChange(cm)
+	  clearCaches(cm)
+	  setTimeout(function () { return updateScrollbars(cm); }, 100)
+	}
+
+	// A CodeMirror instance represents an editor. This is the object
+	// that user code is usually dealing with.
+
+	function CodeMirror(place, options) {
+	  var this$1 = this;
+
+	  if (!(this instanceof CodeMirror)) { return new CodeMirror(place, options) }
+
+	  this.options = options = options ? copyObj(options) : {}
+	  // Determine effective options based on given values and defaults.
+	  copyObj(defaults, options, false)
+	  setGuttersForLineNumbers(options)
+
+	  var doc = options.value
+	  if (typeof doc == "string") { doc = new Doc(doc, options.mode, null, options.lineSeparator) }
+	  this.doc = doc
+
+	  var input = new CodeMirror.inputStyles[options.inputStyle](this)
+	  var display = this.display = new Display(place, doc, input)
+	  display.wrapper.CodeMirror = this
+	  updateGutters(this)
+	  themeChanged(this)
+	  if (options.lineWrapping)
+	    { this.display.wrapper.className += " CodeMirror-wrap" }
+	  if (options.autofocus && !mobile) { display.input.focus() }
+	  initScrollbars(this)
+
+	  this.state = {
+	    keyMaps: [],  // stores maps added by addKeyMap
+	    overlays: [], // highlighting overlays, as added by addOverlay
+	    modeGen: 0,   // bumped when mode/overlay changes, used to invalidate highlighting info
+	    overwrite: false,
+	    delayingBlurEvent: false,
+	    focused: false,
+	    suppressEdits: false, // used to disable editing during key handlers when in readOnly mode
+	    pasteIncoming: false, cutIncoming: false, // help recognize paste/cut edits in input.poll
+	    selectingText: false,
+	    draggingText: false,
+	    highlight: new Delayed(), // stores highlight worker timeout
+	    keySeq: null,  // Unfinished key sequence
+	    specialChars: null
+	  }
+
+	  // Override magic textarea content restore that IE sometimes does
+	  // on our hidden textarea on reload
+	  if (ie && ie_version < 11) { setTimeout(function () { return this$1.display.input.reset(true); }, 20) }
+
+	  registerEventHandlers(this)
+	  ensureGlobalHandlers()
+
+	  startOperation(this)
+	  this.curOp.forceUpdate = true
+	  attachDoc(this, doc)
+
+	  if ((options.autofocus && !mobile) || this.hasFocus())
+	    { setTimeout(bind(onFocus, this), 20) }
+	  else
+	    { onBlur(this) }
+
+	  for (var opt in optionHandlers) { if (optionHandlers.hasOwnProperty(opt))
+	    { optionHandlers[opt](this$1, options[opt], Init) } }
+	  maybeUpdateLineNumberWidth(this)
+	  if (options.finishInit) { options.finishInit(this) }
+	  for (var i = 0; i < initHooks.length; ++i) { initHooks[i](this$1) }
+	  endOperation(this)
+	  // Suppress optimizelegibility in Webkit, since it breaks text
+	  // measuring on line wrapping boundaries.
+	  if (webkit && options.lineWrapping &&
+	      getComputedStyle(display.lineDiv).textRendering == "optimizelegibility")
+	    { display.lineDiv.style.textRendering = "auto" }
+	}
+
+	// The default configuration options.
+	CodeMirror.defaults = defaults
+	// Functions to run when options are changed.
+	CodeMirror.optionHandlers = optionHandlers
+
+	// Attach the necessary event handlers when initializing the editor
+	function registerEventHandlers(cm) {
+	  var d = cm.display
+	  on(d.scroller, "mousedown", operation(cm, onMouseDown))
+	  // Older IE's will not fire a second mousedown for a double click
+	  if (ie && ie_version < 11)
+	    { on(d.scroller, "dblclick", operation(cm, function (e) {
+	      if (signalDOMEvent(cm, e)) { return }
+	      var pos = posFromMouse(cm, e)
+	      if (!pos || clickInGutter(cm, e) || eventInWidget(cm.display, e)) { return }
+	      e_preventDefault(e)
+	      var word = cm.findWordAt(pos)
+	      extendSelection(cm.doc, word.anchor, word.head)
+	    })) }
+	  else
+	    { on(d.scroller, "dblclick", function (e) { return signalDOMEvent(cm, e) || e_preventDefault(e); }) }
+	  // Some browsers fire contextmenu *after* opening the menu, at
+	  // which point we can't mess with it anymore. Context menu is
+	  // handled in onMouseDown for these browsers.
+	  if (!captureRightClick) { on(d.scroller, "contextmenu", function (e) { return onContextMenu(cm, e); }) }
+
+	  // Used to suppress mouse event handling when a touch happens
+	  var touchFinished, prevTouch = {end: 0}
+	  function finishTouch() {
+	    if (d.activeTouch) {
+	      touchFinished = setTimeout(function () { return d.activeTouch = null; }, 1000)
+	      prevTouch = d.activeTouch
+	      prevTouch.end = +new Date
+	    }
+	  }
+	  function isMouseLikeTouchEvent(e) {
+	    if (e.touches.length != 1) { return false }
+	    var touch = e.touches[0]
+	    return touch.radiusX <= 1 && touch.radiusY <= 1
+	  }
+	  function farAway(touch, other) {
+	    if (other.left == null) { return true }
+	    var dx = other.left - touch.left, dy = other.top - touch.top
+	    return dx * dx + dy * dy > 20 * 20
+	  }
+	  on(d.scroller, "touchstart", function (e) {
+	    if (!signalDOMEvent(cm, e) && !isMouseLikeTouchEvent(e)) {
+	      d.input.ensurePolled()
+	      clearTimeout(touchFinished)
+	      var now = +new Date
+	      d.activeTouch = {start: now, moved: false,
+	                       prev: now - prevTouch.end <= 300 ? prevTouch : null}
+	      if (e.touches.length == 1) {
+	        d.activeTouch.left = e.touches[0].pageX
+	        d.activeTouch.top = e.touches[0].pageY
+	      }
+	    }
+	  })
+	  on(d.scroller, "touchmove", function () {
+	    if (d.activeTouch) { d.activeTouch.moved = true }
+	  })
+	  on(d.scroller, "touchend", function (e) {
+	    var touch = d.activeTouch
+	    if (touch && !eventInWidget(d, e) && touch.left != null &&
+	        !touch.moved && new Date - touch.start < 300) {
+	      var pos = cm.coordsChar(d.activeTouch, "page"), range
+	      if (!touch.prev || farAway(touch, touch.prev)) // Single tap
+	        { range = new Range(pos, pos) }
+	      else if (!touch.prev.prev || farAway(touch, touch.prev.prev)) // Double tap
+	        { range = cm.findWordAt(pos) }
+	      else // Triple tap
+	        { range = new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0))) }
+	      cm.setSelection(range.anchor, range.head)
+	      cm.focus()
+	      e_preventDefault(e)
+	    }
+	    finishTouch()
+	  })
+	  on(d.scroller, "touchcancel", finishTouch)
+
+	  // Sync scrolling between fake scrollbars and real scrollable
+	  // area, ensure viewport is updated when scrolling.
+	  on(d.scroller, "scroll", function () {
+	    if (d.scroller.clientHeight) {
+	      setScrollTop(cm, d.scroller.scrollTop)
+	      setScrollLeft(cm, d.scroller.scrollLeft, true)
+	      signal(cm, "scroll", cm)
+	    }
+	  })
+
+	  // Listen to wheel events in order to try and update the viewport on time.
+	  on(d.scroller, "mousewheel", function (e) { return onScrollWheel(cm, e); })
+	  on(d.scroller, "DOMMouseScroll", function (e) { return onScrollWheel(cm, e); })
+
+	  // Prevent wrapper from ever scrolling
+	  on(d.wrapper, "scroll", function () { return d.wrapper.scrollTop = d.wrapper.scrollLeft = 0; })
+
+	  d.dragFunctions = {
+	    enter: function (e) {if (!signalDOMEvent(cm, e)) { e_stop(e) }},
+	    over: function (e) {if (!signalDOMEvent(cm, e)) { onDragOver(cm, e); e_stop(e) }},
+	    start: function (e) { return onDragStart(cm, e); },
+	    drop: operation(cm, onDrop),
+	    leave: function (e) {if (!signalDOMEvent(cm, e)) { clearDragCursor(cm) }}
+	  }
+
+	  var inp = d.input.getField()
+	  on(inp, "keyup", function (e) { return onKeyUp.call(cm, e); })
+	  on(inp, "keydown", operation(cm, onKeyDown))
+	  on(inp, "keypress", operation(cm, onKeyPress))
+	  on(inp, "focus", function (e) { return onFocus(cm, e); })
+	  on(inp, "blur", function (e) { return onBlur(cm, e); })
+	}
+
+	var initHooks = []
+	CodeMirror.defineInitHook = function (f) { return initHooks.push(f); }
+
+	// Indent the given line. The how parameter can be "smart",
+	// "add"/null, "subtract", or "prev". When aggressive is false
+	// (typically set to true for forced single-line indents), empty
+	// lines are not indented, and places where the mode returns Pass
+	// are left alone.
+	function indentLine(cm, n, how, aggressive) {
+	  var doc = cm.doc, state
+	  if (how == null) { how = "add" }
+	  if (how == "smart") {
+	    // Fall back to "prev" when the mode doesn't have an indentation
+	    // method.
+	    if (!doc.mode.indent) { how = "prev" }
+	    else { state = getStateBefore(cm, n) }
+	  }
+
+	  var tabSize = cm.options.tabSize
+	  var line = getLine(doc, n), curSpace = countColumn(line.text, null, tabSize)
+	  if (line.stateAfter) { line.stateAfter = null }
+	  var curSpaceString = line.text.match(/^\s*/)[0], indentation
+	  if (!aggressive && !/\S/.test(line.text)) {
+	    indentation = 0
+	    how = "not"
+	  } else if (how == "smart") {
+	    indentation = doc.mode.indent(state, line.text.slice(curSpaceString.length), line.text)
+	    if (indentation == Pass || indentation > 150) {
+	      if (!aggressive) { return }
+	      how = "prev"
+	    }
+	  }
+	  if (how == "prev") {
+	    if (n > doc.first) { indentation = countColumn(getLine(doc, n-1).text, null, tabSize) }
+	    else { indentation = 0 }
+	  } else if (how == "add") {
+	    indentation = curSpace + cm.options.indentUnit
+	  } else if (how == "subtract") {
+	    indentation = curSpace - cm.options.indentUnit
+	  } else if (typeof how == "number") {
+	    indentation = curSpace + how
+	  }
+	  indentation = Math.max(0, indentation)
+
+	  var indentString = "", pos = 0
+	  if (cm.options.indentWithTabs)
+	    { for (var i = Math.floor(indentation / tabSize); i; --i) {pos += tabSize; indentString += "\t"} }
+	  if (pos < indentation) { indentString += spaceStr(indentation - pos) }
+
+	  if (indentString != curSpaceString) {
+	    replaceRange(doc, indentString, Pos(n, 0), Pos(n, curSpaceString.length), "+input")
+	    line.stateAfter = null
+	    return true
+	  } else {
+	    // Ensure that, if the cursor was in the whitespace at the start
+	    // of the line, it is moved to the end of that space.
+	    for (var i$1 = 0; i$1 < doc.sel.ranges.length; i$1++) {
+	      var range = doc.sel.ranges[i$1]
+	      if (range.head.line == n && range.head.ch < curSpaceString.length) {
+	        var pos$1 = Pos(n, curSpaceString.length)
+	        replaceOneSelection(doc, i$1, new Range(pos$1, pos$1))
+	        break
+	      }
+	    }
+	  }
+	}
+
+	// This will be set to a {lineWise: bool, text: [string]} object, so
+	// that, when pasting, we know what kind of selections the copied
+	// text was made out of.
+	var lastCopied = null
+
+	function setLastCopied(newLastCopied) {
+	  lastCopied = newLastCopied
+	}
+
+	function applyTextInput(cm, inserted, deleted, sel, origin) {
+	  var doc = cm.doc
+	  cm.display.shift = false
+	  if (!sel) { sel = doc.sel }
+
+	  var paste = cm.state.pasteIncoming || origin == "paste"
+	  var textLines = splitLinesAuto(inserted), multiPaste = null
+	  // When pasing N lines into N selections, insert one line per selection
+	  if (paste && sel.ranges.length > 1) {
+	    if (lastCopied && lastCopied.text.join("\n") == inserted) {
+	      if (sel.ranges.length % lastCopied.text.length == 0) {
+	        multiPaste = []
+	        for (var i = 0; i < lastCopied.text.length; i++)
+	          { multiPaste.push(doc.splitLines(lastCopied.text[i])) }
+	      }
+	    } else if (textLines.length == sel.ranges.length) {
+	      multiPaste = map(textLines, function (l) { return [l]; })
+	    }
+	  }
+
+	  var updateInput
+	  // Normal behavior is to insert the new text into every selection
+	  for (var i$1 = sel.ranges.length - 1; i$1 >= 0; i$1--) {
+	    var range = sel.ranges[i$1]
+	    var from = range.from(), to = range.to()
+	    if (range.empty()) {
+	      if (deleted && deleted > 0) // Handle deletion
+	        { from = Pos(from.line, from.ch - deleted) }
+	      else if (cm.state.overwrite && !paste) // Handle overwrite
+	        { to = Pos(to.line, Math.min(getLine(doc, to.line).text.length, to.ch + lst(textLines).length)) }
+	      else if (lastCopied && lastCopied.lineWise && lastCopied.text.join("\n") == inserted)
+	        { from = to = Pos(from.line, 0) }
+	    }
+	    updateInput = cm.curOp.updateInput
+	    var changeEvent = {from: from, to: to, text: multiPaste ? multiPaste[i$1 % multiPaste.length] : textLines,
+	                       origin: origin || (paste ? "paste" : cm.state.cutIncoming ? "cut" : "+input")}
+	    makeChange(cm.doc, changeEvent)
+	    signalLater(cm, "inputRead", cm, changeEvent)
+	  }
+	  if (inserted && !paste)
+	    { triggerElectric(cm, inserted) }
+
+	  ensureCursorVisible(cm)
+	  cm.curOp.updateInput = updateInput
+	  cm.curOp.typing = true
+	  cm.state.pasteIncoming = cm.state.cutIncoming = false
+	}
+
+	function handlePaste(e, cm) {
+	  var pasted = e.clipboardData && e.clipboardData.getData("Text")
+	  if (pasted) {
+	    e.preventDefault()
+	    if (!cm.isReadOnly() && !cm.options.disableInput)
+	      { runInOp(cm, function () { return applyTextInput(cm, pasted, 0, null, "paste"); }) }
+	    return true
+	  }
+	}
+
+	function triggerElectric(cm, inserted) {
+	  // When an 'electric' character is inserted, immediately trigger a reindent
+	  if (!cm.options.electricChars || !cm.options.smartIndent) { return }
+	  var sel = cm.doc.sel
+
+	  for (var i = sel.ranges.length - 1; i >= 0; i--) {
+	    var range = sel.ranges[i]
+	    if (range.head.ch > 100 || (i && sel.ranges[i - 1].head.line == range.head.line)) { continue }
+	    var mode = cm.getModeAt(range.head)
+	    var indented = false
+	    if (mode.electricChars) {
+	      for (var j = 0; j < mode.electricChars.length; j++)
+	        { if (inserted.indexOf(mode.electricChars.charAt(j)) > -1) {
+	          indented = indentLine(cm, range.head.line, "smart")
+	          break
+	        } }
+	    } else if (mode.electricInput) {
+	      if (mode.electricInput.test(getLine(cm.doc, range.head.line).text.slice(0, range.head.ch)))
+	        { indented = indentLine(cm, range.head.line, "smart") }
+	    }
+	    if (indented) { signalLater(cm, "electricInput", cm, range.head.line) }
+	  }
+	}
+
+	function copyableRanges(cm) {
+	  var text = [], ranges = []
+	  for (var i = 0; i < cm.doc.sel.ranges.length; i++) {
+	    var line = cm.doc.sel.ranges[i].head.line
+	    var lineRange = {anchor: Pos(line, 0), head: Pos(line + 1, 0)}
+	    ranges.push(lineRange)
+	    text.push(cm.getRange(lineRange.anchor, lineRange.head))
+	  }
+	  return {text: text, ranges: ranges}
+	}
+
+	function disableBrowserMagic(field, spellcheck) {
+	  field.setAttribute("autocorrect", "off")
+	  field.setAttribute("autocapitalize", "off")
+	  field.setAttribute("spellcheck", !!spellcheck)
+	}
+
+	function hiddenTextarea() {
+	  var te = elt("textarea", null, null, "position: absolute; bottom: -1em; padding: 0; width: 1px; height: 1em; outline: none")
+	  var div = elt("div", [te], null, "overflow: hidden; position: relative; width: 3px; height: 0px;")
+	  // The textarea is kept positioned near the cursor to prevent the
+	  // fact that it'll be scrolled into view on input from scrolling
+	  // our fake cursor out of view. On webkit, when wrap=off, paste is
+	  // very slow. So make the area wide instead.
+	  if (webkit) { te.style.width = "1000px" }
+	  else { te.setAttribute("wrap", "off") }
+	  // If border: 0; -- iOS fails to open keyboard (issue #1287)
+	  if (ios) { te.style.border = "1px solid black" }
+	  disableBrowserMagic(te)
+	  return div
+	}
+
+	// The publicly visible API. Note that methodOp(f) means
+	// 'wrap f in an operation, performed on its `this` parameter'.
+
+	// This is not the complete set of editor methods. Most of the
+	// methods defined on the Doc type are also injected into
+	// CodeMirror.prototype, for backwards compatibility and
+	// convenience.
+
+	function addEditorMethods(CodeMirror) {
+	  var optionHandlers = CodeMirror.optionHandlers
+
+	  var helpers = CodeMirror.helpers = {}
+
+	  CodeMirror.prototype = {
+	    constructor: CodeMirror,
+	    focus: function(){window.focus(); this.display.input.focus()},
+
+	    setOption: function(option, value) {
+	      var options = this.options, old = options[option]
+	      if (options[option] == value && option != "mode") { return }
+	      options[option] = value
+	      if (optionHandlers.hasOwnProperty(option))
+	        { operation(this, optionHandlers[option])(this, value, old) }
+	    },
+
+	    getOption: function(option) {return this.options[option]},
+	    getDoc: function() {return this.doc},
+
+	    addKeyMap: function(map, bottom) {
+	      this.state.keyMaps[bottom ? "push" : "unshift"](getKeyMap(map))
+	    },
+	    removeKeyMap: function(map) {
+	      var maps = this.state.keyMaps
+	      for (var i = 0; i < maps.length; ++i)
+	        { if (maps[i] == map || maps[i].name == map) {
+	          maps.splice(i, 1)
+	          return true
+	        } }
+	    },
+
+	    addOverlay: methodOp(function(spec, options) {
+	      var mode = spec.token ? spec : CodeMirror.getMode(this.options, spec)
+	      if (mode.startState) { throw new Error("Overlays may not be stateful.") }
+	      insertSorted(this.state.overlays,
+	                   {mode: mode, modeSpec: spec, opaque: options && options.opaque,
+	                    priority: (options && options.priority) || 0},
+	                   function (overlay) { return overlay.priority; })
+	      this.state.modeGen++
+	      regChange(this)
+	    }),
+	    removeOverlay: methodOp(function(spec) {
+	      var this$1 = this;
+
+	      var overlays = this.state.overlays
+	      for (var i = 0; i < overlays.length; ++i) {
+	        var cur = overlays[i].modeSpec
+	        if (cur == spec || typeof spec == "string" && cur.name == spec) {
+	          overlays.splice(i, 1)
+	          this$1.state.modeGen++
+	          regChange(this$1)
+	          return
+	        }
+	      }
+	    }),
+
+	    indentLine: methodOp(function(n, dir, aggressive) {
+	      if (typeof dir != "string" && typeof dir != "number") {
+	        if (dir == null) { dir = this.options.smartIndent ? "smart" : "prev" }
+	        else { dir = dir ? "add" : "subtract" }
+	      }
+	      if (isLine(this.doc, n)) { indentLine(this, n, dir, aggressive) }
+	    }),
+	    indentSelection: methodOp(function(how) {
+	      var this$1 = this;
+
+	      var ranges = this.doc.sel.ranges, end = -1
+	      for (var i = 0; i < ranges.length; i++) {
+	        var range = ranges[i]
+	        if (!range.empty()) {
+	          var from = range.from(), to = range.to()
+	          var start = Math.max(end, from.line)
+	          end = Math.min(this$1.lastLine(), to.line - (to.ch ? 0 : 1)) + 1
+	          for (var j = start; j < end; ++j)
+	            { indentLine(this$1, j, how) }
+	          var newRanges = this$1.doc.sel.ranges
+	          if (from.ch == 0 && ranges.length == newRanges.length && newRanges[i].from().ch > 0)
+	            { replaceOneSelection(this$1.doc, i, new Range(from, newRanges[i].to()), sel_dontScroll) }
+	        } else if (range.head.line > end) {
+	          indentLine(this$1, range.head.line, how, true)
+	          end = range.head.line
+	          if (i == this$1.doc.sel.primIndex) { ensureCursorVisible(this$1) }
+	        }
+	      }
+	    }),
+
+	    // Fetch the parser token for a given character. Useful for hacks
+	    // that want to inspect the mode state (say, for completion).
+	    getTokenAt: function(pos, precise) {
+	      return takeToken(this, pos, precise)
+	    },
+
+	    getLineTokens: function(line, precise) {
+	      return takeToken(this, Pos(line), precise, true)
+	    },
+
+	    getTokenTypeAt: function(pos) {
+	      pos = clipPos(this.doc, pos)
+	      var styles = getLineStyles(this, getLine(this.doc, pos.line))
+	      var before = 0, after = (styles.length - 1) / 2, ch = pos.ch
+	      var type
+	      if (ch == 0) { type = styles[2] }
+	      else { for (;;) {
+	        var mid = (before + after) >> 1
+	        if ((mid ? styles[mid * 2 - 1] : 0) >= ch) { after = mid }
+	        else if (styles[mid * 2 + 1] < ch) { before = mid + 1 }
+	        else { type = styles[mid * 2 + 2]; break }
+	      } }
+	      var cut = type ? type.indexOf("overlay ") : -1
+	      return cut < 0 ? type : cut == 0 ? null : type.slice(0, cut - 1)
+	    },
+
+	    getModeAt: function(pos) {
+	      var mode = this.doc.mode
+	      if (!mode.innerMode) { return mode }
+	      return CodeMirror.innerMode(mode, this.getTokenAt(pos).state).mode
+	    },
+
+	    getHelper: function(pos, type) {
+	      return this.getHelpers(pos, type)[0]
+	    },
+
+	    getHelpers: function(pos, type) {
+	      var this$1 = this;
+
+	      var found = []
+	      if (!helpers.hasOwnProperty(type)) { return found }
+	      var help = helpers[type], mode = this.getModeAt(pos)
+	      if (typeof mode[type] == "string") {
+	        if (help[mode[type]]) { found.push(help[mode[type]]) }
+	      } else if (mode[type]) {
+	        for (var i = 0; i < mode[type].length; i++) {
+	          var val = help[mode[type][i]]
+	          if (val) { found.push(val) }
+	        }
+	      } else if (mode.helperType && help[mode.helperType]) {
+	        found.push(help[mode.helperType])
+	      } else if (help[mode.name]) {
+	        found.push(help[mode.name])
+	      }
+	      for (var i$1 = 0; i$1 < help._global.length; i$1++) {
+	        var cur = help._global[i$1]
+	        if (cur.pred(mode, this$1) && indexOf(found, cur.val) == -1)
+	          { found.push(cur.val) }
+	      }
+	      return found
+	    },
+
+	    getStateAfter: function(line, precise) {
+	      var doc = this.doc
+	      line = clipLine(doc, line == null ? doc.first + doc.size - 1: line)
+	      return getStateBefore(this, line + 1, precise)
+	    },
+
+	    cursorCoords: function(start, mode) {
+	      var pos, range = this.doc.sel.primary()
+	      if (start == null) { pos = range.head }
+	      else if (typeof start == "object") { pos = clipPos(this.doc, start) }
+	      else { pos = start ? range.from() : range.to() }
+	      return cursorCoords(this, pos, mode || "page")
+	    },
+
+	    charCoords: function(pos, mode) {
+	      return charCoords(this, clipPos(this.doc, pos), mode || "page")
+	    },
+
+	    coordsChar: function(coords, mode) {
+	      coords = fromCoordSystem(this, coords, mode || "page")
+	      return coordsChar(this, coords.left, coords.top)
+	    },
+
+	    lineAtHeight: function(height, mode) {
+	      height = fromCoordSystem(this, {top: height, left: 0}, mode || "page").top
+	      return lineAtHeight(this.doc, height + this.display.viewOffset)
+	    },
+	    heightAtLine: function(line, mode, includeWidgets) {
+	      var end = false, lineObj
+	      if (typeof line == "number") {
+	        var last = this.doc.first + this.doc.size - 1
+	        if (line < this.doc.first) { line = this.doc.first }
+	        else if (line > last) { line = last; end = true }
+	        lineObj = getLine(this.doc, line)
+	      } else {
+	        lineObj = line
+	      }
+	      return intoCoordSystem(this, lineObj, {top: 0, left: 0}, mode || "page", includeWidgets).top +
+	        (end ? this.doc.height - heightAtLine(lineObj) : 0)
+	    },
+
+	    defaultTextHeight: function() { return textHeight(this.display) },
+	    defaultCharWidth: function() { return charWidth(this.display) },
+
+	    getViewport: function() { return {from: this.display.viewFrom, to: this.display.viewTo}},
+
+	    addWidget: function(pos, node, scroll, vert, horiz) {
+	      var display = this.display
+	      pos = cursorCoords(this, clipPos(this.doc, pos))
+	      var top = pos.bottom, left = pos.left
+	      node.style.position = "absolute"
+	      node.setAttribute("cm-ignore-events", "true")
+	      this.display.input.setUneditable(node)
+	      display.sizer.appendChild(node)
+	      if (vert == "over") {
+	        top = pos.top
+	      } else if (vert == "above" || vert == "near") {
+	        var vspace = Math.max(display.wrapper.clientHeight, this.doc.height),
+	        hspace = Math.max(display.sizer.clientWidth, display.lineSpace.clientWidth)
+	        // Default to positioning above (if specified and possible); otherwise default to positioning below
+	        if ((vert == 'above' || pos.bottom + node.offsetHeight > vspace) && pos.top > node.offsetHeight)
+	          { top = pos.top - node.offsetHeight }
+	        else if (pos.bottom + node.offsetHeight <= vspace)
+	          { top = pos.bottom }
+	        if (left + node.offsetWidth > hspace)
+	          { left = hspace - node.offsetWidth }
+	      }
+	      node.style.top = top + "px"
+	      node.style.left = node.style.right = ""
+	      if (horiz == "right") {
+	        left = display.sizer.clientWidth - node.offsetWidth
+	        node.style.right = "0px"
+	      } else {
+	        if (horiz == "left") { left = 0 }
+	        else if (horiz == "middle") { left = (display.sizer.clientWidth - node.offsetWidth) / 2 }
+	        node.style.left = left + "px"
+	      }
+	      if (scroll)
+	        { scrollIntoView(this, left, top, left + node.offsetWidth, top + node.offsetHeight) }
+	    },
+
+	    triggerOnKeyDown: methodOp(onKeyDown),
+	    triggerOnKeyPress: methodOp(onKeyPress),
+	    triggerOnKeyUp: onKeyUp,
+
+	    execCommand: function(cmd) {
+	      if (commands.hasOwnProperty(cmd))
+	        { return commands[cmd].call(null, this) }
+	    },
+
+	    triggerElectric: methodOp(function(text) { triggerElectric(this, text) }),
+
+	    findPosH: function(from, amount, unit, visually) {
+	      var this$1 = this;
+
+	      var dir = 1
+	      if (amount < 0) { dir = -1; amount = -amount }
+	      var cur = clipPos(this.doc, from)
+	      for (var i = 0; i < amount; ++i) {
+	        cur = findPosH(this$1.doc, cur, dir, unit, visually)
+	        if (cur.hitSide) { break }
+	      }
+	      return cur
+	    },
+
+	    moveH: methodOp(function(dir, unit) {
+	      var this$1 = this;
+
+	      this.extendSelectionsBy(function (range) {
+	        if (this$1.display.shift || this$1.doc.extend || range.empty())
+	          { return findPosH(this$1.doc, range.head, dir, unit, this$1.options.rtlMoveVisually) }
+	        else
+	          { return dir < 0 ? range.from() : range.to() }
+	      }, sel_move)
+	    }),
+
+	    deleteH: methodOp(function(dir, unit) {
+	      var sel = this.doc.sel, doc = this.doc
+	      if (sel.somethingSelected())
+	        { doc.replaceSelection("", null, "+delete") }
+	      else
+	        { deleteNearSelection(this, function (range) {
+	          var other = findPosH(doc, range.head, dir, unit, false)
+	          return dir < 0 ? {from: other, to: range.head} : {from: range.head, to: other}
+	        }) }
+	    }),
+
+	    findPosV: function(from, amount, unit, goalColumn) {
+	      var this$1 = this;
+
+	      var dir = 1, x = goalColumn
+	      if (amount < 0) { dir = -1; amount = -amount }
+	      var cur = clipPos(this.doc, from)
+	      for (var i = 0; i < amount; ++i) {
+	        var coords = cursorCoords(this$1, cur, "div")
+	        if (x == null) { x = coords.left }
+	        else { coords.left = x }
+	        cur = findPosV(this$1, coords, dir, unit)
+	        if (cur.hitSide) { break }
+	      }
+	      return cur
+	    },
+
+	    moveV: methodOp(function(dir, unit) {
+	      var this$1 = this;
+
+	      var doc = this.doc, goals = []
+	      var collapse = !this.display.shift && !doc.extend && doc.sel.somethingSelected()
+	      doc.extendSelectionsBy(function (range) {
+	        if (collapse)
+	          { return dir < 0 ? range.from() : range.to() }
+	        var headPos = cursorCoords(this$1, range.head, "div")
+	        if (range.goalColumn != null) { headPos.left = range.goalColumn }
+	        goals.push(headPos.left)
+	        var pos = findPosV(this$1, headPos, dir, unit)
+	        if (unit == "page" && range == doc.sel.primary())
+	          { addToScrollPos(this$1, null, charCoords(this$1, pos, "div").top - headPos.top) }
+	        return pos
+	      }, sel_move)
+	      if (goals.length) { for (var i = 0; i < doc.sel.ranges.length; i++)
+	        { doc.sel.ranges[i].goalColumn = goals[i] } }
+	    }),
+
+	    // Find the word at the given position (as returned by coordsChar).
+	    findWordAt: function(pos) {
+	      var doc = this.doc, line = getLine(doc, pos.line).text
+	      var start = pos.ch, end = pos.ch
+	      if (line) {
+	        var helper = this.getHelper(pos, "wordChars")
+	        if ((pos.xRel < 0 || end == line.length) && start) { --start; } else { ++end }
+	        var startChar = line.charAt(start)
+	        var check = isWordChar(startChar, helper)
+	          ? function (ch) { return isWordChar(ch, helper); }
+	          : /\s/.test(startChar) ? function (ch) { return /\s/.test(ch); }
+	          : function (ch) { return (!/\s/.test(ch) && !isWordChar(ch)); }
+	        while (start > 0 && check(line.charAt(start - 1))) { --start }
+	        while (end < line.length && check(line.charAt(end))) { ++end }
+	      }
+	      return new Range(Pos(pos.line, start), Pos(pos.line, end))
+	    },
+
+	    toggleOverwrite: function(value) {
+	      if (value != null && value == this.state.overwrite) { return }
+	      if (this.state.overwrite = !this.state.overwrite)
+	        { addClass(this.display.cursorDiv, "CodeMirror-overwrite") }
+	      else
+	        { rmClass(this.display.cursorDiv, "CodeMirror-overwrite") }
+
+	      signal(this, "overwriteToggle", this, this.state.overwrite)
+	    },
+	    hasFocus: function() { return this.display.input.getField() == activeElt() },
+	    isReadOnly: function() { return !!(this.options.readOnly || this.doc.cantEdit) },
+
+	    scrollTo: methodOp(function(x, y) {
+	      if (x != null || y != null) { resolveScrollToPos(this) }
+	      if (x != null) { this.curOp.scrollLeft = x }
+	      if (y != null) { this.curOp.scrollTop = y }
+	    }),
+	    getScrollInfo: function() {
+	      var scroller = this.display.scroller
+	      return {left: scroller.scrollLeft, top: scroller.scrollTop,
+	              height: scroller.scrollHeight - scrollGap(this) - this.display.barHeight,
+	              width: scroller.scrollWidth - scrollGap(this) - this.display.barWidth,
+	              clientHeight: displayHeight(this), clientWidth: displayWidth(this)}
+	    },
+
+	    scrollIntoView: methodOp(function(range, margin) {
+	      if (range == null) {
+	        range = {from: this.doc.sel.primary().head, to: null}
+	        if (margin == null) { margin = this.options.cursorScrollMargin }
+	      } else if (typeof range == "number") {
+	        range = {from: Pos(range, 0), to: null}
+	      } else if (range.from == null) {
+	        range = {from: range, to: null}
+	      }
+	      if (!range.to) { range.to = range.from }
+	      range.margin = margin || 0
+
+	      if (range.from.line != null) {
+	        resolveScrollToPos(this)
+	        this.curOp.scrollToPos = range
+	      } else {
+	        var sPos = calculateScrollPos(this, Math.min(range.from.left, range.to.left),
+	                                      Math.min(range.from.top, range.to.top) - range.margin,
+	                                      Math.max(range.from.right, range.to.right),
+	                                      Math.max(range.from.bottom, range.to.bottom) + range.margin)
+	        this.scrollTo(sPos.scrollLeft, sPos.scrollTop)
+	      }
+	    }),
+
+	    setSize: methodOp(function(width, height) {
+	      var this$1 = this;
+
+	      var interpret = function (val) { return typeof val == "number" || /^\d+$/.test(String(val)) ? val + "px" : val; }
+	      if (width != null) { this.display.wrapper.style.width = interpret(width) }
+	      if (height != null) { this.display.wrapper.style.height = interpret(height) }
+	      if (this.options.lineWrapping) { clearLineMeasurementCache(this) }
+	      var lineNo = this.display.viewFrom
+	      this.doc.iter(lineNo, this.display.viewTo, function (line) {
+	        if (line.widgets) { for (var i = 0; i < line.widgets.length; i++)
+	          { if (line.widgets[i].noHScroll) { regLineChange(this$1, lineNo, "widget"); break } } }
+	        ++lineNo
+	      })
+	      this.curOp.forceUpdate = true
+	      signal(this, "refresh", this)
+	    }),
+
+	    operation: function(f){return runInOp(this, f)},
+
+	    refresh: methodOp(function() {
+	      var oldHeight = this.display.cachedTextHeight
+	      regChange(this)
+	      this.curOp.forceUpdate = true
+	      clearCaches(this)
+	      this.scrollTo(this.doc.scrollLeft, this.doc.scrollTop)
+	      updateGutterSpace(this)
+	      if (oldHeight == null || Math.abs(oldHeight - textHeight(this.display)) > .5)
+	        { estimateLineHeights(this) }
+	      signal(this, "refresh", this)
+	    }),
+
+	    swapDoc: methodOp(function(doc) {
+	      var old = this.doc
+	      old.cm = null
+	      attachDoc(this, doc)
+	      clearCaches(this)
+	      this.display.input.reset()
+	      this.scrollTo(doc.scrollLeft, doc.scrollTop)
+	      this.curOp.forceScroll = true
+	      signalLater(this, "swapDoc", this, old)
+	      return old
+	    }),
+
+	    getInputField: function(){return this.display.input.getField()},
+	    getWrapperElement: function(){return this.display.wrapper},
+	    getScrollerElement: function(){return this.display.scroller},
+	    getGutterElement: function(){return this.display.gutters}
+	  }
+	  eventMixin(CodeMirror)
+
+	  CodeMirror.registerHelper = function(type, name, value) {
+	    if (!helpers.hasOwnProperty(type)) { helpers[type] = CodeMirror[type] = {_global: []} }
+	    helpers[type][name] = value
+	  }
+	  CodeMirror.registerGlobalHelper = function(type, name, predicate, value) {
+	    CodeMirror.registerHelper(type, name, value)
+	    helpers[type]._global.push({pred: predicate, val: value})
+	  }
+	}
+
+	// Used for horizontal relative motion. Dir is -1 or 1 (left or
+	// right), unit can be "char", "column" (like char, but doesn't
+	// cross line boundaries), "word" (across next word), or "group" (to
+	// the start of next group of word or non-word-non-whitespace
+	// chars). The visually param controls whether, in right-to-left
+	// text, direction 1 means to move towards the next index in the
+	// string, or towards the character to the right of the current
+	// position. The resulting position will have a hitSide=true
+	// property if it reached the end of the document.
+	function findPosH(doc, pos, dir, unit, visually) {
+	  var line = pos.line, ch = pos.ch, origDir = dir
+	  var lineObj = getLine(doc, line)
+	  function findNextLine() {
+	    var l = line + dir
+	    if (l < doc.first || l >= doc.first + doc.size) { return false }
+	    line = l
+	    return lineObj = getLine(doc, l)
+	  }
+	  function moveOnce(boundToLine) {
+	    var next = (visually ? moveVisually : moveLogically)(lineObj, ch, dir, true)
+	    if (next == null) {
+	      if (!boundToLine && findNextLine()) {
+	        if (visually) { ch = (dir < 0 ? lineRight : lineLeft)(lineObj) }
+	        else { ch = dir < 0 ? lineObj.text.length : 0 }
+	      } else { return false }
+	    } else { ch = next }
+	    return true
+	  }
+
+	  if (unit == "char") {
+	    moveOnce()
+	  } else if (unit == "column") {
+	    moveOnce(true)
+	  } else if (unit == "word" || unit == "group") {
+	    var sawType = null, group = unit == "group"
+	    var helper = doc.cm && doc.cm.getHelper(pos, "wordChars")
+	    for (var first = true;; first = false) {
+	      if (dir < 0 && !moveOnce(!first)) { break }
+	      var cur = lineObj.text.charAt(ch) || "\n"
+	      var type = isWordChar(cur, helper) ? "w"
+	        : group && cur == "\n" ? "n"
+	        : !group || /\s/.test(cur) ? null
+	        : "p"
+	      if (group && !first && !type) { type = "s" }
+	      if (sawType && sawType != type) {
+	        if (dir < 0) {dir = 1; moveOnce()}
+	        break
+	      }
+
+	      if (type) { sawType = type }
+	      if (dir > 0 && !moveOnce(!first)) { break }
+	    }
+	  }
+	  var result = skipAtomic(doc, Pos(line, ch), pos, origDir, true)
+	  if (!cmp(pos, result)) { result.hitSide = true }
+	  return result
+	}
+
+	// For relative vertical movement. Dir may be -1 or 1. Unit can be
+	// "page" or "line". The resulting position will have a hitSide=true
+	// property if it reached the end of the document.
+	function findPosV(cm, pos, dir, unit) {
+	  var doc = cm.doc, x = pos.left, y
+	  if (unit == "page") {
+	    var pageSize = Math.min(cm.display.wrapper.clientHeight, window.innerHeight || document.documentElement.clientHeight)
+	    var moveAmount = Math.max(pageSize - .5 * textHeight(cm.display), 3)
+	    y = (dir > 0 ? pos.bottom : pos.top) + dir * moveAmount
+
+	  } else if (unit == "line") {
+	    y = dir > 0 ? pos.bottom + 3 : pos.top - 3
+	  }
+	  var target
+	  for (;;) {
+	    target = coordsChar(cm, x, y)
+	    if (!target.outside) { break }
+	    if (dir < 0 ? y <= 0 : y >= doc.height) { target.hitSide = true; break }
+	    y += dir * 5
+	  }
+	  return target
+	}
+
+	// CONTENTEDITABLE INPUT STYLE
+
+	function ContentEditableInput(cm) {
+	  this.cm = cm
+	  this.lastAnchorNode = this.lastAnchorOffset = this.lastFocusNode = this.lastFocusOffset = null
+	  this.polling = new Delayed()
+	  this.composing = null
+	  this.gracePeriod = false
+	  this.readDOMTimeout = null
+	}
+
+	ContentEditableInput.prototype = copyObj({
+	  init: function(display) {
+	    var this$1 = this;
+
+	    var input = this, cm = input.cm
+	    var div = input.div = display.lineDiv
+	    disableBrowserMagic(div, cm.options.spellcheck)
+
+	    on(div, "paste", function (e) {
+	      if (signalDOMEvent(cm, e) || handlePaste(e, cm)) { return }
+	      // IE doesn't fire input events, so we schedule a read for the pasted content in this way
+	      if (ie_version <= 11) { setTimeout(operation(cm, function () {
+	        if (!input.pollContent()) { regChange(cm) }
+	      }), 20) }
+	    })
+
+	    on(div, "compositionstart", function (e) {
+	      this$1.composing = {data: e.data}
+	    })
+	    on(div, "compositionupdate", function (e) {
+	      if (!this$1.composing) { this$1.composing = {data: e.data} }
+	    })
+	    on(div, "compositionend", function (e) {
+	      if (this$1.composing) {
+	        if (e.data != this$1.composing.data) { this$1.readFromDOMSoon() }
+	        this$1.composing = null
+	      }
+	    })
+
+	    on(div, "touchstart", function () { return input.forceCompositionEnd(); })
+
+	    on(div, "input", function () {
+	      if (!this$1.composing) { this$1.readFromDOMSoon() }
+	    })
+
+	    function onCopyCut(e) {
+	      if (signalDOMEvent(cm, e)) { return }
+	      if (cm.somethingSelected()) {
+	        setLastCopied({lineWise: false, text: cm.getSelections()})
+	        if (e.type == "cut") { cm.replaceSelection("", null, "cut") }
+	      } else if (!cm.options.lineWiseCopyCut) {
+	        return
+	      } else {
+	        var ranges = copyableRanges(cm)
+	        setLastCopied({lineWise: true, text: ranges.text})
+	        if (e.type == "cut") {
+	          cm.operation(function () {
+	            cm.setSelections(ranges.ranges, 0, sel_dontScroll)
+	            cm.replaceSelection("", null, "cut")
+	          })
+	        }
+	      }
+	      if (e.clipboardData) {
+	        e.clipboardData.clearData()
+	        var content = lastCopied.text.join("\n")
+	        // iOS exposes the clipboard API, but seems to discard content inserted into it
+	        e.clipboardData.setData("Text", content)
+	        if (e.clipboardData.getData("Text") == content) {
+	          e.preventDefault()
+	          return
+	        }
+	      }
+	      // Old-fashioned briefly-focus-a-textarea hack
+	      var kludge = hiddenTextarea(), te = kludge.firstChild
+	      cm.display.lineSpace.insertBefore(kludge, cm.display.lineSpace.firstChild)
+	      te.value = lastCopied.text.join("\n")
+	      var hadFocus = document.activeElement
+	      selectInput(te)
+	      setTimeout(function () {
+	        cm.display.lineSpace.removeChild(kludge)
+	        hadFocus.focus()
+	        if (hadFocus == div) { input.showPrimarySelection() }
+	      }, 50)
+	    }
+	    on(div, "copy", onCopyCut)
+	    on(div, "cut", onCopyCut)
+	  },
+
+	  prepareSelection: function() {
+	    var result = prepareSelection(this.cm, false)
+	    result.focus = this.cm.state.focused
+	    return result
+	  },
+
+	  showSelection: function(info, takeFocus) {
+	    if (!info || !this.cm.display.view.length) { return }
+	    if (info.focus || takeFocus) { this.showPrimarySelection() }
+	    this.showMultipleSelections(info)
+	  },
+
+	  showPrimarySelection: function() {
+	    var sel = window.getSelection(), prim = this.cm.doc.sel.primary()
+	    var curAnchor = domToPos(this.cm, sel.anchorNode, sel.anchorOffset)
+	    var curFocus = domToPos(this.cm, sel.focusNode, sel.focusOffset)
+	    if (curAnchor && !curAnchor.bad && curFocus && !curFocus.bad &&
+	        cmp(minPos(curAnchor, curFocus), prim.from()) == 0 &&
+	        cmp(maxPos(curAnchor, curFocus), prim.to()) == 0)
+	      { return }
+
+	    var start = posToDOM(this.cm, prim.from())
+	    var end = posToDOM(this.cm, prim.to())
+	    if (!start && !end) { return }
+
+	    var view = this.cm.display.view
+	    var old = sel.rangeCount && sel.getRangeAt(0)
+	    if (!start) {
+	      start = {node: view[0].measure.map[2], offset: 0}
+	    } else if (!end) { // FIXME dangerously hacky
+	      var measure = view[view.length - 1].measure
+	      var map = measure.maps ? measure.maps[measure.maps.length - 1] : measure.map
+	      end = {node: map[map.length - 1], offset: map[map.length - 2] - map[map.length - 3]}
+	    }
+
+	    var rng
+	    try { rng = range(start.node, start.offset, end.offset, end.node) }
+	    catch(e) {} // Our model of the DOM might be outdated, in which case the range we try to set can be impossible
+	    if (rng) {
+	      if (!gecko && this.cm.state.focused) {
+	        sel.collapse(start.node, start.offset)
+	        if (!rng.collapsed) {
+	          sel.removeAllRanges()
+	          sel.addRange(rng)
+	        }
+	      } else {
+	        sel.removeAllRanges()
+	        sel.addRange(rng)
+	      }
+	      if (old && sel.anchorNode == null) { sel.addRange(old) }
+	      else if (gecko) { this.startGracePeriod() }
+	    }
+	    this.rememberSelection()
+	  },
+
+	  startGracePeriod: function() {
+	    var this$1 = this;
+
+	    clearTimeout(this.gracePeriod)
+	    this.gracePeriod = setTimeout(function () {
+	      this$1.gracePeriod = false
+	      if (this$1.selectionChanged())
+	        { this$1.cm.operation(function () { return this$1.cm.curOp.selectionChanged = true; }) }
+	    }, 20)
+	  },
+
+	  showMultipleSelections: function(info) {
+	    removeChildrenAndAdd(this.cm.display.cursorDiv, info.cursors)
+	    removeChildrenAndAdd(this.cm.display.selectionDiv, info.selection)
+	  },
+
+	  rememberSelection: function() {
+	    var sel = window.getSelection()
+	    this.lastAnchorNode = sel.anchorNode; this.lastAnchorOffset = sel.anchorOffset
+	    this.lastFocusNode = sel.focusNode; this.lastFocusOffset = sel.focusOffset
+	  },
+
+	  selectionInEditor: function() {
+	    var sel = window.getSelection()
+	    if (!sel.rangeCount) { return false }
+	    var node = sel.getRangeAt(0).commonAncestorContainer
+	    return contains(this.div, node)
+	  },
+
+	  focus: function() {
+	    if (this.cm.options.readOnly != "nocursor") {
+	      if (!this.selectionInEditor())
+	        { this.showSelection(this.prepareSelection(), true) }
+	      this.div.focus()
+	    }
+	  },
+	  blur: function() { this.div.blur() },
+	  getField: function() { return this.div },
+
+	  supportsTouch: function() { return true },
+
+	  receivedFocus: function() {
+	    var input = this
+	    if (this.selectionInEditor())
+	      { this.pollSelection() }
+	    else
+	      { runInOp(this.cm, function () { return input.cm.curOp.selectionChanged = true; }) }
+
+	    function poll() {
+	      if (input.cm.state.focused) {
+	        input.pollSelection()
+	        input.polling.set(input.cm.options.pollInterval, poll)
+	      }
+	    }
+	    this.polling.set(this.cm.options.pollInterval, poll)
+	  },
+
+	  selectionChanged: function() {
+	    var sel = window.getSelection()
+	    return sel.anchorNode != this.lastAnchorNode || sel.anchorOffset != this.lastAnchorOffset ||
+	      sel.focusNode != this.lastFocusNode || sel.focusOffset != this.lastFocusOffset
+	  },
+
+	  pollSelection: function() {
+	    if (!this.composing && this.readDOMTimeout == null && !this.gracePeriod && this.selectionChanged()) {
+	      var sel = window.getSelection(), cm = this.cm
+	      this.rememberSelection()
+	      var anchor = domToPos(cm, sel.anchorNode, sel.anchorOffset)
+	      var head = domToPos(cm, sel.focusNode, sel.focusOffset)
+	      if (anchor && head) { runInOp(cm, function () {
+	        setSelection(cm.doc, simpleSelection(anchor, head), sel_dontScroll)
+	        if (anchor.bad || head.bad) { cm.curOp.selectionChanged = true }
+	      }) }
+	    }
+	  },
+
+	  pollContent: function() {
+	    if (this.readDOMTimeout != null) {
+	      clearTimeout(this.readDOMTimeout)
+	      this.readDOMTimeout = null
+	    }
+
+	    var cm = this.cm, display = cm.display, sel = cm.doc.sel.primary()
+	    var from = sel.from(), to = sel.to()
+	    if (from.ch == 0 && from.line > cm.firstLine())
+	      { from = Pos(from.line - 1, getLine(cm.doc, from.line - 1).length) }
+	    if (to.ch == getLine(cm.doc, to.line).text.length && to.line < cm.lastLine())
+	      { to = Pos(to.line + 1, 0) }
+	    if (from.line < display.viewFrom || to.line > display.viewTo - 1) { return false }
+
+	    var fromIndex, fromLine, fromNode
+	    if (from.line == display.viewFrom || (fromIndex = findViewIndex(cm, from.line)) == 0) {
+	      fromLine = lineNo(display.view[0].line)
+	      fromNode = display.view[0].node
+	    } else {
+	      fromLine = lineNo(display.view[fromIndex].line)
+	      fromNode = display.view[fromIndex - 1].node.nextSibling
+	    }
+	    var toIndex = findViewIndex(cm, to.line)
+	    var toLine, toNode
+	    if (toIndex == display.view.length - 1) {
+	      toLine = display.viewTo - 1
+	      toNode = display.lineDiv.lastChild
+	    } else {
+	      toLine = lineNo(display.view[toIndex + 1].line) - 1
+	      toNode = display.view[toIndex + 1].node.previousSibling
+	    }
+
+	    if (!fromNode) { return false }
+	    var newText = cm.doc.splitLines(domTextBetween(cm, fromNode, toNode, fromLine, toLine))
+	    var oldText = getBetween(cm.doc, Pos(fromLine, 0), Pos(toLine, getLine(cm.doc, toLine).text.length))
+	    while (newText.length > 1 && oldText.length > 1) {
+	      if (lst(newText) == lst(oldText)) { newText.pop(); oldText.pop(); toLine-- }
+	      else if (newText[0] == oldText[0]) { newText.shift(); oldText.shift(); fromLine++ }
+	      else { break }
+	    }
+
+	    var cutFront = 0, cutEnd = 0
+	    var newTop = newText[0], oldTop = oldText[0], maxCutFront = Math.min(newTop.length, oldTop.length)
+	    while (cutFront < maxCutFront && newTop.charCodeAt(cutFront) == oldTop.charCodeAt(cutFront))
+	      { ++cutFront }
+	    var newBot = lst(newText), oldBot = lst(oldText)
+	    var maxCutEnd = Math.min(newBot.length - (newText.length == 1 ? cutFront : 0),
+	                             oldBot.length - (oldText.length == 1 ? cutFront : 0))
+	    while (cutEnd < maxCutEnd &&
+	           newBot.charCodeAt(newBot.length - cutEnd - 1) == oldBot.charCodeAt(oldBot.length - cutEnd - 1))
+	      { ++cutEnd }
+
+	    newText[newText.length - 1] = newBot.slice(0, newBot.length - cutEnd).replace(/^\u200b+/, "")
+	    newText[0] = newText[0].slice(cutFront).replace(/\u200b+$/, "")
+
+	    var chFrom = Pos(fromLine, cutFront)
+	    var chTo = Pos(toLine, oldText.length ? lst(oldText).length - cutEnd : 0)
+	    if (newText.length > 1 || newText[0] || cmp(chFrom, chTo)) {
+	      replaceRange(cm.doc, newText, chFrom, chTo, "+input")
+	      return true
+	    }
+	  },
+
+	  ensurePolled: function() {
+	    this.forceCompositionEnd()
+	  },
+	  reset: function() {
+	    this.forceCompositionEnd()
+	  },
+	  forceCompositionEnd: function() {
+	    if (!this.composing) { return }
+	    this.composing = null
+	    if (!this.pollContent()) { regChange(this.cm) }
+	    this.div.blur()
+	    this.div.focus()
+	  },
+	  readFromDOMSoon: function() {
+	    var this$1 = this;
+
+	    if (this.readDOMTimeout != null) { return }
+	    this.readDOMTimeout = setTimeout(function () {
+	      this$1.readDOMTimeout = null
+	      if (this$1.composing) { return }
+	      if (this$1.cm.isReadOnly() || !this$1.pollContent())
+	        { runInOp(this$1.cm, function () { return regChange(this$1.cm); }) }
+	    }, 80)
+	  },
+
+	  setUneditable: function(node) {
+	    node.contentEditable = "false"
+	  },
+
+	  onKeyPress: function(e) {
+	    e.preventDefault()
+	    if (!this.cm.isReadOnly())
+	      { operation(this.cm, applyTextInput)(this.cm, String.fromCharCode(e.charCode == null ? e.keyCode : e.charCode), 0) }
+	  },
+
+	  readOnlyChanged: function(val) {
+	    this.div.contentEditable = String(val != "nocursor")
+	  },
+
+	  onContextMenu: nothing,
+	  resetPosition: nothing,
+
+	  needsContentAttribute: true
+	  }, ContentEditableInput.prototype)
+
+	function posToDOM(cm, pos) {
+	  var view = findViewForLine(cm, pos.line)
+	  if (!view || view.hidden) { return null }
+	  var line = getLine(cm.doc, pos.line)
+	  var info = mapFromLineView(view, line, pos.line)
+
+	  var order = getOrder(line), side = "left"
+	  if (order) {
+	    var partPos = getBidiPartAt(order, pos.ch)
+	    side = partPos % 2 ? "right" : "left"
+	  }
+	  var result = nodeAndOffsetInLineMap(info.map, pos.ch, side)
+	  result.offset = result.collapse == "right" ? result.end : result.start
+	  return result
+	}
+
+	function badPos(pos, bad) { if (bad) { pos.bad = true; } return pos }
+
+	function domTextBetween(cm, from, to, fromLine, toLine) {
+	  var text = "", closing = false, lineSep = cm.doc.lineSeparator()
+	  function recognizeMarker(id) { return function (marker) { return marker.id == id; } }
+	  function walk(node) {
+	    if (node.nodeType == 1) {
+	      var cmText = node.getAttribute("cm-text")
+	      if (cmText != null) {
+	        if (cmText == "") { text += node.textContent.replace(/\u200b/g, "") }
+	        else { text += cmText }
+	        return
+	      }
+	      var markerID = node.getAttribute("cm-marker"), range
+	      if (markerID) {
+	        var found = cm.findMarks(Pos(fromLine, 0), Pos(toLine + 1, 0), recognizeMarker(+markerID))
+	        if (found.length && (range = found[0].find()))
+	          { text += getBetween(cm.doc, range.from, range.to).join(lineSep) }
+	        return
+	      }
+	      if (node.getAttribute("contenteditable") == "false") { return }
+	      for (var i = 0; i < node.childNodes.length; i++)
+	        { walk(node.childNodes[i]) }
+	      if (/^(pre|div|p)$/i.test(node.nodeName))
+	        { closing = true }
+	    } else if (node.nodeType == 3) {
+	      var val = node.nodeValue
+	      if (!val) { return }
+	      if (closing) {
+	        text += lineSep
+	        closing = false
+	      }
+	      text += val
+	    }
+	  }
+	  for (;;) {
+	    walk(from)
+	    if (from == to) { break }
+	    from = from.nextSibling
+	  }
+	  return text
+	}
+
+	function domToPos(cm, node, offset) {
+	  var lineNode
+	  if (node == cm.display.lineDiv) {
+	    lineNode = cm.display.lineDiv.childNodes[offset]
+	    if (!lineNode) { return badPos(cm.clipPos(Pos(cm.display.viewTo - 1)), true) }
+	    node = null; offset = 0
+	  } else {
+	    for (lineNode = node;; lineNode = lineNode.parentNode) {
+	      if (!lineNode || lineNode == cm.display.lineDiv) { return null }
+	      if (lineNode.parentNode && lineNode.parentNode == cm.display.lineDiv) { break }
+	    }
+	  }
+	  for (var i = 0; i < cm.display.view.length; i++) {
+	    var lineView = cm.display.view[i]
+	    if (lineView.node == lineNode)
+	      { return locateNodeInLineView(lineView, node, offset) }
+	  }
+	}
+
+	function locateNodeInLineView(lineView, node, offset) {
+	  var wrapper = lineView.text.firstChild, bad = false
+	  if (!node || !contains(wrapper, node)) { return badPos(Pos(lineNo(lineView.line), 0), true) }
+	  if (node == wrapper) {
+	    bad = true
+	    node = wrapper.childNodes[offset]
+	    offset = 0
+	    if (!node) {
+	      var line = lineView.rest ? lst(lineView.rest) : lineView.line
+	      return badPos(Pos(lineNo(line), line.text.length), bad)
+	    }
+	  }
+
+	  var textNode = node.nodeType == 3 ? node : null, topNode = node
+	  if (!textNode && node.childNodes.length == 1 && node.firstChild.nodeType == 3) {
+	    textNode = node.firstChild
+	    if (offset) { offset = textNode.nodeValue.length }
+	  }
+	  while (topNode.parentNode != wrapper) { topNode = topNode.parentNode }
+	  var measure = lineView.measure, maps = measure.maps
+
+	  function find(textNode, topNode, offset) {
+	    for (var i = -1; i < (maps ? maps.length : 0); i++) {
+	      var map = i < 0 ? measure.map : maps[i]
+	      for (var j = 0; j < map.length; j += 3) {
+	        var curNode = map[j + 2]
+	        if (curNode == textNode || curNode == topNode) {
+	          var line = lineNo(i < 0 ? lineView.line : lineView.rest[i])
+	          var ch = map[j] + offset
+	          if (offset < 0 || curNode != textNode) { ch = map[j + (offset ? 1 : 0)] }
+	          return Pos(line, ch)
+	        }
+	      }
+	    }
+	  }
+	  var found = find(textNode, topNode, offset)
+	  if (found) { return badPos(found, bad) }
+
+	  // FIXME this is all really shaky. might handle the few cases it needs to handle, but likely to cause problems
+	  for (var after = topNode.nextSibling, dist = textNode ? textNode.nodeValue.length - offset : 0; after; after = after.nextSibling) {
+	    found = find(after, after.firstChild, 0)
+	    if (found)
+	      { return badPos(Pos(found.line, found.ch - dist), bad) }
+	    else
+	      { dist += after.textContent.length }
+	  }
+	  for (var before = topNode.previousSibling, dist$1 = offset; before; before = before.previousSibling) {
+	    found = find(before, before.firstChild, -1)
+	    if (found)
+	      { return badPos(Pos(found.line, found.ch + dist$1), bad) }
+	    else
+	      { dist$1 += before.textContent.length }
+	  }
+	}
+
+	// TEXTAREA INPUT STYLE
+
+	function TextareaInput(cm) {
+	  this.cm = cm
+	  // See input.poll and input.reset
+	  this.prevInput = ""
+
+	  // Flag that indicates whether we expect input to appear real soon
+	  // now (after some event like 'keypress' or 'input') and are
+	  // polling intensively.
+	  this.pollingFast = false
+	  // Self-resetting timeout for the poller
+	  this.polling = new Delayed()
+	  // Tracks when input.reset has punted to just putting a short
+	  // string into the textarea instead of the full selection.
+	  this.inaccurateSelection = false
+	  // Used to work around IE issue with selection being forgotten when focus moves away from textarea
+	  this.hasSelection = false
+	  this.composing = null
+	}
+
+	TextareaInput.prototype = copyObj({
+	  init: function(display) {
+	    var this$1 = this;
+
+	    var input = this, cm = this.cm
+
+	    // Wraps and hides input textarea
+	    var div = this.wrapper = hiddenTextarea()
+	    // The semihidden textarea that is focused when the editor is
+	    // focused, and receives input.
+	    var te = this.textarea = div.firstChild
+	    display.wrapper.insertBefore(div, display.wrapper.firstChild)
+
+	    // Needed to hide big blue blinking cursor on Mobile Safari (doesn't seem to work in iOS 8 anymore)
+	    if (ios) { te.style.width = "0px" }
+
+	    on(te, "input", function () {
+	      if (ie && ie_version >= 9 && this$1.hasSelection) { this$1.hasSelection = null }
+	      input.poll()
+	    })
+
+	    on(te, "paste", function (e) {
+	      if (signalDOMEvent(cm, e) || handlePaste(e, cm)) { return }
+
+	      cm.state.pasteIncoming = true
+	      input.fastPoll()
+	    })
+
+	    function prepareCopyCut(e) {
+	      if (signalDOMEvent(cm, e)) { return }
+	      if (cm.somethingSelected()) {
+	        setLastCopied({lineWise: false, text: cm.getSelections()})
+	        if (input.inaccurateSelection) {
+	          input.prevInput = ""
+	          input.inaccurateSelection = false
+	          te.value = lastCopied.text.join("\n")
+	          selectInput(te)
+	        }
+	      } else if (!cm.options.lineWiseCopyCut) {
+	        return
+	      } else {
+	        var ranges = copyableRanges(cm)
+	        setLastCopied({lineWise: true, text: ranges.text})
+	        if (e.type == "cut") {
+	          cm.setSelections(ranges.ranges, null, sel_dontScroll)
+	        } else {
+	          input.prevInput = ""
+	          te.value = ranges.text.join("\n")
+	          selectInput(te)
+	        }
+	      }
+	      if (e.type == "cut") { cm.state.cutIncoming = true }
+	    }
+	    on(te, "cut", prepareCopyCut)
+	    on(te, "copy", prepareCopyCut)
+
+	    on(display.scroller, "paste", function (e) {
+	      if (eventInWidget(display, e) || signalDOMEvent(cm, e)) { return }
+	      cm.state.pasteIncoming = true
+	      input.focus()
+	    })
+
+	    // Prevent normal selection in the editor (we handle our own)
+	    on(display.lineSpace, "selectstart", function (e) {
+	      if (!eventInWidget(display, e)) { e_preventDefault(e) }
+	    })
+
+	    on(te, "compositionstart", function () {
+	      var start = cm.getCursor("from")
+	      if (input.composing) { input.composing.range.clear() }
+	      input.composing = {
+	        start: start,
+	        range: cm.markText(start, cm.getCursor("to"), {className: "CodeMirror-composing"})
+	      }
+	    })
+	    on(te, "compositionend", function () {
+	      if (input.composing) {
+	        input.poll()
+	        input.composing.range.clear()
+	        input.composing = null
+	      }
+	    })
+	  },
+
+	  prepareSelection: function() {
+	    // Redraw the selection and/or cursor
+	    var cm = this.cm, display = cm.display, doc = cm.doc
+	    var result = prepareSelection(cm)
+
+	    // Move the hidden textarea near the cursor to prevent scrolling artifacts
+	    if (cm.options.moveInputWithCursor) {
+	      var headPos = cursorCoords(cm, doc.sel.primary().head, "div")
+	      var wrapOff = display.wrapper.getBoundingClientRect(), lineOff = display.lineDiv.getBoundingClientRect()
+	      result.teTop = Math.max(0, Math.min(display.wrapper.clientHeight - 10,
+	                                          headPos.top + lineOff.top - wrapOff.top))
+	      result.teLeft = Math.max(0, Math.min(display.wrapper.clientWidth - 10,
+	                                           headPos.left + lineOff.left - wrapOff.left))
+	    }
+
+	    return result
+	  },
+
+	  showSelection: function(drawn) {
+	    var cm = this.cm, display = cm.display
+	    removeChildrenAndAdd(display.cursorDiv, drawn.cursors)
+	    removeChildrenAndAdd(display.selectionDiv, drawn.selection)
+	    if (drawn.teTop != null) {
+	      this.wrapper.style.top = drawn.teTop + "px"
+	      this.wrapper.style.left = drawn.teLeft + "px"
+	    }
+	  },
+
+	  // Reset the input to correspond to the selection (or to be empty,
+	  // when not typing and nothing is selected)
+	  reset: function(typing) {
+	    if (this.contextMenuPending) { return }
+	    var minimal, selected, cm = this.cm, doc = cm.doc
+	    if (cm.somethingSelected()) {
+	      this.prevInput = ""
+	      var range = doc.sel.primary()
+	      minimal = hasCopyEvent &&
+	        (range.to().line - range.from().line > 100 || (selected = cm.getSelection()).length > 1000)
+	      var content = minimal ? "-" : selected || cm.getSelection()
+	      this.textarea.value = content
+	      if (cm.state.focused) { selectInput(this.textarea) }
+	      if (ie && ie_version >= 9) { this.hasSelection = content }
+	    } else if (!typing) {
+	      this.prevInput = this.textarea.value = ""
+	      if (ie && ie_version >= 9) { this.hasSelection = null }
+	    }
+	    this.inaccurateSelection = minimal
+	  },
+
+	  getField: function() { return this.textarea },
+
+	  supportsTouch: function() { return false },
+
+	  focus: function() {
+	    if (this.cm.options.readOnly != "nocursor" && (!mobile || activeElt() != this.textarea)) {
+	      try { this.textarea.focus() }
+	      catch (e) {} // IE8 will throw if the textarea is display: none or not in DOM
+	    }
+	  },
+
+	  blur: function() { this.textarea.blur() },
+
+	  resetPosition: function() {
+	    this.wrapper.style.top = this.wrapper.style.left = 0
+	  },
+
+	  receivedFocus: function() { this.slowPoll() },
+
+	  // Poll for input changes, using the normal rate of polling. This
+	  // runs as long as the editor is focused.
+	  slowPoll: function() {
+	    var this$1 = this;
+
+	    if (this.pollingFast) { return }
+	    this.polling.set(this.cm.options.pollInterval, function () {
+	      this$1.poll()
+	      if (this$1.cm.state.focused) { this$1.slowPoll() }
+	    })
+	  },
+
+	  // When an event has just come in that is likely to add or change
+	  // something in the input textarea, we poll faster, to ensure that
+	  // the change appears on the screen quickly.
+	  fastPoll: function() {
+	    var missed = false, input = this
+	    input.pollingFast = true
+	    function p() {
+	      var changed = input.poll()
+	      if (!changed && !missed) {missed = true; input.polling.set(60, p)}
+	      else {input.pollingFast = false; input.slowPoll()}
+	    }
+	    input.polling.set(20, p)
+	  },
+
+	  // Read input from the textarea, and update the document to match.
+	  // When something is selected, it is present in the textarea, and
+	  // selected (unless it is huge, in which case a placeholder is
+	  // used). When nothing is selected, the cursor sits after previously
+	  // seen text (can be empty), which is stored in prevInput (we must
+	  // not reset the textarea when typing, because that breaks IME).
+	  poll: function() {
+	    var this$1 = this;
+
+	    var cm = this.cm, input = this.textarea, prevInput = this.prevInput
+	    // Since this is called a *lot*, try to bail out as cheaply as
+	    // possible when it is clear that nothing happened. hasSelection
+	    // will be the case when there is a lot of text in the textarea,
+	    // in which case reading its value would be expensive.
+	    if (this.contextMenuPending || !cm.state.focused ||
+	        (hasSelection(input) && !prevInput && !this.composing) ||
+	        cm.isReadOnly() || cm.options.disableInput || cm.state.keySeq)
+	      { return false }
+
+	    var text = input.value
+	    // If nothing changed, bail.
+	    if (text == prevInput && !cm.somethingSelected()) { return false }
+	    // Work around nonsensical selection resetting in IE9/10, and
+	    // inexplicable appearance of private area unicode characters on
+	    // some key combos in Mac (#2689).
+	    if (ie && ie_version >= 9 && this.hasSelection === text ||
+	        mac && /[\uf700-\uf7ff]/.test(text)) {
+	      cm.display.input.reset()
+	      return false
+	    }
+
+	    if (cm.doc.sel == cm.display.selForContextMenu) {
+	      var first = text.charCodeAt(0)
+	      if (first == 0x200b && !prevInput) { prevInput = "\u200b" }
+	      if (first == 0x21da) { this.reset(); return this.cm.execCommand("undo") }
+	    }
+	    // Find the part of the input that is actually new
+	    var same = 0, l = Math.min(prevInput.length, text.length)
+	    while (same < l && prevInput.charCodeAt(same) == text.charCodeAt(same)) { ++same }
+
+	    runInOp(cm, function () {
+	      applyTextInput(cm, text.slice(same), prevInput.length - same,
+	                     null, this$1.composing ? "*compose" : null)
+
+	      // Don't leave long text in the textarea, since it makes further polling slow
+	      if (text.length > 1000 || text.indexOf("\n") > -1) { input.value = this$1.prevInput = "" }
+	      else { this$1.prevInput = text }
+
+	      if (this$1.composing) {
+	        this$1.composing.range.clear()
+	        this$1.composing.range = cm.markText(this$1.composing.start, cm.getCursor("to"),
+	                                           {className: "CodeMirror-composing"})
+	      }
+	    })
+	    return true
+	  },
+
+	  ensurePolled: function() {
+	    if (this.pollingFast && this.poll()) { this.pollingFast = false }
+	  },
+
+	  onKeyPress: function() {
+	    if (ie && ie_version >= 9) { this.hasSelection = null }
+	    this.fastPoll()
+	  },
+
+	  onContextMenu: function(e) {
+	    var input = this, cm = input.cm, display = cm.display, te = input.textarea
+	    var pos = posFromMouse(cm, e), scrollPos = display.scroller.scrollTop
+	    if (!pos || presto) { return } // Opera is difficult.
+
+	    // Reset the current text selection only if the click is done outside of the selection
+	    // and 'resetSelectionOnContextMenu' option is true.
+	    var reset = cm.options.resetSelectionOnContextMenu
+	    if (reset && cm.doc.sel.contains(pos) == -1)
+	      { operation(cm, setSelection)(cm.doc, simpleSelection(pos), sel_dontScroll) }
+
+	    var oldCSS = te.style.cssText, oldWrapperCSS = input.wrapper.style.cssText
+	    input.wrapper.style.cssText = "position: absolute"
+	    var wrapperBox = input.wrapper.getBoundingClientRect()
+	    te.style.cssText = "position: absolute; width: 30px; height: 30px;\n      top: " + (e.clientY - wrapperBox.top - 5) + "px; left: " + (e.clientX - wrapperBox.left - 5) + "px;\n      z-index: 1000; background: " + (ie ? "rgba(255, 255, 255, .05)" : "transparent") + ";\n      outline: none; border-width: 0; outline: none; overflow: hidden; opacity: .05; filter: alpha(opacity=5);"
+	    var oldScrollY
+	    if (webkit) { oldScrollY = window.scrollY } // Work around Chrome issue (#2712)
+	    display.input.focus()
+	    if (webkit) { window.scrollTo(null, oldScrollY) }
+	    display.input.reset()
+	    // Adds "Select all" to context menu in FF
+	    if (!cm.somethingSelected()) { te.value = input.prevInput = " " }
+	    input.contextMenuPending = true
+	    display.selForContextMenu = cm.doc.sel
+	    clearTimeout(display.detectingSelectAll)
+
+	    // Select-all will be greyed out if there's nothing to select, so
+	    // this adds a zero-width space so that we can later check whether
+	    // it got selected.
+	    function prepareSelectAllHack() {
+	      if (te.selectionStart != null) {
+	        var selected = cm.somethingSelected()
+	        var extval = "\u200b" + (selected ? te.value : "")
+	        te.value = "\u21da" // Used to catch context-menu undo
+	        te.value = extval
+	        input.prevInput = selected ? "" : "\u200b"
+	        te.selectionStart = 1; te.selectionEnd = extval.length
+	        // Re-set this, in case some other handler touched the
+	        // selection in the meantime.
+	        display.selForContextMenu = cm.doc.sel
+	      }
+	    }
+	    function rehide() {
+	      input.contextMenuPending = false
+	      input.wrapper.style.cssText = oldWrapperCSS
+	      te.style.cssText = oldCSS
+	      if (ie && ie_version < 9) { display.scrollbars.setScrollTop(display.scroller.scrollTop = scrollPos) }
+
+	      // Try to detect the user choosing select-all
+	      if (te.selectionStart != null) {
+	        if (!ie || (ie && ie_version < 9)) { prepareSelectAllHack() }
+	        var i = 0, poll = function () {
+	          if (display.selForContextMenu == cm.doc.sel && te.selectionStart == 0 &&
+	              te.selectionEnd > 0 && input.prevInput == "\u200b")
+	            { operation(cm, selectAll)(cm) }
+	          else if (i++ < 10) { display.detectingSelectAll = setTimeout(poll, 500) }
+	          else { display.input.reset() }
+	        }
+	        display.detectingSelectAll = setTimeout(poll, 200)
+	      }
+	    }
+
+	    if (ie && ie_version >= 9) { prepareSelectAllHack() }
+	    if (captureRightClick) {
+	      e_stop(e)
+	      var mouseup = function () {
+	        off(window, "mouseup", mouseup)
+	        setTimeout(rehide, 20)
+	      }
+	      on(window, "mouseup", mouseup)
+	    } else {
+	      setTimeout(rehide, 50)
+	    }
+	  },
+
+	  readOnlyChanged: function(val) {
+	    if (!val) { this.reset() }
+	  },
+
+	  setUneditable: nothing,
+
+	  needsContentAttribute: false
+	}, TextareaInput.prototype)
+
+	function fromTextArea(textarea, options) {
+	  options = options ? copyObj(options) : {}
+	  options.value = textarea.value
+	  if (!options.tabindex && textarea.tabIndex)
+	    { options.tabindex = textarea.tabIndex }
+	  if (!options.placeholder && textarea.placeholder)
+	    { options.placeholder = textarea.placeholder }
+	  // Set autofocus to true if this textarea is focused, or if it has
+	  // autofocus and no other element is focused.
+	  if (options.autofocus == null) {
+	    var hasFocus = activeElt()
+	    options.autofocus = hasFocus == textarea ||
+	      textarea.getAttribute("autofocus") != null && hasFocus == document.body
+	  }
+
+	  function save() {textarea.value = cm.getValue()}
+
+	  var realSubmit
+	  if (textarea.form) {
+	    on(textarea.form, "submit", save)
+	    // Deplorable hack to make the submit method do the right thing.
+	    if (!options.leaveSubmitMethodAlone) {
+	      var form = textarea.form
+	      realSubmit = form.submit
+	      try {
+	        var wrappedSubmit = form.submit = function () {
+	          save()
+	          form.submit = realSubmit
+	          form.submit()
+	          form.submit = wrappedSubmit
+	        }
+	      } catch(e) {}
+	    }
+	  }
+
+	  options.finishInit = function (cm) {
+	    cm.save = save
+	    cm.getTextArea = function () { return textarea; }
+	    cm.toTextArea = function () {
+	      cm.toTextArea = isNaN // Prevent this from being ran twice
+	      save()
+	      textarea.parentNode.removeChild(cm.getWrapperElement())
+	      textarea.style.display = ""
+	      if (textarea.form) {
+	        off(textarea.form, "submit", save)
+	        if (typeof textarea.form.submit == "function")
+	          { textarea.form.submit = realSubmit }
+	      }
+	    }
+	  }
+
+	  textarea.style.display = "none"
+	  var cm = CodeMirror(function (node) { return textarea.parentNode.insertBefore(node, textarea.nextSibling); },
+	    options)
+	  return cm
+	}
+
+	function addLegacyProps(CodeMirror) {
+	  CodeMirror.off = off
+	  CodeMirror.on = on
+	  CodeMirror.wheelEventPixels = wheelEventPixels
+	  CodeMirror.Doc = Doc
+	  CodeMirror.splitLines = splitLinesAuto
+	  CodeMirror.countColumn = countColumn
+	  CodeMirror.findColumn = findColumn
+	  CodeMirror.isWordChar = isWordCharBasic
+	  CodeMirror.Pass = Pass
+	  CodeMirror.signal = signal
+	  CodeMirror.Line = Line
+	  CodeMirror.changeEnd = changeEnd
+	  CodeMirror.scrollbarModel = scrollbarModel
+	  CodeMirror.Pos = Pos
+	  CodeMirror.cmpPos = cmp
+	  CodeMirror.modes = modes
+	  CodeMirror.mimeModes = mimeModes
+	  CodeMirror.resolveMode = resolveMode
+	  CodeMirror.getMode = getMode
+	  CodeMirror.modeExtensions = modeExtensions
+	  CodeMirror.extendMode = extendMode
+	  CodeMirror.copyState = copyState
+	  CodeMirror.startState = startState
+	  CodeMirror.innerMode = innerMode
+	  CodeMirror.commands = commands
+	  CodeMirror.keyMap = keyMap
+	  CodeMirror.keyName = keyName
+	  CodeMirror.isModifierKey = isModifierKey
+	  CodeMirror.lookupKey = lookupKey
+	  CodeMirror.normalizeKeyMap = normalizeKeyMap
+	  CodeMirror.StringStream = StringStream
+	  CodeMirror.SharedTextMarker = SharedTextMarker
+	  CodeMirror.TextMarker = TextMarker
+	  CodeMirror.LineWidget = LineWidget
+	  CodeMirror.e_preventDefault = e_preventDefault
+	  CodeMirror.e_stopPropagation = e_stopPropagation
+	  CodeMirror.e_stop = e_stop
+	  CodeMirror.addClass = addClass
+	  CodeMirror.contains = contains
+	  CodeMirror.rmClass = rmClass
+	  CodeMirror.keyNames = keyNames
+	}
+
+	// EDITOR CONSTRUCTOR
+
+	defineOptions(CodeMirror)
+
+	addEditorMethods(CodeMirror)
+
+	// Set up methods on CodeMirror's prototype to redirect to the editor's document.
+	var dontDelegate = "iter insert remove copy getEditor constructor".split(" ")
+	for (var prop in Doc.prototype) { if (Doc.prototype.hasOwnProperty(prop) && indexOf(dontDelegate, prop) < 0)
+	  { CodeMirror.prototype[prop] = (function(method) {
+	    return function() {return method.apply(this.doc, arguments)}
+	  })(Doc.prototype[prop]) } }
+
+	eventMixin(Doc)
+
+	// INPUT HANDLING
+
+	CodeMirror.inputStyles = {"textarea": TextareaInput, "contenteditable": ContentEditableInput}
+
+	// MODE DEFINITION AND QUERYING
+
+	// Extra arguments are stored as the mode's dependencies, which is
+	// used by (legacy) mechanisms like loadmode.js to automatically
+	// load a mode. (Preferred mechanism is the require/define calls.)
+	CodeMirror.defineMode = function(name/*, mode, …*/) {
+	  if (!CodeMirror.defaults.mode && name != "null") { CodeMirror.defaults.mode = name }
+	  defineMode.apply(this, arguments)
+	}
+
+	CodeMirror.defineMIME = defineMIME
+
+	// Minimal default mode.
+	CodeMirror.defineMode("null", function () { return ({token: function (stream) { return stream.skipToEnd(); }}); })
+	CodeMirror.defineMIME("text/plain", "null")
+
+	// EXTENSIONS
+
+	CodeMirror.defineExtension = function (name, func) {
+	  CodeMirror.prototype[name] = func
+	}
+	CodeMirror.defineDocExtension = function (name, func) {
+	  Doc.prototype[name] = func
+	}
+
+	CodeMirror.fromTextArea = fromTextArea
+
+	addLegacyProps(CodeMirror)
+
+	CodeMirror.version = "5.21.0"
+
+	return CodeMirror;
+
+	})));
+
+/***/ },
+/* 268 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// CodeMirror, copyright (c) by Marijn Haverbeke and others
+	// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+	(function(mod) {
+	  if (true) // CommonJS
+	    mod(__webpack_require__(267));
+	  else if (typeof define == "function" && define.amd) // AMD
+	    define(["../../lib/codemirror"], mod);
+	  else // Plain browser env
+	    mod(CodeMirror);
+	})(function(CodeMirror) {
+	  "use strict";
+
+	  var HINT_ELEMENT_CLASS        = "CodeMirror-hint";
+	  var ACTIVE_HINT_ELEMENT_CLASS = "CodeMirror-hint-active";
+
+	  // This is the old interface, kept around for now to stay
+	  // backwards-compatible.
+	  CodeMirror.showHint = function(cm, getHints, options) {
+	    if (!getHints) return cm.showHint(options);
+	    if (options && options.async) getHints.async = true;
+	    var newOpts = {hint: getHints};
+	    if (options) for (var prop in options) newOpts[prop] = options[prop];
+	    return cm.showHint(newOpts);
+	  };
+
+	  CodeMirror.defineExtension("showHint", function(options) {
+	    options = parseOptions(this, this.getCursor("start"), options);
+	    var selections = this.listSelections()
+	    if (selections.length > 1) return;
+	    // By default, don't allow completion when something is selected.
+	    // A hint function can have a `supportsSelection` property to
+	    // indicate that it can handle selections.
+	    if (this.somethingSelected()) {
+	      if (!options.hint.supportsSelection) return;
+	      // Don't try with cross-line selections
+	      for (var i = 0; i < selections.length; i++)
+	        if (selections[i].head.line != selections[i].anchor.line) return;
+	    }
+
+	    if (this.state.completionActive) this.state.completionActive.close();
+	    var completion = this.state.completionActive = new Completion(this, options);
+	    if (!completion.options.hint) return;
+
+	    CodeMirror.signal(this, "startCompletion", this);
+	    completion.update(true);
+	  });
+
+	  function Completion(cm, options) {
+	    this.cm = cm;
+	    this.options = options;
+	    this.widget = null;
+	    this.debounce = 0;
+	    this.tick = 0;
+	    this.startPos = this.cm.getCursor("start");
+	    this.startLen = this.cm.getLine(this.startPos.line).length - this.cm.getSelection().length;
+
+	    var self = this;
+	    cm.on("cursorActivity", this.activityFunc = function() { self.cursorActivity(); });
+	  }
+
+	  var requestAnimationFrame = window.requestAnimationFrame || function(fn) {
+	    return setTimeout(fn, 1000/60);
+	  };
+	  var cancelAnimationFrame = window.cancelAnimationFrame || clearTimeout;
+
+	  Completion.prototype = {
+	    close: function() {
+	      if (!this.active()) return;
+	      this.cm.state.completionActive = null;
+	      this.tick = null;
+	      this.cm.off("cursorActivity", this.activityFunc);
+
+	      if (this.widget && this.data) CodeMirror.signal(this.data, "close");
+	      if (this.widget) this.widget.close();
+	      CodeMirror.signal(this.cm, "endCompletion", this.cm);
+	    },
+
+	    active: function() {
+	      return this.cm.state.completionActive == this;
+	    },
+
+	    pick: function(data, i) {
+	      var completion = data.list[i];
+	      if (completion.hint) completion.hint(this.cm, data, completion);
+	      else this.cm.replaceRange(getText(completion), completion.from || data.from,
+	                                completion.to || data.to, "complete");
+	      CodeMirror.signal(data, "pick", completion);
+	      this.close();
+	    },
+
+	    cursorActivity: function() {
+	      if (this.debounce) {
+	        cancelAnimationFrame(this.debounce);
+	        this.debounce = 0;
+	      }
+
+	      var pos = this.cm.getCursor(), line = this.cm.getLine(pos.line);
+	      if (pos.line != this.startPos.line || line.length - pos.ch != this.startLen - this.startPos.ch ||
+	          pos.ch < this.startPos.ch || this.cm.somethingSelected() ||
+	          (pos.ch && this.options.closeCharacters.test(line.charAt(pos.ch - 1)))) {
+	        this.close();
+	      } else {
+	        var self = this;
+	        this.debounce = requestAnimationFrame(function() {self.update();});
+	        if (this.widget) this.widget.disable();
+	      }
+	    },
+
+	    update: function(first) {
+	      if (this.tick == null) return
+	      var self = this, myTick = ++this.tick
+	      fetchHints(this.options.hint, this.cm, this.options, function(data) {
+	        if (self.tick == myTick) self.finishUpdate(data, first)
+	      })
+	    },
+
+	    finishUpdate: function(data, first) {
+	      if (this.data) CodeMirror.signal(this.data, "update");
+
+	      var picked = (this.widget && this.widget.picked) || (first && this.options.completeSingle);
+	      if (this.widget) this.widget.close();
+
+	      if (data && this.data && isNewCompletion(this.data, data)) return;
+	      this.data = data;
+
+	      if (data && data.list.length) {
+	        if (picked && data.list.length == 1) {
+	          this.pick(data, 0);
+	        } else {
+	          this.widget = new Widget(this, data);
+	          CodeMirror.signal(data, "shown");
+	        }
+	      }
+	    }
+	  };
+
+	  function isNewCompletion(old, nw) {
+	    var moved = CodeMirror.cmpPos(nw.from, old.from)
+	    return moved > 0 && old.to.ch - old.from.ch != nw.to.ch - nw.from.ch
+	  }
+
+	  function parseOptions(cm, pos, options) {
+	    var editor = cm.options.hintOptions;
+	    var out = {};
+	    for (var prop in defaultOptions) out[prop] = defaultOptions[prop];
+	    if (editor) for (var prop in editor)
+	      if (editor[prop] !== undefined) out[prop] = editor[prop];
+	    if (options) for (var prop in options)
+	      if (options[prop] !== undefined) out[prop] = options[prop];
+	    if (out.hint.resolve) out.hint = out.hint.resolve(cm, pos)
+	    return out;
+	  }
+
+	  function getText(completion) {
+	    if (typeof completion == "string") return completion;
+	    else return completion.text;
+	  }
+
+	  function buildKeyMap(completion, handle) {
+	    var baseMap = {
+	      Up: function() {handle.moveFocus(-1);},
+	      Down: function() {handle.moveFocus(1);},
+	      PageUp: function() {handle.moveFocus(-handle.menuSize() + 1, true);},
+	      PageDown: function() {handle.moveFocus(handle.menuSize() - 1, true);},
+	      Home: function() {handle.setFocus(0);},
+	      End: function() {handle.setFocus(handle.length - 1);},
+	      Enter: handle.pick,
+	      Tab: handle.pick,
+	      Esc: handle.close
+	    };
+	    var custom = completion.options.customKeys;
+	    var ourMap = custom ? {} : baseMap;
+	    function addBinding(key, val) {
+	      var bound;
+	      if (typeof val != "string")
+	        bound = function(cm) { return val(cm, handle); };
+	      // This mechanism is deprecated
+	      else if (baseMap.hasOwnProperty(val))
+	        bound = baseMap[val];
+	      else
+	        bound = val;
+	      ourMap[key] = bound;
+	    }
+	    if (custom)
+	      for (var key in custom) if (custom.hasOwnProperty(key))
+	        addBinding(key, custom[key]);
+	    var extra = completion.options.extraKeys;
+	    if (extra)
+	      for (var key in extra) if (extra.hasOwnProperty(key))
+	        addBinding(key, extra[key]);
+	    return ourMap;
+	  }
+
+	  function getHintElement(hintsElement, el) {
+	    while (el && el != hintsElement) {
+	      if (el.nodeName.toUpperCase() === "LI" && el.parentNode == hintsElement) return el;
+	      el = el.parentNode;
+	    }
+	  }
+
+	  function Widget(completion, data) {
+	    this.completion = completion;
+	    this.data = data;
+	    this.picked = false;
+	    var widget = this, cm = completion.cm;
+
+	    var hints = this.hints = document.createElement("ul");
+	    hints.className = "CodeMirror-hints";
+	    this.selectedHint = data.selectedHint || 0;
+
+	    var completions = data.list;
+	    for (var i = 0; i < completions.length; ++i) {
+	      var elt = hints.appendChild(document.createElement("li")), cur = completions[i];
+	      var className = HINT_ELEMENT_CLASS + (i != this.selectedHint ? "" : " " + ACTIVE_HINT_ELEMENT_CLASS);
+	      if (cur.className != null) className = cur.className + " " + className;
+	      elt.className = className;
+	      if (cur.render) cur.render(elt, data, cur);
+	      else elt.appendChild(document.createTextNode(cur.displayText || getText(cur)));
+	      elt.hintId = i;
+	    }
+
+	    var pos = cm.cursorCoords(completion.options.alignWithWord ? data.from : null);
+	    var left = pos.left, top = pos.bottom, below = true;
+	    hints.style.left = left + "px";
+	    hints.style.top = top + "px";
+	    // If we're at the edge of the screen, then we want the menu to appear on the left of the cursor.
+	    var winW = window.innerWidth || Math.max(document.body.offsetWidth, document.documentElement.offsetWidth);
+	    var winH = window.innerHeight || Math.max(document.body.offsetHeight, document.documentElement.offsetHeight);
+	    (completion.options.container || document.body).appendChild(hints);
+	    var box = hints.getBoundingClientRect(), overlapY = box.bottom - winH;
+	    var scrolls = hints.scrollHeight > hints.clientHeight + 1
+	    var startScroll = cm.getScrollInfo();
+
+	    if (overlapY > 0) {
+	      var height = box.bottom - box.top, curTop = pos.top - (pos.bottom - box.top);
+	      if (curTop - height > 0) { // Fits above cursor
+	        hints.style.top = (top = pos.top - height) + "px";
+	        below = false;
+	      } else if (height > winH) {
+	        hints.style.height = (winH - 5) + "px";
+	        hints.style.top = (top = pos.bottom - box.top) + "px";
+	        var cursor = cm.getCursor();
+	        if (data.from.ch != cursor.ch) {
+	          pos = cm.cursorCoords(cursor);
+	          hints.style.left = (left = pos.left) + "px";
+	          box = hints.getBoundingClientRect();
+	        }
+	      }
+	    }
+	    var overlapX = box.right - winW;
+	    if (overlapX > 0) {
+	      if (box.right - box.left > winW) {
+	        hints.style.width = (winW - 5) + "px";
+	        overlapX -= (box.right - box.left) - winW;
+	      }
+	      hints.style.left = (left = pos.left - overlapX) + "px";
+	    }
+	    if (scrolls) for (var node = hints.firstChild; node; node = node.nextSibling)
+	      node.style.paddingRight = cm.display.nativeBarWidth + "px"
+
+	    cm.addKeyMap(this.keyMap = buildKeyMap(completion, {
+	      moveFocus: function(n, avoidWrap) { widget.changeActive(widget.selectedHint + n, avoidWrap); },
+	      setFocus: function(n) { widget.changeActive(n); },
+	      menuSize: function() { return widget.screenAmount(); },
+	      length: completions.length,
+	      close: function() { completion.close(); },
+	      pick: function() { widget.pick(); },
+	      data: data
+	    }));
+
+	    if (completion.options.closeOnUnfocus) {
+	      var closingOnBlur;
+	      cm.on("blur", this.onBlur = function() { closingOnBlur = setTimeout(function() { completion.close(); }, 100); });
+	      cm.on("focus", this.onFocus = function() { clearTimeout(closingOnBlur); });
+	    }
+
+	    cm.on("scroll", this.onScroll = function() {
+	      var curScroll = cm.getScrollInfo(), editor = cm.getWrapperElement().getBoundingClientRect();
+	      var newTop = top + startScroll.top - curScroll.top;
+	      var point = newTop - (window.pageYOffset || (document.documentElement || document.body).scrollTop);
+	      if (!below) point += hints.offsetHeight;
+	      if (point <= editor.top || point >= editor.bottom) return completion.close();
+	      hints.style.top = newTop + "px";
+	      hints.style.left = (left + startScroll.left - curScroll.left) + "px";
+	    });
+
+	    CodeMirror.on(hints, "dblclick", function(e) {
+	      var t = getHintElement(hints, e.target || e.srcElement);
+	      if (t && t.hintId != null) {widget.changeActive(t.hintId); widget.pick();}
+	    });
+
+	    CodeMirror.on(hints, "click", function(e) {
+	      var t = getHintElement(hints, e.target || e.srcElement);
+	      if (t && t.hintId != null) {
+	        widget.changeActive(t.hintId);
+	        if (completion.options.completeOnSingleClick) widget.pick();
+	      }
+	    });
+
+	    CodeMirror.on(hints, "mousedown", function() {
+	      setTimeout(function(){cm.focus();}, 20);
+	    });
+
+	    CodeMirror.signal(data, "select", completions[0], hints.firstChild);
+	    return true;
+	  }
+
+	  Widget.prototype = {
+	    close: function() {
+	      if (this.completion.widget != this) return;
+	      this.completion.widget = null;
+	      this.hints.parentNode.removeChild(this.hints);
+	      this.completion.cm.removeKeyMap(this.keyMap);
+
+	      var cm = this.completion.cm;
+	      if (this.completion.options.closeOnUnfocus) {
+	        cm.off("blur", this.onBlur);
+	        cm.off("focus", this.onFocus);
+	      }
+	      cm.off("scroll", this.onScroll);
+	    },
+
+	    disable: function() {
+	      this.completion.cm.removeKeyMap(this.keyMap);
+	      var widget = this;
+	      this.keyMap = {Enter: function() { widget.picked = true; }};
+	      this.completion.cm.addKeyMap(this.keyMap);
+	    },
+
+	    pick: function() {
+	      this.completion.pick(this.data, this.selectedHint);
+	    },
+
+	    changeActive: function(i, avoidWrap) {
+	      if (i >= this.data.list.length)
+	        i = avoidWrap ? this.data.list.length - 1 : 0;
+	      else if (i < 0)
+	        i = avoidWrap ? 0  : this.data.list.length - 1;
+	      if (this.selectedHint == i) return;
+	      var node = this.hints.childNodes[this.selectedHint];
+	      node.className = node.className.replace(" " + ACTIVE_HINT_ELEMENT_CLASS, "");
+	      node = this.hints.childNodes[this.selectedHint = i];
+	      node.className += " " + ACTIVE_HINT_ELEMENT_CLASS;
+	      if (node.offsetTop < this.hints.scrollTop)
+	        this.hints.scrollTop = node.offsetTop - 3;
+	      else if (node.offsetTop + node.offsetHeight > this.hints.scrollTop + this.hints.clientHeight)
+	        this.hints.scrollTop = node.offsetTop + node.offsetHeight - this.hints.clientHeight + 3;
+	      CodeMirror.signal(this.data, "select", this.data.list[this.selectedHint], node);
+	    },
+
+	    screenAmount: function() {
+	      return Math.floor(this.hints.clientHeight / this.hints.firstChild.offsetHeight) || 1;
+	    }
+	  };
+
+	  function applicableHelpers(cm, helpers) {
+	    if (!cm.somethingSelected()) return helpers
+	    var result = []
+	    for (var i = 0; i < helpers.length; i++)
+	      if (helpers[i].supportsSelection) result.push(helpers[i])
+	    return result
+	  }
+
+	  function fetchHints(hint, cm, options, callback) {
+	    if (hint.async) {
+	      hint(cm, callback, options)
+	    } else {
+	      var result = hint(cm, options)
+	      if (result && result.then) result.then(callback)
+	      else callback(result)
+	    }
+	  }
+
+	  function resolveAutoHints(cm, pos) {
+	    var helpers = cm.getHelpers(pos, "hint"), words
+	    if (helpers.length) {
+	      var resolved = function(cm, callback, options) {
+	        var app = applicableHelpers(cm, helpers);
+	        function run(i) {
+	          if (i == app.length) return callback(null)
+	          fetchHints(app[i], cm, options, function(result) {
+	            if (result && result.list.length > 0) callback(result)
+	            else run(i + 1)
+	          })
+	        }
+	        run(0)
+	      }
+	      resolved.async = true
+	      resolved.supportsSelection = true
+	      return resolved
+	    } else if (words = cm.getHelper(cm.getCursor(), "hintWords")) {
+	      return function(cm) { return CodeMirror.hint.fromList(cm, {words: words}) }
+	    } else if (CodeMirror.hint.anyword) {
+	      return function(cm, options) { return CodeMirror.hint.anyword(cm, options) }
+	    } else {
+	      return function() {}
+	    }
+	  }
+
+	  CodeMirror.registerHelper("hint", "auto", {
+	    resolve: resolveAutoHints
+	  });
+
+	  CodeMirror.registerHelper("hint", "fromList", function(cm, options) {
+	    var cur = cm.getCursor(), token = cm.getTokenAt(cur);
+	    var to = CodeMirror.Pos(cur.line, token.end);
+	    if (token.string && /\w/.test(token.string[token.string.length - 1])) {
+	      var term = token.string, from = CodeMirror.Pos(cur.line, token.start);
+	    } else {
+	      var term = "", from = to;
+	    }
+	    var found = [];
+	    for (var i = 0; i < options.words.length; i++) {
+	      var word = options.words[i];
+	      if (word.slice(0, term.length) == term)
+	        found.push(word);
+	    }
+
+	    if (found.length) return {list: found, from: from, to: to};
+	  });
+
+	  CodeMirror.commands.autocomplete = CodeMirror.showHint;
+
+	  var defaultOptions = {
+	    hint: CodeMirror.hint.auto,
+	    completeSingle: true,
+	    alignWithWord: true,
+	    closeCharacters: /[\s()\[\]{};:>,]/,
+	    closeOnUnfocus: true,
+	    completeOnSingleClick: true,
+	    container: null,
+	    customKeys: null,
+	    extraKeys: null
+	  };
+
+	  CodeMirror.defineOption("hintOptions", null);
+	});
+
+
+/***/ },
+/* 269 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// CodeMirror, copyright (c) by Marijn Haverbeke and others
+	// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+	(function(mod) {
+	  if (true) // CommonJS
+	    mod(__webpack_require__(267));
+	  else if (typeof define == "function" && define.amd) // AMD
+	    define(["../../lib/codemirror"], mod);
+	  else // Plain browser env
+	    mod(CodeMirror);
+	})(function(CodeMirror) {
+	  "use strict";
+
+	  var noOptions = {};
+	  var nonWS = /[^\s\u00a0]/;
+	  var Pos = CodeMirror.Pos;
+
+	  function firstNonWS(str) {
+	    var found = str.search(nonWS);
+	    return found == -1 ? 0 : found;
+	  }
+
+	  CodeMirror.commands.toggleComment = function(cm) {
+	    cm.toggleComment();
+	  };
+
+	  CodeMirror.defineExtension("toggleComment", function(options) {
+	    if (!options) options = noOptions;
+	    var cm = this;
+	    var minLine = Infinity, ranges = this.listSelections(), mode = null;
+	    for (var i = ranges.length - 1; i >= 0; i--) {
+	      var from = ranges[i].from(), to = ranges[i].to();
+	      if (from.line >= minLine) continue;
+	      if (to.line >= minLine) to = Pos(minLine, 0);
+	      minLine = from.line;
+	      if (mode == null) {
+	        if (cm.uncomment(from, to, options)) mode = "un";
+	        else { cm.lineComment(from, to, options); mode = "line"; }
+	      } else if (mode == "un") {
+	        cm.uncomment(from, to, options);
+	      } else {
+	        cm.lineComment(from, to, options);
+	      }
+	    }
+	  });
+
+	  // Rough heuristic to try and detect lines that are part of multi-line string
+	  function probablyInsideString(cm, pos, line) {
+	    return /\bstring\b/.test(cm.getTokenTypeAt(Pos(pos.line, 0))) && !/^[\'\"`]/.test(line)
+	  }
+
+	  CodeMirror.defineExtension("lineComment", function(from, to, options) {
+	    if (!options) options = noOptions;
+	    var self = this, mode = self.getModeAt(from);
+	    var firstLine = self.getLine(from.line);
+	    if (firstLine == null || probablyInsideString(self, from, firstLine)) return;
+
+	    var commentString = options.lineComment || mode.lineComment;
+	    if (!commentString) {
+	      if (options.blockCommentStart || mode.blockCommentStart) {
+	        options.fullLines = true;
+	        self.blockComment(from, to, options);
+	      }
+	      return;
+	    }
+
+	    var end = Math.min(to.ch != 0 || to.line == from.line ? to.line + 1 : to.line, self.lastLine() + 1);
+	    var pad = options.padding == null ? " " : options.padding;
+	    var blankLines = options.commentBlankLines || from.line == to.line;
+
+	    self.operation(function() {
+	      if (options.indent) {
+	        var baseString = null;
+	        for (var i = from.line; i < end; ++i) {
+	          var line = self.getLine(i);
+	          var whitespace = line.slice(0, firstNonWS(line));
+	          if (baseString == null || baseString.length > whitespace.length) {
+	            baseString = whitespace;
+	          }
+	        }
+	        for (var i = from.line; i < end; ++i) {
+	          var line = self.getLine(i), cut = baseString.length;
+	          if (!blankLines && !nonWS.test(line)) continue;
+	          if (line.slice(0, cut) != baseString) cut = firstNonWS(line);
+	          self.replaceRange(baseString + commentString + pad, Pos(i, 0), Pos(i, cut));
+	        }
+	      } else {
+	        for (var i = from.line; i < end; ++i) {
+	          if (blankLines || nonWS.test(self.getLine(i)))
+	            self.replaceRange(commentString + pad, Pos(i, 0));
+	        }
+	      }
+	    });
+	  });
+
+	  CodeMirror.defineExtension("blockComment", function(from, to, options) {
+	    if (!options) options = noOptions;
+	    var self = this, mode = self.getModeAt(from);
+	    var startString = options.blockCommentStart || mode.blockCommentStart;
+	    var endString = options.blockCommentEnd || mode.blockCommentEnd;
+	    if (!startString || !endString) {
+	      if ((options.lineComment || mode.lineComment) && options.fullLines != false)
+	        self.lineComment(from, to, options);
+	      return;
+	    }
+	    if (/\bcomment\b/.test(self.getTokenTypeAt(Pos(from.line, 0)))) return
+
+	    var end = Math.min(to.line, self.lastLine());
+	    if (end != from.line && to.ch == 0 && nonWS.test(self.getLine(end))) --end;
+
+	    var pad = options.padding == null ? " " : options.padding;
+	    if (from.line > end) return;
+
+	    self.operation(function() {
+	      if (options.fullLines != false) {
+	        var lastLineHasText = nonWS.test(self.getLine(end));
+	        self.replaceRange(pad + endString, Pos(end));
+	        self.replaceRange(startString + pad, Pos(from.line, 0));
+	        var lead = options.blockCommentLead || mode.blockCommentLead;
+	        if (lead != null) for (var i = from.line + 1; i <= end; ++i)
+	          if (i != end || lastLineHasText)
+	            self.replaceRange(lead + pad, Pos(i, 0));
+	      } else {
+	        self.replaceRange(endString, to);
+	        self.replaceRange(startString, from);
+	      }
+	    });
+	  });
+
+	  CodeMirror.defineExtension("uncomment", function(from, to, options) {
+	    if (!options) options = noOptions;
+	    var self = this, mode = self.getModeAt(from);
+	    var end = Math.min(to.ch != 0 || to.line == from.line ? to.line : to.line - 1, self.lastLine()), start = Math.min(from.line, end);
+
+	    // Try finding line comments
+	    var lineString = options.lineComment || mode.lineComment, lines = [];
+	    var pad = options.padding == null ? " " : options.padding, didSomething;
+	    lineComment: {
+	      if (!lineString) break lineComment;
+	      for (var i = start; i <= end; ++i) {
+	        var line = self.getLine(i);
+	        var found = line.indexOf(lineString);
+	        if (found > -1 && !/comment/.test(self.getTokenTypeAt(Pos(i, found + 1)))) found = -1;
+	        if (found == -1 && nonWS.test(line)) break lineComment;
+	        if (found > -1 && nonWS.test(line.slice(0, found))) break lineComment;
+	        lines.push(line);
+	      }
+	      self.operation(function() {
+	        for (var i = start; i <= end; ++i) {
+	          var line = lines[i - start];
+	          var pos = line.indexOf(lineString), endPos = pos + lineString.length;
+	          if (pos < 0) continue;
+	          if (line.slice(endPos, endPos + pad.length) == pad) endPos += pad.length;
+	          didSomething = true;
+	          self.replaceRange("", Pos(i, pos), Pos(i, endPos));
+	        }
+	      });
+	      if (didSomething) return true;
+	    }
+
+	    // Try block comments
+	    var startString = options.blockCommentStart || mode.blockCommentStart;
+	    var endString = options.blockCommentEnd || mode.blockCommentEnd;
+	    if (!startString || !endString) return false;
+	    var lead = options.blockCommentLead || mode.blockCommentLead;
+	    var startLine = self.getLine(start), open = startLine.indexOf(startString)
+	    if (open == -1) return false
+	    var endLine = end == start ? startLine : self.getLine(end)
+	    var close = endLine.indexOf(endString, end == start ? open + startString.length : 0);
+	    if (close == -1 && start != end) {
+	      endLine = self.getLine(--end);
+	      close = endLine.indexOf(endString);
+	    }
+	    if (close == -1 ||
+	        !/comment/.test(self.getTokenTypeAt(Pos(start, open + 1))) ||
+	        !/comment/.test(self.getTokenTypeAt(Pos(end, close + 1))))
+	      return false;
+
+	    // Avoid killing block comments completely outside the selection.
+	    // Positions of the last startString before the start of the selection, and the first endString after it.
+	    var lastStart = startLine.lastIndexOf(startString, from.ch);
+	    var firstEnd = lastStart == -1 ? -1 : startLine.slice(0, from.ch).indexOf(endString, lastStart + startString.length);
+	    if (lastStart != -1 && firstEnd != -1 && firstEnd + endString.length != from.ch) return false;
+	    // Positions of the first endString after the end of the selection, and the last startString before it.
+	    firstEnd = endLine.indexOf(endString, to.ch);
+	    var almostLastStart = endLine.slice(to.ch).lastIndexOf(startString, firstEnd - to.ch);
+	    lastStart = (firstEnd == -1 || almostLastStart == -1) ? -1 : to.ch + almostLastStart;
+	    if (firstEnd != -1 && lastStart != -1 && lastStart != to.ch) return false;
+
+	    self.operation(function() {
+	      self.replaceRange("", Pos(end, close - (pad && endLine.slice(close - pad.length, close) == pad ? pad.length : 0)),
+	                        Pos(end, close + endString.length));
+	      var openEnd = open + startString.length;
+	      if (pad && startLine.slice(openEnd, openEnd + pad.length) == pad) openEnd += pad.length;
+	      self.replaceRange("", Pos(start, open), Pos(start, openEnd));
+	      if (lead) for (var i = start + 1; i <= end; ++i) {
+	        var line = self.getLine(i), found = line.indexOf(lead);
+	        if (found == -1 || nonWS.test(line.slice(0, found))) continue;
+	        var foundEnd = found + lead.length;
+	        if (pad && line.slice(foundEnd, foundEnd + pad.length) == pad) foundEnd += pad.length;
+	        self.replaceRange("", Pos(i, found), Pos(i, foundEnd));
+	      }
+	    });
+	    return true;
+	  });
+	});
+
+
+/***/ },
+/* 270 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// CodeMirror, copyright (c) by Marijn Haverbeke and others
+	// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+	(function(mod) {
+	  if (true) // CommonJS
+	    mod(__webpack_require__(267));
+	  else if (typeof define == "function" && define.amd) // AMD
+	    define(["../../lib/codemirror"], mod);
+	  else // Plain browser env
+	    mod(CodeMirror);
+	})(function(CodeMirror) {
+	  var ie_lt8 = /MSIE \d/.test(navigator.userAgent) &&
+	    (document.documentMode == null || document.documentMode < 8);
+
+	  var Pos = CodeMirror.Pos;
+
+	  var matching = {"(": ")>", ")": "(<", "[": "]>", "]": "[<", "{": "}>", "}": "{<"};
+
+	  function findMatchingBracket(cm, where, strict, config) {
+	    var line = cm.getLineHandle(where.line), pos = where.ch - 1;
+	    var match = (pos >= 0 && matching[line.text.charAt(pos)]) || matching[line.text.charAt(++pos)];
+	    if (!match) return null;
+	    var dir = match.charAt(1) == ">" ? 1 : -1;
+	    if (strict && (dir > 0) != (pos == where.ch)) return null;
+	    var style = cm.getTokenTypeAt(Pos(where.line, pos + 1));
+
+	    var found = scanForBracket(cm, Pos(where.line, pos + (dir > 0 ? 1 : 0)), dir, style || null, config);
+	    if (found == null) return null;
+	    return {from: Pos(where.line, pos), to: found && found.pos,
+	            match: found && found.ch == match.charAt(0), forward: dir > 0};
+	  }
+
+	  // bracketRegex is used to specify which type of bracket to scan
+	  // should be a regexp, e.g. /[[\]]/
+	  //
+	  // Note: If "where" is on an open bracket, then this bracket is ignored.
+	  //
+	  // Returns false when no bracket was found, null when it reached
+	  // maxScanLines and gave up
+	  function scanForBracket(cm, where, dir, style, config) {
+	    var maxScanLen = (config && config.maxScanLineLength) || 10000;
+	    var maxScanLines = (config && config.maxScanLines) || 1000;
+
+	    var stack = [];
+	    var re = config && config.bracketRegex ? config.bracketRegex : /[(){}[\]]/;
+	    var lineEnd = dir > 0 ? Math.min(where.line + maxScanLines, cm.lastLine() + 1)
+	                          : Math.max(cm.firstLine() - 1, where.line - maxScanLines);
+	    for (var lineNo = where.line; lineNo != lineEnd; lineNo += dir) {
+	      var line = cm.getLine(lineNo);
+	      if (!line) continue;
+	      var pos = dir > 0 ? 0 : line.length - 1, end = dir > 0 ? line.length : -1;
+	      if (line.length > maxScanLen) continue;
+	      if (lineNo == where.line) pos = where.ch - (dir < 0 ? 1 : 0);
+	      for (; pos != end; pos += dir) {
+	        var ch = line.charAt(pos);
+	        if (re.test(ch) && (style === undefined || cm.getTokenTypeAt(Pos(lineNo, pos + 1)) == style)) {
+	          var match = matching[ch];
+	          if ((match.charAt(1) == ">") == (dir > 0)) stack.push(ch);
+	          else if (!stack.length) return {pos: Pos(lineNo, pos), ch: ch};
+	          else stack.pop();
+	        }
+	      }
+	    }
+	    return lineNo - dir == (dir > 0 ? cm.lastLine() : cm.firstLine()) ? false : null;
+	  }
+
+	  function matchBrackets(cm, autoclear, config) {
+	    // Disable brace matching in long lines, since it'll cause hugely slow updates
+	    var maxHighlightLen = cm.state.matchBrackets.maxHighlightLineLength || 1000;
+	    var marks = [], ranges = cm.listSelections();
+	    for (var i = 0; i < ranges.length; i++) {
+	      var match = ranges[i].empty() && findMatchingBracket(cm, ranges[i].head, false, config);
+	      if (match && cm.getLine(match.from.line).length <= maxHighlightLen) {
+	        var style = match.match ? "CodeMirror-matchingbracket" : "CodeMirror-nonmatchingbracket";
+	        marks.push(cm.markText(match.from, Pos(match.from.line, match.from.ch + 1), {className: style}));
+	        if (match.to && cm.getLine(match.to.line).length <= maxHighlightLen)
+	          marks.push(cm.markText(match.to, Pos(match.to.line, match.to.ch + 1), {className: style}));
+	      }
+	    }
+
+	    if (marks.length) {
+	      // Kludge to work around the IE bug from issue #1193, where text
+	      // input stops going to the textare whever this fires.
+	      if (ie_lt8 && cm.state.focused) cm.focus();
+
+	      var clear = function() {
+	        cm.operation(function() {
+	          for (var i = 0; i < marks.length; i++) marks[i].clear();
+	        });
+	      };
+	      if (autoclear) setTimeout(clear, 800);
+	      else return clear;
+	    }
+	  }
+
+	  var currentlyHighlighted = null;
+	  function doMatchBrackets(cm) {
+	    cm.operation(function() {
+	      if (currentlyHighlighted) {currentlyHighlighted(); currentlyHighlighted = null;}
+	      currentlyHighlighted = matchBrackets(cm, false, cm.state.matchBrackets);
+	    });
+	  }
+
+	  CodeMirror.defineOption("matchBrackets", false, function(cm, val, old) {
+	    if (old && old != CodeMirror.Init) {
+	      cm.off("cursorActivity", doMatchBrackets);
+	      if (currentlyHighlighted) {currentlyHighlighted(); currentlyHighlighted = null;}
+	    }
+	    if (val) {
+	      cm.state.matchBrackets = typeof val == "object" ? val : {};
+	      cm.on("cursorActivity", doMatchBrackets);
+	    }
+	  });
+
+	  CodeMirror.defineExtension("matchBrackets", function() {matchBrackets(this, true);});
+	  CodeMirror.defineExtension("findMatchingBracket", function(pos, strict, config){
+	    return findMatchingBracket(this, pos, strict, config);
+	  });
+	  CodeMirror.defineExtension("scanForBracket", function(pos, dir, style, config){
+	    return scanForBracket(this, pos, dir, style, config);
+	  });
+	});
+
+
+/***/ },
+/* 271 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// CodeMirror, copyright (c) by Marijn Haverbeke and others
+	// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+	(function(mod) {
+	  if (true) // CommonJS
+	    mod(__webpack_require__(267));
+	  else if (typeof define == "function" && define.amd) // AMD
+	    define(["../../lib/codemirror"], mod);
+	  else // Plain browser env
+	    mod(CodeMirror);
+	})(function(CodeMirror) {
+	  var defaults = {
+	    pairs: "()[]{}''\"\"",
+	    triples: "",
+	    explode: "[]{}"
+	  };
+
+	  var Pos = CodeMirror.Pos;
+
+	  CodeMirror.defineOption("autoCloseBrackets", false, function(cm, val, old) {
+	    if (old && old != CodeMirror.Init) {
+	      cm.removeKeyMap(keyMap);
+	      cm.state.closeBrackets = null;
+	    }
+	    if (val) {
+	      cm.state.closeBrackets = val;
+	      cm.addKeyMap(keyMap);
+	    }
+	  });
+
+	  function getOption(conf, name) {
+	    if (name == "pairs" && typeof conf == "string") return conf;
+	    if (typeof conf == "object" && conf[name] != null) return conf[name];
+	    return defaults[name];
+	  }
+
+	  var bind = defaults.pairs + "`";
+	  var keyMap = {Backspace: handleBackspace, Enter: handleEnter};
+	  for (var i = 0; i < bind.length; i++)
+	    keyMap["'" + bind.charAt(i) + "'"] = handler(bind.charAt(i));
+
+	  function handler(ch) {
+	    return function(cm) { return handleChar(cm, ch); };
+	  }
+
+	  function getConfig(cm) {
+	    var deflt = cm.state.closeBrackets;
+	    if (!deflt) return null;
+	    var mode = cm.getModeAt(cm.getCursor());
+	    return mode.closeBrackets || deflt;
+	  }
+
+	  function handleBackspace(cm) {
+	    var conf = getConfig(cm);
+	    if (!conf || cm.getOption("disableInput")) return CodeMirror.Pass;
+
+	    var pairs = getOption(conf, "pairs");
+	    var ranges = cm.listSelections();
+	    for (var i = 0; i < ranges.length; i++) {
+	      if (!ranges[i].empty()) return CodeMirror.Pass;
+	      var around = charsAround(cm, ranges[i].head);
+	      if (!around || pairs.indexOf(around) % 2 != 0) return CodeMirror.Pass;
+	    }
+	    for (var i = ranges.length - 1; i >= 0; i--) {
+	      var cur = ranges[i].head;
+	      cm.replaceRange("", Pos(cur.line, cur.ch - 1), Pos(cur.line, cur.ch + 1), "+delete");
+	    }
+	  }
+
+	  function handleEnter(cm) {
+	    var conf = getConfig(cm);
+	    var explode = conf && getOption(conf, "explode");
+	    if (!explode || cm.getOption("disableInput")) return CodeMirror.Pass;
+
+	    var ranges = cm.listSelections();
+	    for (var i = 0; i < ranges.length; i++) {
+	      if (!ranges[i].empty()) return CodeMirror.Pass;
+	      var around = charsAround(cm, ranges[i].head);
+	      if (!around || explode.indexOf(around) % 2 != 0) return CodeMirror.Pass;
+	    }
+	    cm.operation(function() {
+	      cm.replaceSelection("\n\n", null);
+	      cm.execCommand("goCharLeft");
+	      ranges = cm.listSelections();
+	      for (var i = 0; i < ranges.length; i++) {
+	        var line = ranges[i].head.line;
+	        cm.indentLine(line, null, true);
+	        cm.indentLine(line + 1, null, true);
+	      }
+	    });
+	  }
+
+	  function contractSelection(sel) {
+	    var inverted = CodeMirror.cmpPos(sel.anchor, sel.head) > 0;
+	    return {anchor: new Pos(sel.anchor.line, sel.anchor.ch + (inverted ? -1 : 1)),
+	            head: new Pos(sel.head.line, sel.head.ch + (inverted ? 1 : -1))};
+	  }
+
+	  function handleChar(cm, ch) {
+	    var conf = getConfig(cm);
+	    if (!conf || cm.getOption("disableInput")) return CodeMirror.Pass;
+
+	    var pairs = getOption(conf, "pairs");
+	    var pos = pairs.indexOf(ch);
+	    if (pos == -1) return CodeMirror.Pass;
+	    var triples = getOption(conf, "triples");
+
+	    var identical = pairs.charAt(pos + 1) == ch;
+	    var ranges = cm.listSelections();
+	    var opening = pos % 2 == 0;
+
+	    var type;
+	    for (var i = 0; i < ranges.length; i++) {
+	      var range = ranges[i], cur = range.head, curType;
+	      var next = cm.getRange(cur, Pos(cur.line, cur.ch + 1));
+	      if (opening && !range.empty()) {
+	        curType = "surround";
+	      } else if ((identical || !opening) && next == ch) {
+	        if (identical && stringStartsAfter(cm, cur))
+	          curType = "both";
+	        else if (triples.indexOf(ch) >= 0 && cm.getRange(cur, Pos(cur.line, cur.ch + 3)) == ch + ch + ch)
+	          curType = "skipThree";
+	        else
+	          curType = "skip";
+	      } else if (identical && cur.ch > 1 && triples.indexOf(ch) >= 0 &&
+	                 cm.getRange(Pos(cur.line, cur.ch - 2), cur) == ch + ch &&
+	                 (cur.ch <= 2 || cm.getRange(Pos(cur.line, cur.ch - 3), Pos(cur.line, cur.ch - 2)) != ch)) {
+	        curType = "addFour";
+	      } else if (identical) {
+	        if (!CodeMirror.isWordChar(next) && enteringString(cm, cur, ch)) curType = "both";
+	        else return CodeMirror.Pass;
+	      } else if (opening && (cm.getLine(cur.line).length == cur.ch ||
+	                             isClosingBracket(next, pairs) ||
+	                             /\s/.test(next))) {
+	        curType = "both";
+	      } else {
+	        return CodeMirror.Pass;
+	      }
+	      if (!type) type = curType;
+	      else if (type != curType) return CodeMirror.Pass;
+	    }
+
+	    var left = pos % 2 ? pairs.charAt(pos - 1) : ch;
+	    var right = pos % 2 ? ch : pairs.charAt(pos + 1);
+	    cm.operation(function() {
+	      if (type == "skip") {
+	        cm.execCommand("goCharRight");
+	      } else if (type == "skipThree") {
+	        for (var i = 0; i < 3; i++)
+	          cm.execCommand("goCharRight");
+	      } else if (type == "surround") {
+	        var sels = cm.getSelections();
+	        for (var i = 0; i < sels.length; i++)
+	          sels[i] = left + sels[i] + right;
+	        cm.replaceSelections(sels, "around");
+	        sels = cm.listSelections().slice();
+	        for (var i = 0; i < sels.length; i++)
+	          sels[i] = contractSelection(sels[i]);
+	        cm.setSelections(sels);
+	      } else if (type == "both") {
+	        cm.replaceSelection(left + right, null);
+	        cm.triggerElectric(left + right);
+	        cm.execCommand("goCharLeft");
+	      } else if (type == "addFour") {
+	        cm.replaceSelection(left + left + left + left, "before");
+	        cm.execCommand("goCharRight");
+	      }
+	    });
+	  }
+
+	  function isClosingBracket(ch, pairs) {
+	    var pos = pairs.lastIndexOf(ch);
+	    return pos > -1 && pos % 2 == 1;
+	  }
+
+	  function charsAround(cm, pos) {
+	    var str = cm.getRange(Pos(pos.line, pos.ch - 1),
+	                          Pos(pos.line, pos.ch + 1));
+	    return str.length == 2 ? str : null;
+	  }
+
+	  // Project the token type that will exists after the given char is
+	  // typed, and use it to determine whether it would cause the start
+	  // of a string token.
+	  function enteringString(cm, pos, ch) {
+	    var line = cm.getLine(pos.line);
+	    var token = cm.getTokenAt(pos);
+	    if (/\bstring2?\b/.test(token.type)) return false;
+	    var stream = new CodeMirror.StringStream(line.slice(0, pos.ch) + ch + line.slice(pos.ch), 4);
+	    stream.pos = stream.start = token.start;
+	    for (;;) {
+	      var type1 = cm.getMode().token(stream, token.state);
+	      if (stream.pos >= pos.ch + 1) return /\bstring2?\b/.test(type1);
+	      stream.start = stream.pos;
+	    }
+	  }
+
+	  function stringStartsAfter(cm, pos) {
+	    var token = cm.getTokenAt(Pos(pos.line, pos.ch + 1))
+	    return /\bstring/.test(token.type) && token.start == pos.ch
+	  }
+	});
+
+
+/***/ },
+/* 272 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// CodeMirror, copyright (c) by Marijn Haverbeke and others
+	// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+	(function(mod) {
+	  if (true) // CommonJS
+	    mod(__webpack_require__(267), __webpack_require__(273));
+	  else if (typeof define == "function" && define.amd) // AMD
+	    define(["../../lib/codemirror", "./foldcode"], mod);
+	  else // Plain browser env
+	    mod(CodeMirror);
+	})(function(CodeMirror) {
+	  "use strict";
+
+	  CodeMirror.defineOption("foldGutter", false, function(cm, val, old) {
+	    if (old && old != CodeMirror.Init) {
+	      cm.clearGutter(cm.state.foldGutter.options.gutter);
+	      cm.state.foldGutter = null;
+	      cm.off("gutterClick", onGutterClick);
+	      cm.off("change", onChange);
+	      cm.off("viewportChange", onViewportChange);
+	      cm.off("fold", onFold);
+	      cm.off("unfold", onFold);
+	      cm.off("swapDoc", onChange);
+	    }
+	    if (val) {
+	      cm.state.foldGutter = new State(parseOptions(val));
+	      updateInViewport(cm);
+	      cm.on("gutterClick", onGutterClick);
+	      cm.on("change", onChange);
+	      cm.on("viewportChange", onViewportChange);
+	      cm.on("fold", onFold);
+	      cm.on("unfold", onFold);
+	      cm.on("swapDoc", onChange);
+	    }
+	  });
+
+	  var Pos = CodeMirror.Pos;
+
+	  function State(options) {
+	    this.options = options;
+	    this.from = this.to = 0;
+	  }
+
+	  function parseOptions(opts) {
+	    if (opts === true) opts = {};
+	    if (opts.gutter == null) opts.gutter = "CodeMirror-foldgutter";
+	    if (opts.indicatorOpen == null) opts.indicatorOpen = "CodeMirror-foldgutter-open";
+	    if (opts.indicatorFolded == null) opts.indicatorFolded = "CodeMirror-foldgutter-folded";
+	    return opts;
+	  }
+
+	  function isFolded(cm, line) {
+	    var marks = cm.findMarks(Pos(line, 0), Pos(line + 1, 0));
+	    for (var i = 0; i < marks.length; ++i)
+	      if (marks[i].__isFold && marks[i].find().from.line == line) return marks[i];
+	  }
+
+	  function marker(spec) {
+	    if (typeof spec == "string") {
+	      var elt = document.createElement("div");
+	      elt.className = spec + " CodeMirror-guttermarker-subtle";
+	      return elt;
+	    } else {
+	      return spec.cloneNode(true);
+	    }
+	  }
+
+	  function updateFoldInfo(cm, from, to) {
+	    var opts = cm.state.foldGutter.options, cur = from;
+	    var minSize = cm.foldOption(opts, "minFoldSize");
+	    var func = cm.foldOption(opts, "rangeFinder");
+	    cm.eachLine(from, to, function(line) {
+	      var mark = null;
+	      if (isFolded(cm, cur)) {
+	        mark = marker(opts.indicatorFolded);
+	      } else {
+	        var pos = Pos(cur, 0);
+	        var range = func && func(cm, pos);
+	        if (range && range.to.line - range.from.line >= minSize)
+	          mark = marker(opts.indicatorOpen);
+	      }
+	      cm.setGutterMarker(line, opts.gutter, mark);
+	      ++cur;
+	    });
+	  }
+
+	  function updateInViewport(cm) {
+	    var vp = cm.getViewport(), state = cm.state.foldGutter;
+	    if (!state) return;
+	    cm.operation(function() {
+	      updateFoldInfo(cm, vp.from, vp.to);
+	    });
+	    state.from = vp.from; state.to = vp.to;
+	  }
+
+	  function onGutterClick(cm, line, gutter) {
+	    var state = cm.state.foldGutter;
+	    if (!state) return;
+	    var opts = state.options;
+	    if (gutter != opts.gutter) return;
+	    var folded = isFolded(cm, line);
+	    if (folded) folded.clear();
+	    else cm.foldCode(Pos(line, 0), opts.rangeFinder);
+	  }
+
+	  function onChange(cm) {
+	    var state = cm.state.foldGutter;
+	    if (!state) return;
+	    var opts = state.options;
+	    state.from = state.to = 0;
+	    clearTimeout(state.changeUpdate);
+	    state.changeUpdate = setTimeout(function() { updateInViewport(cm); }, opts.foldOnChangeTimeSpan || 600);
+	  }
+
+	  function onViewportChange(cm) {
+	    var state = cm.state.foldGutter;
+	    if (!state) return;
+	    var opts = state.options;
+	    clearTimeout(state.changeUpdate);
+	    state.changeUpdate = setTimeout(function() {
+	      var vp = cm.getViewport();
+	      if (state.from == state.to || vp.from - state.to > 20 || state.from - vp.to > 20) {
+	        updateInViewport(cm);
+	      } else {
+	        cm.operation(function() {
+	          if (vp.from < state.from) {
+	            updateFoldInfo(cm, vp.from, state.from);
+	            state.from = vp.from;
+	          }
+	          if (vp.to > state.to) {
+	            updateFoldInfo(cm, state.to, vp.to);
+	            state.to = vp.to;
+	          }
+	        });
+	      }
+	    }, opts.updateViewportTimeSpan || 400);
+	  }
+
+	  function onFold(cm, from) {
+	    var state = cm.state.foldGutter;
+	    if (!state) return;
+	    var line = from.line;
+	    if (line >= state.from && line < state.to)
+	      updateFoldInfo(cm, line, line + 1);
+	  }
+	});
+
+
+/***/ },
+/* 273 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// CodeMirror, copyright (c) by Marijn Haverbeke and others
+	// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+	(function(mod) {
+	  if (true) // CommonJS
+	    mod(__webpack_require__(267));
+	  else if (typeof define == "function" && define.amd) // AMD
+	    define(["../../lib/codemirror"], mod);
+	  else // Plain browser env
+	    mod(CodeMirror);
+	})(function(CodeMirror) {
+	  "use strict";
+
+	  function doFold(cm, pos, options, force) {
+	    if (options && options.call) {
+	      var finder = options;
+	      options = null;
+	    } else {
+	      var finder = getOption(cm, options, "rangeFinder");
+	    }
+	    if (typeof pos == "number") pos = CodeMirror.Pos(pos, 0);
+	    var minSize = getOption(cm, options, "minFoldSize");
+
+	    function getRange(allowFolded) {
+	      var range = finder(cm, pos);
+	      if (!range || range.to.line - range.from.line < minSize) return null;
+	      var marks = cm.findMarksAt(range.from);
+	      for (var i = 0; i < marks.length; ++i) {
+	        if (marks[i].__isFold && force !== "fold") {
+	          if (!allowFolded) return null;
+	          range.cleared = true;
+	          marks[i].clear();
+	        }
+	      }
+	      return range;
+	    }
+
+	    var range = getRange(true);
+	    if (getOption(cm, options, "scanUp")) while (!range && pos.line > cm.firstLine()) {
+	      pos = CodeMirror.Pos(pos.line - 1, 0);
+	      range = getRange(false);
+	    }
+	    if (!range || range.cleared || force === "unfold") return;
+
+	    var myWidget = makeWidget(cm, options);
+	    CodeMirror.on(myWidget, "mousedown", function(e) {
+	      myRange.clear();
+	      CodeMirror.e_preventDefault(e);
+	    });
+	    var myRange = cm.markText(range.from, range.to, {
+	      replacedWith: myWidget,
+	      clearOnEnter: getOption(cm, options, "clearOnEnter"),
+	      __isFold: true
+	    });
+	    myRange.on("clear", function(from, to) {
+	      CodeMirror.signal(cm, "unfold", cm, from, to);
+	    });
+	    CodeMirror.signal(cm, "fold", cm, range.from, range.to);
+	  }
+
+	  function makeWidget(cm, options) {
+	    var widget = getOption(cm, options, "widget");
+	    if (typeof widget == "string") {
+	      var text = document.createTextNode(widget);
+	      widget = document.createElement("span");
+	      widget.appendChild(text);
+	      widget.className = "CodeMirror-foldmarker";
+	    }
+	    return widget;
+	  }
+
+	  // Clumsy backwards-compatible interface
+	  CodeMirror.newFoldFunction = function(rangeFinder, widget) {
+	    return function(cm, pos) { doFold(cm, pos, {rangeFinder: rangeFinder, widget: widget}); };
+	  };
+
+	  // New-style interface
+	  CodeMirror.defineExtension("foldCode", function(pos, options, force) {
+	    doFold(this, pos, options, force);
+	  });
+
+	  CodeMirror.defineExtension("isFolded", function(pos) {
+	    var marks = this.findMarksAt(pos);
+	    for (var i = 0; i < marks.length; ++i)
+	      if (marks[i].__isFold) return true;
+	  });
+
+	  CodeMirror.commands.toggleFold = function(cm) {
+	    cm.foldCode(cm.getCursor());
+	  };
+	  CodeMirror.commands.fold = function(cm) {
+	    cm.foldCode(cm.getCursor(), null, "fold");
+	  };
+	  CodeMirror.commands.unfold = function(cm) {
+	    cm.foldCode(cm.getCursor(), null, "unfold");
+	  };
+	  CodeMirror.commands.foldAll = function(cm) {
+	    cm.operation(function() {
+	      for (var i = cm.firstLine(), e = cm.lastLine(); i <= e; i++)
+	        cm.foldCode(CodeMirror.Pos(i, 0), null, "fold");
+	    });
+	  };
+	  CodeMirror.commands.unfoldAll = function(cm) {
+	    cm.operation(function() {
+	      for (var i = cm.firstLine(), e = cm.lastLine(); i <= e; i++)
+	        cm.foldCode(CodeMirror.Pos(i, 0), null, "unfold");
+	    });
+	  };
+
+	  CodeMirror.registerHelper("fold", "combine", function() {
+	    var funcs = Array.prototype.slice.call(arguments, 0);
+	    return function(cm, start) {
+	      for (var i = 0; i < funcs.length; ++i) {
+	        var found = funcs[i](cm, start);
+	        if (found) return found;
+	      }
+	    };
+	  });
+
+	  CodeMirror.registerHelper("fold", "auto", function(cm, start) {
+	    var helpers = cm.getHelpers(start, "fold");
+	    for (var i = 0; i < helpers.length; i++) {
+	      var cur = helpers[i](cm, start);
+	      if (cur) return cur;
+	    }
+	  });
+
+	  var defaultOptions = {
+	    rangeFinder: CodeMirror.fold.auto,
+	    widget: "\u2194",
+	    minFoldSize: 0,
+	    scanUp: false,
+	    clearOnEnter: true
+	  };
+
+	  CodeMirror.defineOption("foldOptions", null);
+
+	  function getOption(cm, options, name) {
+	    if (options && options[name] !== undefined)
+	      return options[name];
+	    var editorOptions = cm.options.foldOptions;
+	    if (editorOptions && editorOptions[name] !== undefined)
+	      return editorOptions[name];
+	    return defaultOptions[name];
+	  }
+
+	  CodeMirror.defineExtension("foldOption", function(options, name) {
+	    return getOption(this, options, name);
+	  });
+	});
+
+
+/***/ },
+/* 274 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// CodeMirror, copyright (c) by Marijn Haverbeke and others
+	// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+	(function(mod) {
+	  if (true) // CommonJS
+	    mod(__webpack_require__(267));
+	  else if (typeof define == "function" && define.amd) // AMD
+	    define(["../../lib/codemirror"], mod);
+	  else // Plain browser env
+	    mod(CodeMirror);
+	})(function(CodeMirror) {
+	"use strict";
+
+	CodeMirror.registerHelper("fold", "brace", function(cm, start) {
+	  var line = start.line, lineText = cm.getLine(line);
+	  var tokenType;
+
+	  function findOpening(openCh) {
+	    for (var at = start.ch, pass = 0;;) {
+	      var found = at <= 0 ? -1 : lineText.lastIndexOf(openCh, at - 1);
+	      if (found == -1) {
+	        if (pass == 1) break;
+	        pass = 1;
+	        at = lineText.length;
+	        continue;
+	      }
+	      if (pass == 1 && found < start.ch) break;
+	      tokenType = cm.getTokenTypeAt(CodeMirror.Pos(line, found + 1));
+	      if (!/^(comment|string)/.test(tokenType)) return found + 1;
+	      at = found - 1;
+	    }
+	  }
+
+	  var startToken = "{", endToken = "}", startCh = findOpening("{");
+	  if (startCh == null) {
+	    startToken = "[", endToken = "]";
+	    startCh = findOpening("[");
+	  }
+
+	  if (startCh == null) return;
+	  var count = 1, lastLine = cm.lastLine(), end, endCh;
+	  outer: for (var i = line; i <= lastLine; ++i) {
+	    var text = cm.getLine(i), pos = i == line ? startCh : 0;
+	    for (;;) {
+	      var nextOpen = text.indexOf(startToken, pos), nextClose = text.indexOf(endToken, pos);
+	      if (nextOpen < 0) nextOpen = text.length;
+	      if (nextClose < 0) nextClose = text.length;
+	      pos = Math.min(nextOpen, nextClose);
+	      if (pos == text.length) break;
+	      if (cm.getTokenTypeAt(CodeMirror.Pos(i, pos + 1)) == tokenType) {
+	        if (pos == nextOpen) ++count;
+	        else if (!--count) { end = i; endCh = pos; break outer; }
+	      }
+	      ++pos;
+	    }
+	  }
+	  if (end == null || line == end && endCh == startCh) return;
+	  return {from: CodeMirror.Pos(line, startCh),
+	          to: CodeMirror.Pos(end, endCh)};
+	});
+
+	CodeMirror.registerHelper("fold", "import", function(cm, start) {
+	  function hasImport(line) {
+	    if (line < cm.firstLine() || line > cm.lastLine()) return null;
+	    var start = cm.getTokenAt(CodeMirror.Pos(line, 1));
+	    if (!/\S/.test(start.string)) start = cm.getTokenAt(CodeMirror.Pos(line, start.end + 1));
+	    if (start.type != "keyword" || start.string != "import") return null;
+	    // Now find closing semicolon, return its position
+	    for (var i = line, e = Math.min(cm.lastLine(), line + 10); i <= e; ++i) {
+	      var text = cm.getLine(i), semi = text.indexOf(";");
+	      if (semi != -1) return {startCh: start.end, end: CodeMirror.Pos(i, semi)};
+	    }
+	  }
+
+	  var startLine = start.line, has = hasImport(startLine), prev;
+	  if (!has || hasImport(startLine - 1) || ((prev = hasImport(startLine - 2)) && prev.end.line == startLine - 1))
+	    return null;
+	  for (var end = has.end;;) {
+	    var next = hasImport(end.line + 1);
+	    if (next == null) break;
+	    end = next.end;
+	  }
+	  return {from: cm.clipPos(CodeMirror.Pos(startLine, has.startCh + 1)), to: end};
+	});
+
+	CodeMirror.registerHelper("fold", "include", function(cm, start) {
+	  function hasInclude(line) {
+	    if (line < cm.firstLine() || line > cm.lastLine()) return null;
+	    var start = cm.getTokenAt(CodeMirror.Pos(line, 1));
+	    if (!/\S/.test(start.string)) start = cm.getTokenAt(CodeMirror.Pos(line, start.end + 1));
+	    if (start.type == "meta" && start.string.slice(0, 8) == "#include") return start.start + 8;
+	  }
+
+	  var startLine = start.line, has = hasInclude(startLine);
+	  if (has == null || hasInclude(startLine - 1) != null) return null;
+	  for (var end = startLine;;) {
+	    var next = hasInclude(end + 1);
+	    if (next == null) break;
+	    ++end;
+	  }
+	  return {from: CodeMirror.Pos(startLine, has + 1),
+	          to: cm.clipPos(CodeMirror.Pos(end))};
+	});
+
+	});
+
+
+/***/ },
+/* 275 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// CodeMirror, copyright (c) by Marijn Haverbeke and others
+	// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+	(function(mod) {
+	  if (true) // CommonJS
+	    mod(__webpack_require__(267));
+	  else if (typeof define == "function" && define.amd) // AMD
+	    define(["../../lib/codemirror"], mod);
+	  else // Plain browser env
+	    mod(CodeMirror);
+	})(function(CodeMirror) {
+	  "use strict";
+	  var GUTTER_ID = "CodeMirror-lint-markers";
+
+	  function showTooltip(e, content) {
+	    var tt = document.createElement("div");
+	    tt.className = "CodeMirror-lint-tooltip";
+	    tt.appendChild(content.cloneNode(true));
+	    document.body.appendChild(tt);
+
+	    function position(e) {
+	      if (!tt.parentNode) return CodeMirror.off(document, "mousemove", position);
+	      tt.style.top = Math.max(0, e.clientY - tt.offsetHeight - 5) + "px";
+	      tt.style.left = (e.clientX + 5) + "px";
+	    }
+	    CodeMirror.on(document, "mousemove", position);
+	    position(e);
+	    if (tt.style.opacity != null) tt.style.opacity = 1;
+	    return tt;
+	  }
+	  function rm(elt) {
+	    if (elt.parentNode) elt.parentNode.removeChild(elt);
+	  }
+	  function hideTooltip(tt) {
+	    if (!tt.parentNode) return;
+	    if (tt.style.opacity == null) rm(tt);
+	    tt.style.opacity = 0;
+	    setTimeout(function() { rm(tt); }, 600);
+	  }
+
+	  function showTooltipFor(e, content, node) {
+	    var tooltip = showTooltip(e, content);
+	    function hide() {
+	      CodeMirror.off(node, "mouseout", hide);
+	      if (tooltip) { hideTooltip(tooltip); tooltip = null; }
+	    }
+	    var poll = setInterval(function() {
+	      if (tooltip) for (var n = node;; n = n.parentNode) {
+	        if (n && n.nodeType == 11) n = n.host;
+	        if (n == document.body) return;
+	        if (!n) { hide(); break; }
+	      }
+	      if (!tooltip) return clearInterval(poll);
+	    }, 400);
+	    CodeMirror.on(node, "mouseout", hide);
+	  }
+
+	  function LintState(cm, options, hasGutter) {
+	    this.marked = [];
+	    this.options = options;
+	    this.timeout = null;
+	    this.hasGutter = hasGutter;
+	    this.onMouseOver = function(e) { onMouseOver(cm, e); };
+	    this.waitingFor = 0
+	  }
+
+	  function parseOptions(_cm, options) {
+	    if (options instanceof Function) return {getAnnotations: options};
+	    if (!options || options === true) options = {};
+	    return options;
+	  }
+
+	  function clearMarks(cm) {
+	    var state = cm.state.lint;
+	    if (state.hasGutter) cm.clearGutter(GUTTER_ID);
+	    for (var i = 0; i < state.marked.length; ++i)
+	      state.marked[i].clear();
+	    state.marked.length = 0;
+	  }
+
+	  function makeMarker(labels, severity, multiple, tooltips) {
+	    var marker = document.createElement("div"), inner = marker;
+	    marker.className = "CodeMirror-lint-marker-" + severity;
+	    if (multiple) {
+	      inner = marker.appendChild(document.createElement("div"));
+	      inner.className = "CodeMirror-lint-marker-multiple";
+	    }
+
+	    if (tooltips != false) CodeMirror.on(inner, "mouseover", function(e) {
+	      showTooltipFor(e, labels, inner);
+	    });
+
+	    return marker;
+	  }
+
+	  function getMaxSeverity(a, b) {
+	    if (a == "error") return a;
+	    else return b;
+	  }
+
+	  function groupByLine(annotations) {
+	    var lines = [];
+	    for (var i = 0; i < annotations.length; ++i) {
+	      var ann = annotations[i], line = ann.from.line;
+	      (lines[line] || (lines[line] = [])).push(ann);
+	    }
+	    return lines;
+	  }
+
+	  function annotationTooltip(ann) {
+	    var severity = ann.severity;
+	    if (!severity) severity = "error";
+	    var tip = document.createElement("div");
+	    tip.className = "CodeMirror-lint-message-" + severity;
+	    tip.appendChild(document.createTextNode(ann.message));
+	    return tip;
+	  }
+
+	  function lintAsync(cm, getAnnotations, passOptions) {
+	    var state = cm.state.lint
+	    var id = ++state.waitingFor
+	    function abort() {
+	      id = -1
+	      cm.off("change", abort)
+	    }
+	    cm.on("change", abort)
+	    getAnnotations(cm.getValue(), function(annotations, arg2) {
+	      cm.off("change", abort)
+	      if (state.waitingFor != id) return
+	      if (arg2 && annotations instanceof CodeMirror) annotations = arg2
+	      updateLinting(cm, annotations)
+	    }, passOptions, cm);
+	  }
+
+	  function startLinting(cm) {
+	    var state = cm.state.lint, options = state.options;
+	    var passOptions = options.options || options; // Support deprecated passing of `options` property in options
+	    var getAnnotations = options.getAnnotations || cm.getHelper(CodeMirror.Pos(0, 0), "lint");
+	    if (!getAnnotations) return;
+	    if (options.async || getAnnotations.async) {
+	      lintAsync(cm, getAnnotations, passOptions)
+	    } else {
+	      updateLinting(cm, getAnnotations(cm.getValue(), passOptions, cm));
+	    }
+	  }
+
+	  function updateLinting(cm, annotationsNotSorted) {
+	    clearMarks(cm);
+	    var state = cm.state.lint, options = state.options;
+
+	    var annotations = groupByLine(annotationsNotSorted);
+
+	    for (var line = 0; line < annotations.length; ++line) {
+	      var anns = annotations[line];
+	      if (!anns) continue;
+
+	      var maxSeverity = null;
+	      var tipLabel = state.hasGutter && document.createDocumentFragment();
+
+	      for (var i = 0; i < anns.length; ++i) {
+	        var ann = anns[i];
+	        var severity = ann.severity;
+	        if (!severity) severity = "error";
+	        maxSeverity = getMaxSeverity(maxSeverity, severity);
+
+	        if (options.formatAnnotation) ann = options.formatAnnotation(ann);
+	        if (state.hasGutter) tipLabel.appendChild(annotationTooltip(ann));
+
+	        if (ann.to) state.marked.push(cm.markText(ann.from, ann.to, {
+	          className: "CodeMirror-lint-mark-" + severity,
+	          __annotation: ann
+	        }));
+	      }
+
+	      if (state.hasGutter)
+	        cm.setGutterMarker(line, GUTTER_ID, makeMarker(tipLabel, maxSeverity, anns.length > 1,
+	                                                       state.options.tooltips));
+	    }
+	    if (options.onUpdateLinting) options.onUpdateLinting(annotationsNotSorted, annotations, cm);
+	  }
+
+	  function onChange(cm) {
+	    var state = cm.state.lint;
+	    if (!state) return;
+	    clearTimeout(state.timeout);
+	    state.timeout = setTimeout(function(){startLinting(cm);}, state.options.delay || 500);
+	  }
+
+	  function popupTooltips(annotations, e) {
+	    var target = e.target || e.srcElement;
+	    var tooltip = document.createDocumentFragment();
+	    for (var i = 0; i < annotations.length; i++) {
+	      var ann = annotations[i];
+	      tooltip.appendChild(annotationTooltip(ann));
+	    }
+	    showTooltipFor(e, tooltip, target);
+	  }
+
+	  function onMouseOver(cm, e) {
+	    var target = e.target || e.srcElement;
+	    if (!/\bCodeMirror-lint-mark-/.test(target.className)) return;
+	    var box = target.getBoundingClientRect(), x = (box.left + box.right) / 2, y = (box.top + box.bottom) / 2;
+	    var spans = cm.findMarksAt(cm.coordsChar({left: x, top: y}, "client"));
+
+	    var annotations = [];
+	    for (var i = 0; i < spans.length; ++i) {
+	      var ann = spans[i].__annotation;
+	      if (ann) annotations.push(ann);
+	    }
+	    if (annotations.length) popupTooltips(annotations, e);
+	  }
+
+	  CodeMirror.defineOption("lint", false, function(cm, val, old) {
+	    if (old && old != CodeMirror.Init) {
+	      clearMarks(cm);
+	      if (cm.state.lint.options.lintOnChange !== false)
+	        cm.off("change", onChange);
+	      CodeMirror.off(cm.getWrapperElement(), "mouseover", cm.state.lint.onMouseOver);
+	      clearTimeout(cm.state.lint.timeout);
+	      delete cm.state.lint;
+	    }
+
+	    if (val) {
+	      var gutters = cm.getOption("gutters"), hasLintGutter = false;
+	      for (var i = 0; i < gutters.length; ++i) if (gutters[i] == GUTTER_ID) hasLintGutter = true;
+	      var state = cm.state.lint = new LintState(cm, parseOptions(cm, val), hasLintGutter);
+	      if (state.options.lintOnChange !== false)
+	        cm.on("change", onChange);
+	      if (state.options.tooltips != false && state.options.tooltips != "gutter")
+	        CodeMirror.on(cm.getWrapperElement(), "mouseover", state.onMouseOver);
+
+	      startLinting(cm);
+	    }
+	  });
+
+	  CodeMirror.defineExtension("performLint", function() {
+	    if (this.state.lint) startLinting(this);
+	  });
+	});
+
+
+/***/ },
+/* 276 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// CodeMirror, copyright (c) by Marijn Haverbeke and others
+	// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+	// A rough approximation of Sublime Text's keybindings
+	// Depends on addon/search/searchcursor.js and optionally addon/dialog/dialogs.js
+
+	(function(mod) {
+	  if (true) // CommonJS
+	    mod(__webpack_require__(267), __webpack_require__(277), __webpack_require__(270));
+	  else if (typeof define == "function" && define.amd) // AMD
+	    define(["../lib/codemirror", "../addon/search/searchcursor", "../addon/edit/matchbrackets"], mod);
+	  else // Plain browser env
+	    mod(CodeMirror);
+	})(function(CodeMirror) {
+	  "use strict";
+
+	  var map = CodeMirror.keyMap.sublime = {fallthrough: "default"};
+	  var cmds = CodeMirror.commands;
+	  var Pos = CodeMirror.Pos;
+	  var mac = CodeMirror.keyMap["default"] == CodeMirror.keyMap.macDefault;
+	  var ctrl = mac ? "Cmd-" : "Ctrl-";
+
+	  // This is not exactly Sublime's algorithm. I couldn't make heads or tails of that.
+	  function findPosSubword(doc, start, dir) {
+	    if (dir < 0 && start.ch == 0) return doc.clipPos(Pos(start.line - 1));
+	    var line = doc.getLine(start.line);
+	    if (dir > 0 && start.ch >= line.length) return doc.clipPos(Pos(start.line + 1, 0));
+	    var state = "start", type;
+	    for (var pos = start.ch, e = dir < 0 ? 0 : line.length, i = 0; pos != e; pos += dir, i++) {
+	      var next = line.charAt(dir < 0 ? pos - 1 : pos);
+	      var cat = next != "_" && CodeMirror.isWordChar(next) ? "w" : "o";
+	      if (cat == "w" && next.toUpperCase() == next) cat = "W";
+	      if (state == "start") {
+	        if (cat != "o") { state = "in"; type = cat; }
+	      } else if (state == "in") {
+	        if (type != cat) {
+	          if (type == "w" && cat == "W" && dir < 0) pos--;
+	          if (type == "W" && cat == "w" && dir > 0) { type = "w"; continue; }
+	          break;
+	        }
+	      }
+	    }
+	    return Pos(start.line, pos);
+	  }
+
+	  function moveSubword(cm, dir) {
+	    cm.extendSelectionsBy(function(range) {
+	      if (cm.display.shift || cm.doc.extend || range.empty())
+	        return findPosSubword(cm.doc, range.head, dir);
+	      else
+	        return dir < 0 ? range.from() : range.to();
+	    });
+	  }
+
+	  var goSubwordCombo = mac ? "Ctrl-" : "Alt-";
+
+	  cmds[map[goSubwordCombo + "Left"] = "goSubwordLeft"] = function(cm) { moveSubword(cm, -1); };
+	  cmds[map[goSubwordCombo + "Right"] = "goSubwordRight"] = function(cm) { moveSubword(cm, 1); };
+
+	  if (mac) map["Cmd-Left"] = "goLineStartSmart";
+
+	  var scrollLineCombo = mac ? "Ctrl-Alt-" : "Ctrl-";
+
+	  cmds[map[scrollLineCombo + "Up"] = "scrollLineUp"] = function(cm) {
+	    var info = cm.getScrollInfo();
+	    if (!cm.somethingSelected()) {
+	      var visibleBottomLine = cm.lineAtHeight(info.top + info.clientHeight, "local");
+	      if (cm.getCursor().line >= visibleBottomLine)
+	        cm.execCommand("goLineUp");
+	    }
+	    cm.scrollTo(null, info.top - cm.defaultTextHeight());
+	  };
+	  cmds[map[scrollLineCombo + "Down"] = "scrollLineDown"] = function(cm) {
+	    var info = cm.getScrollInfo();
+	    if (!cm.somethingSelected()) {
+	      var visibleTopLine = cm.lineAtHeight(info.top, "local")+1;
+	      if (cm.getCursor().line <= visibleTopLine)
+	        cm.execCommand("goLineDown");
+	    }
+	    cm.scrollTo(null, info.top + cm.defaultTextHeight());
+	  };
+
+	  cmds[map["Shift-" + ctrl + "L"] = "splitSelectionByLine"] = function(cm) {
+	    var ranges = cm.listSelections(), lineRanges = [];
+	    for (var i = 0; i < ranges.length; i++) {
+	      var from = ranges[i].from(), to = ranges[i].to();
+	      for (var line = from.line; line <= to.line; ++line)
+	        if (!(to.line > from.line && line == to.line && to.ch == 0))
+	          lineRanges.push({anchor: line == from.line ? from : Pos(line, 0),
+	                           head: line == to.line ? to : Pos(line)});
+	    }
+	    cm.setSelections(lineRanges, 0);
+	  };
+
+	  map["Shift-Tab"] = "indentLess";
+
+	  cmds[map["Esc"] = "singleSelectionTop"] = function(cm) {
+	    var range = cm.listSelections()[0];
+	    cm.setSelection(range.anchor, range.head, {scroll: false});
+	  };
+
+	  cmds[map[ctrl + "L"] = "selectLine"] = function(cm) {
+	    var ranges = cm.listSelections(), extended = [];
+	    for (var i = 0; i < ranges.length; i++) {
+	      var range = ranges[i];
+	      extended.push({anchor: Pos(range.from().line, 0),
+	                     head: Pos(range.to().line + 1, 0)});
+	    }
+	    cm.setSelections(extended);
+	  };
+
+	  map["Shift-Ctrl-K"] = "deleteLine";
+
+	  function insertLine(cm, above) {
+	    if (cm.isReadOnly()) return CodeMirror.Pass
+	    cm.operation(function() {
+	      var len = cm.listSelections().length, newSelection = [], last = -1;
+	      for (var i = 0; i < len; i++) {
+	        var head = cm.listSelections()[i].head;
+	        if (head.line <= last) continue;
+	        var at = Pos(head.line + (above ? 0 : 1), 0);
+	        cm.replaceRange("\n", at, null, "+insertLine");
+	        cm.indentLine(at.line, null, true);
+	        newSelection.push({head: at, anchor: at});
+	        last = head.line + 1;
+	      }
+	      cm.setSelections(newSelection);
+	    });
+	    cm.execCommand("indentAuto");
+	  }
+
+	  cmds[map[ctrl + "Enter"] = "insertLineAfter"] = function(cm) { return insertLine(cm, false); };
+
+	  cmds[map["Shift-" + ctrl + "Enter"] = "insertLineBefore"] = function(cm) { return insertLine(cm, true); };
+
+	  function wordAt(cm, pos) {
+	    var start = pos.ch, end = start, line = cm.getLine(pos.line);
+	    while (start && CodeMirror.isWordChar(line.charAt(start - 1))) --start;
+	    while (end < line.length && CodeMirror.isWordChar(line.charAt(end))) ++end;
+	    return {from: Pos(pos.line, start), to: Pos(pos.line, end), word: line.slice(start, end)};
+	  }
+
+	  cmds[map[ctrl + "D"] = "selectNextOccurrence"] = function(cm) {
+	    var from = cm.getCursor("from"), to = cm.getCursor("to");
+	    var fullWord = cm.state.sublimeFindFullWord == cm.doc.sel;
+	    if (CodeMirror.cmpPos(from, to) == 0) {
+	      var word = wordAt(cm, from);
+	      if (!word.word) return;
+	      cm.setSelection(word.from, word.to);
+	      fullWord = true;
+	    } else {
+	      var text = cm.getRange(from, to);
+	      var query = fullWord ? new RegExp("\\b" + text + "\\b") : text;
+	      var cur = cm.getSearchCursor(query, to);
+	      if (cur.findNext()) {
+	        cm.addSelection(cur.from(), cur.to());
+	      } else {
+	        cur = cm.getSearchCursor(query, Pos(cm.firstLine(), 0));
+	        if (cur.findNext())
+	          cm.addSelection(cur.from(), cur.to());
+	      }
+	    }
+	    if (fullWord)
+	      cm.state.sublimeFindFullWord = cm.doc.sel;
+	  };
+
+	  var mirror = "(){}[]";
+	  function selectBetweenBrackets(cm) {
+	    var pos = cm.getCursor(), opening = cm.scanForBracket(pos, -1);
+	    if (!opening) return;
+	    for (;;) {
+	      var closing = cm.scanForBracket(pos, 1);
+	      if (!closing) return;
+	      if (closing.ch == mirror.charAt(mirror.indexOf(opening.ch) + 1)) {
+	        cm.setSelection(Pos(opening.pos.line, opening.pos.ch + 1), closing.pos, false);
+	        return true;
+	      }
+	      pos = Pos(closing.pos.line, closing.pos.ch + 1);
+	    }
+	  }
+
+	  cmds[map["Shift-" + ctrl + "Space"] = "selectScope"] = function(cm) {
+	    selectBetweenBrackets(cm) || cm.execCommand("selectAll");
+	  };
+	  cmds[map["Shift-" + ctrl + "M"] = "selectBetweenBrackets"] = function(cm) {
+	    if (!selectBetweenBrackets(cm)) return CodeMirror.Pass;
+	  };
+
+	  cmds[map[ctrl + "M"] = "goToBracket"] = function(cm) {
+	    cm.extendSelectionsBy(function(range) {
+	      var next = cm.scanForBracket(range.head, 1);
+	      if (next && CodeMirror.cmpPos(next.pos, range.head) != 0) return next.pos;
+	      var prev = cm.scanForBracket(range.head, -1);
+	      return prev && Pos(prev.pos.line, prev.pos.ch + 1) || range.head;
+	    });
+	  };
+
+	  var swapLineCombo = mac ? "Cmd-Ctrl-" : "Shift-Ctrl-";
+
+	  cmds[map[swapLineCombo + "Up"] = "swapLineUp"] = function(cm) {
+	    if (cm.isReadOnly()) return CodeMirror.Pass
+	    var ranges = cm.listSelections(), linesToMove = [], at = cm.firstLine() - 1, newSels = [];
+	    for (var i = 0; i < ranges.length; i++) {
+	      var range = ranges[i], from = range.from().line - 1, to = range.to().line;
+	      newSels.push({anchor: Pos(range.anchor.line - 1, range.anchor.ch),
+	                    head: Pos(range.head.line - 1, range.head.ch)});
+	      if (range.to().ch == 0 && !range.empty()) --to;
+	      if (from > at) linesToMove.push(from, to);
+	      else if (linesToMove.length) linesToMove[linesToMove.length - 1] = to;
+	      at = to;
+	    }
+	    cm.operation(function() {
+	      for (var i = 0; i < linesToMove.length; i += 2) {
+	        var from = linesToMove[i], to = linesToMove[i + 1];
+	        var line = cm.getLine(from);
+	        cm.replaceRange("", Pos(from, 0), Pos(from + 1, 0), "+swapLine");
+	        if (to > cm.lastLine())
+	          cm.replaceRange("\n" + line, Pos(cm.lastLine()), null, "+swapLine");
+	        else
+	          cm.replaceRange(line + "\n", Pos(to, 0), null, "+swapLine");
+	      }
+	      cm.setSelections(newSels);
+	      cm.scrollIntoView();
+	    });
+	  };
+
+	  cmds[map[swapLineCombo + "Down"] = "swapLineDown"] = function(cm) {
+	    if (cm.isReadOnly()) return CodeMirror.Pass
+	    var ranges = cm.listSelections(), linesToMove = [], at = cm.lastLine() + 1;
+	    for (var i = ranges.length - 1; i >= 0; i--) {
+	      var range = ranges[i], from = range.to().line + 1, to = range.from().line;
+	      if (range.to().ch == 0 && !range.empty()) from--;
+	      if (from < at) linesToMove.push(from, to);
+	      else if (linesToMove.length) linesToMove[linesToMove.length - 1] = to;
+	      at = to;
+	    }
+	    cm.operation(function() {
+	      for (var i = linesToMove.length - 2; i >= 0; i -= 2) {
+	        var from = linesToMove[i], to = linesToMove[i + 1];
+	        var line = cm.getLine(from);
+	        if (from == cm.lastLine())
+	          cm.replaceRange("", Pos(from - 1), Pos(from), "+swapLine");
+	        else
+	          cm.replaceRange("", Pos(from, 0), Pos(from + 1, 0), "+swapLine");
+	        cm.replaceRange(line + "\n", Pos(to, 0), null, "+swapLine");
+	      }
+	      cm.scrollIntoView();
+	    });
+	  };
+
+	  cmds[map[ctrl + "/"] = "toggleCommentIndented"] = function(cm) {
+	    cm.toggleComment({ indent: true });
+	  }
+
+	  cmds[map[ctrl + "J"] = "joinLines"] = function(cm) {
+	    var ranges = cm.listSelections(), joined = [];
+	    for (var i = 0; i < ranges.length; i++) {
+	      var range = ranges[i], from = range.from();
+	      var start = from.line, end = range.to().line;
+	      while (i < ranges.length - 1 && ranges[i + 1].from().line == end)
+	        end = ranges[++i].to().line;
+	      joined.push({start: start, end: end, anchor: !range.empty() && from});
+	    }
+	    cm.operation(function() {
+	      var offset = 0, ranges = [];
+	      for (var i = 0; i < joined.length; i++) {
+	        var obj = joined[i];
+	        var anchor = obj.anchor && Pos(obj.anchor.line - offset, obj.anchor.ch), head;
+	        for (var line = obj.start; line <= obj.end; line++) {
+	          var actual = line - offset;
+	          if (line == obj.end) head = Pos(actual, cm.getLine(actual).length + 1);
+	          if (actual < cm.lastLine()) {
+	            cm.replaceRange(" ", Pos(actual), Pos(actual + 1, /^\s*/.exec(cm.getLine(actual + 1))[0].length));
+	            ++offset;
+	          }
+	        }
+	        ranges.push({anchor: anchor || head, head: head});
+	      }
+	      cm.setSelections(ranges, 0);
+	    });
+	  };
+
+	  cmds[map["Shift-" + ctrl + "D"] = "duplicateLine"] = function(cm) {
+	    cm.operation(function() {
+	      var rangeCount = cm.listSelections().length;
+	      for (var i = 0; i < rangeCount; i++) {
+	        var range = cm.listSelections()[i];
+	        if (range.empty())
+	          cm.replaceRange(cm.getLine(range.head.line) + "\n", Pos(range.head.line, 0));
+	        else
+	          cm.replaceRange(cm.getRange(range.from(), range.to()), range.from());
+	      }
+	      cm.scrollIntoView();
+	    });
+	  };
+
+	  if (!mac) map[ctrl + "T"] = "transposeChars";
+
+	  function sortLines(cm, caseSensitive) {
+	    if (cm.isReadOnly()) return CodeMirror.Pass
+	    var ranges = cm.listSelections(), toSort = [], selected;
+	    for (var i = 0; i < ranges.length; i++) {
+	      var range = ranges[i];
+	      if (range.empty()) continue;
+	      var from = range.from().line, to = range.to().line;
+	      while (i < ranges.length - 1 && ranges[i + 1].from().line == to)
+	        to = range[++i].to().line;
+	      toSort.push(from, to);
+	    }
+	    if (toSort.length) selected = true;
+	    else toSort.push(cm.firstLine(), cm.lastLine());
+
+	    cm.operation(function() {
+	      var ranges = [];
+	      for (var i = 0; i < toSort.length; i += 2) {
+	        var from = toSort[i], to = toSort[i + 1];
+	        var start = Pos(from, 0), end = Pos(to);
+	        var lines = cm.getRange(start, end, false);
+	        if (caseSensitive)
+	          lines.sort();
+	        else
+	          lines.sort(function(a, b) {
+	            var au = a.toUpperCase(), bu = b.toUpperCase();
+	            if (au != bu) { a = au; b = bu; }
+	            return a < b ? -1 : a == b ? 0 : 1;
+	          });
+	        cm.replaceRange(lines, start, end);
+	        if (selected) ranges.push({anchor: start, head: end});
+	      }
+	      if (selected) cm.setSelections(ranges, 0);
+	    });
+	  }
+
+	  cmds[map["F9"] = "sortLines"] = function(cm) { sortLines(cm, true); };
+	  cmds[map[ctrl + "F9"] = "sortLinesInsensitive"] = function(cm) { sortLines(cm, false); };
+
+	  cmds[map["F2"] = "nextBookmark"] = function(cm) {
+	    var marks = cm.state.sublimeBookmarks;
+	    if (marks) while (marks.length) {
+	      var current = marks.shift();
+	      var found = current.find();
+	      if (found) {
+	        marks.push(current);
+	        return cm.setSelection(found.from, found.to);
+	      }
+	    }
+	  };
+
+	  cmds[map["Shift-F2"] = "prevBookmark"] = function(cm) {
+	    var marks = cm.state.sublimeBookmarks;
+	    if (marks) while (marks.length) {
+	      marks.unshift(marks.pop());
+	      var found = marks[marks.length - 1].find();
+	      if (!found)
+	        marks.pop();
+	      else
+	        return cm.setSelection(found.from, found.to);
+	    }
+	  };
+
+	  cmds[map[ctrl + "F2"] = "toggleBookmark"] = function(cm) {
+	    var ranges = cm.listSelections();
+	    var marks = cm.state.sublimeBookmarks || (cm.state.sublimeBookmarks = []);
+	    for (var i = 0; i < ranges.length; i++) {
+	      var from = ranges[i].from(), to = ranges[i].to();
+	      var found = cm.findMarks(from, to);
+	      for (var j = 0; j < found.length; j++) {
+	        if (found[j].sublimeBookmark) {
+	          found[j].clear();
+	          for (var k = 0; k < marks.length; k++)
+	            if (marks[k] == found[j])
+	              marks.splice(k--, 1);
+	          break;
+	        }
+	      }
+	      if (j == found.length)
+	        marks.push(cm.markText(from, to, {sublimeBookmark: true, clearWhenEmpty: false}));
+	    }
+	  };
+
+	  cmds[map["Shift-" + ctrl + "F2"] = "clearBookmarks"] = function(cm) {
+	    var marks = cm.state.sublimeBookmarks;
+	    if (marks) for (var i = 0; i < marks.length; i++) marks[i].clear();
+	    marks.length = 0;
+	  };
+
+	  cmds[map["Alt-F2"] = "selectBookmarks"] = function(cm) {
+	    var marks = cm.state.sublimeBookmarks, ranges = [];
+	    if (marks) for (var i = 0; i < marks.length; i++) {
+	      var found = marks[i].find();
+	      if (!found)
+	        marks.splice(i--, 0);
+	      else
+	        ranges.push({anchor: found.from, head: found.to});
+	    }
+	    if (ranges.length)
+	      cm.setSelections(ranges, 0);
+	  };
+
+	  map["Alt-Q"] = "wrapLines";
+
+	  var cK = ctrl + "K ";
+
+	  function modifyWordOrSelection(cm, mod) {
+	    cm.operation(function() {
+	      var ranges = cm.listSelections(), indices = [], replacements = [];
+	      for (var i = 0; i < ranges.length; i++) {
+	        var range = ranges[i];
+	        if (range.empty()) { indices.push(i); replacements.push(""); }
+	        else replacements.push(mod(cm.getRange(range.from(), range.to())));
+	      }
+	      cm.replaceSelections(replacements, "around", "case");
+	      for (var i = indices.length - 1, at; i >= 0; i--) {
+	        var range = ranges[indices[i]];
+	        if (at && CodeMirror.cmpPos(range.head, at) > 0) continue;
+	        var word = wordAt(cm, range.head);
+	        at = word.from;
+	        cm.replaceRange(mod(word.word), word.from, word.to);
+	      }
+	    });
+	  }
+
+	  map[cK + ctrl + "Backspace"] = "delLineLeft";
+
+	  cmds[map["Backspace"] = "smartBackspace"] = function(cm) {
+	    if (cm.somethingSelected()) return CodeMirror.Pass;
+
+	    cm.operation(function() {
+	      var cursors = cm.listSelections();
+	      var indentUnit = cm.getOption("indentUnit");
+
+	      for (var i = cursors.length - 1; i >= 0; i--) {
+	        var cursor = cursors[i].head;
+	        var toStartOfLine = cm.getRange({line: cursor.line, ch: 0}, cursor);
+	        var column = CodeMirror.countColumn(toStartOfLine, null, cm.getOption("tabSize"));
+
+	        // Delete by one character by default
+	        var deletePos = cm.findPosH(cursor, -1, "char", false);
+
+	        if (toStartOfLine && !/\S/.test(toStartOfLine) && column % indentUnit == 0) {
+	          var prevIndent = new Pos(cursor.line,
+	            CodeMirror.findColumn(toStartOfLine, column - indentUnit, indentUnit));
+
+	          // Smart delete only if we found a valid prevIndent location
+	          if (prevIndent.ch != cursor.ch) deletePos = prevIndent;
+	        }
+
+	        cm.replaceRange("", deletePos, cursor, "+delete");
+	      }
+	    });
+	  };
+
+	  cmds[map[cK + ctrl + "K"] = "delLineRight"] = function(cm) {
+	    cm.operation(function() {
+	      var ranges = cm.listSelections();
+	      for (var i = ranges.length - 1; i >= 0; i--)
+	        cm.replaceRange("", ranges[i].anchor, Pos(ranges[i].to().line), "+delete");
+	      cm.scrollIntoView();
+	    });
+	  };
+
+	  cmds[map[cK + ctrl + "U"] = "upcaseAtCursor"] = function(cm) {
+	    modifyWordOrSelection(cm, function(str) { return str.toUpperCase(); });
+	  };
+	  cmds[map[cK + ctrl + "L"] = "downcaseAtCursor"] = function(cm) {
+	    modifyWordOrSelection(cm, function(str) { return str.toLowerCase(); });
+	  };
+
+	  cmds[map[cK + ctrl + "Space"] = "setSublimeMark"] = function(cm) {
+	    if (cm.state.sublimeMark) cm.state.sublimeMark.clear();
+	    cm.state.sublimeMark = cm.setBookmark(cm.getCursor());
+	  };
+	  cmds[map[cK + ctrl + "A"] = "selectToSublimeMark"] = function(cm) {
+	    var found = cm.state.sublimeMark && cm.state.sublimeMark.find();
+	    if (found) cm.setSelection(cm.getCursor(), found);
+	  };
+	  cmds[map[cK + ctrl + "W"] = "deleteToSublimeMark"] = function(cm) {
+	    var found = cm.state.sublimeMark && cm.state.sublimeMark.find();
+	    if (found) {
+	      var from = cm.getCursor(), to = found;
+	      if (CodeMirror.cmpPos(from, to) > 0) { var tmp = to; to = from; from = tmp; }
+	      cm.state.sublimeKilled = cm.getRange(from, to);
+	      cm.replaceRange("", from, to);
+	    }
+	  };
+	  cmds[map[cK + ctrl + "X"] = "swapWithSublimeMark"] = function(cm) {
+	    var found = cm.state.sublimeMark && cm.state.sublimeMark.find();
+	    if (found) {
+	      cm.state.sublimeMark.clear();
+	      cm.state.sublimeMark = cm.setBookmark(cm.getCursor());
+	      cm.setCursor(found);
+	    }
+	  };
+	  cmds[map[cK + ctrl + "Y"] = "sublimeYank"] = function(cm) {
+	    if (cm.state.sublimeKilled != null)
+	      cm.replaceSelection(cm.state.sublimeKilled, null, "paste");
+	  };
+
+	  map[cK + ctrl + "G"] = "clearBookmarks";
+	  cmds[map[cK + ctrl + "C"] = "showInCenter"] = function(cm) {
+	    var pos = cm.cursorCoords(null, "local");
+	    cm.scrollTo(null, (pos.top + pos.bottom) / 2 - cm.getScrollInfo().clientHeight / 2);
+	  };
+
+	  var selectLinesCombo = mac ? "Ctrl-Shift-" : "Ctrl-Alt-";
+	  cmds[map[selectLinesCombo + "Up"] = "selectLinesUpward"] = function(cm) {
+	    cm.operation(function() {
+	      var ranges = cm.listSelections();
+	      for (var i = 0; i < ranges.length; i++) {
+	        var range = ranges[i];
+	        if (range.head.line > cm.firstLine())
+	          cm.addSelection(Pos(range.head.line - 1, range.head.ch));
+	      }
+	    });
+	  };
+	  cmds[map[selectLinesCombo + "Down"] = "selectLinesDownward"] = function(cm) {
+	    cm.operation(function() {
+	      var ranges = cm.listSelections();
+	      for (var i = 0; i < ranges.length; i++) {
+	        var range = ranges[i];
+	        if (range.head.line < cm.lastLine())
+	          cm.addSelection(Pos(range.head.line + 1, range.head.ch));
+	      }
+	    });
+	  };
+
+	  function getTarget(cm) {
+	    var from = cm.getCursor("from"), to = cm.getCursor("to");
+	    if (CodeMirror.cmpPos(from, to) == 0) {
+	      var word = wordAt(cm, from);
+	      if (!word.word) return;
+	      from = word.from;
+	      to = word.to;
+	    }
+	    return {from: from, to: to, query: cm.getRange(from, to), word: word};
+	  }
+
+	  function findAndGoTo(cm, forward) {
+	    var target = getTarget(cm);
+	    if (!target) return;
+	    var query = target.query;
+	    var cur = cm.getSearchCursor(query, forward ? target.to : target.from);
+
+	    if (forward ? cur.findNext() : cur.findPrevious()) {
+	      cm.setSelection(cur.from(), cur.to());
+	    } else {
+	      cur = cm.getSearchCursor(query, forward ? Pos(cm.firstLine(), 0)
+	                                              : cm.clipPos(Pos(cm.lastLine())));
+	      if (forward ? cur.findNext() : cur.findPrevious())
+	        cm.setSelection(cur.from(), cur.to());
+	      else if (target.word)
+	        cm.setSelection(target.from, target.to);
+	    }
+	  };
+	  cmds[map[ctrl + "F3"] = "findUnder"] = function(cm) { findAndGoTo(cm, true); };
+	  cmds[map["Shift-" + ctrl + "F3"] = "findUnderPrevious"] = function(cm) { findAndGoTo(cm,false); };
+	  cmds[map["Alt-F3"] = "findAllUnder"] = function(cm) {
+	    var target = getTarget(cm);
+	    if (!target) return;
+	    var cur = cm.getSearchCursor(target.query);
+	    var matches = [];
+	    var primaryIndex = -1;
+	    while (cur.findNext()) {
+	      matches.push({anchor: cur.from(), head: cur.to()});
+	      if (cur.from().line <= target.from.line && cur.from().ch <= target.from.ch)
+	        primaryIndex++;
+	    }
+	    cm.setSelections(matches, primaryIndex);
+	  };
+
+	  map["Shift-" + ctrl + "["] = "fold";
+	  map["Shift-" + ctrl + "]"] = "unfold";
+	  map[cK + ctrl + "0"] = map[cK + ctrl + "J"] = "unfoldAll";
+
+	  map[ctrl + "I"] = "findIncremental";
+	  map["Shift-" + ctrl + "I"] = "findIncrementalReverse";
+	  map[ctrl + "H"] = "replace";
+	  map["F3"] = "findNext";
+	  map["Shift-F3"] = "findPrev";
+
+	  CodeMirror.normalizeKeyMap(map);
+	});
+
+
+/***/ },
+/* 277 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// CodeMirror, copyright (c) by Marijn Haverbeke and others
+	// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+	(function(mod) {
+	  if (true) // CommonJS
+	    mod(__webpack_require__(267));
+	  else if (typeof define == "function" && define.amd) // AMD
+	    define(["../../lib/codemirror"], mod);
+	  else // Plain browser env
+	    mod(CodeMirror);
+	})(function(CodeMirror) {
+	  "use strict";
+	  var Pos = CodeMirror.Pos;
+
+	  function SearchCursor(doc, query, pos, caseFold) {
+	    this.atOccurrence = false; this.doc = doc;
+	    if (caseFold == null && typeof query == "string") caseFold = false;
+
+	    pos = pos ? doc.clipPos(pos) : Pos(0, 0);
+	    this.pos = {from: pos, to: pos};
+
+	    // The matches method is filled in based on the type of query.
+	    // It takes a position and a direction, and returns an object
+	    // describing the next occurrence of the query, or null if no
+	    // more matches were found.
+	    if (typeof query != "string") { // Regexp match
+	      if (!query.global) query = new RegExp(query.source, query.ignoreCase ? "ig" : "g");
+	      this.matches = function(reverse, pos) {
+	        if (reverse) {
+	          query.lastIndex = 0;
+	          var line = doc.getLine(pos.line).slice(0, pos.ch), cutOff = 0, match, start;
+	          for (;;) {
+	            query.lastIndex = cutOff;
+	            var newMatch = query.exec(line);
+	            if (!newMatch) break;
+	            match = newMatch;
+	            start = match.index;
+	            cutOff = match.index + (match[0].length || 1);
+	            if (cutOff == line.length) break;
+	          }
+	          var matchLen = (match && match[0].length) || 0;
+	          if (!matchLen) {
+	            if (start == 0 && line.length == 0) {match = undefined;}
+	            else if (start != doc.getLine(pos.line).length) {
+	              matchLen++;
+	            }
+	          }
+	        } else {
+	          query.lastIndex = pos.ch;
+	          var line = doc.getLine(pos.line), match = query.exec(line);
+	          var matchLen = (match && match[0].length) || 0;
+	          var start = match && match.index;
+	          if (start + matchLen != line.length && !matchLen) matchLen = 1;
+	        }
+	        if (match && matchLen)
+	          return {from: Pos(pos.line, start),
+	                  to: Pos(pos.line, start + matchLen),
+	                  match: match};
+	      };
+	    } else { // String query
+	      var origQuery = query;
+	      if (caseFold) query = query.toLowerCase();
+	      var fold = caseFold ? function(str){return str.toLowerCase();} : function(str){return str;};
+	      var target = query.split("\n");
+	      // Different methods for single-line and multi-line queries
+	      if (target.length == 1) {
+	        if (!query.length) {
+	          // Empty string would match anything and never progress, so
+	          // we define it to match nothing instead.
+	          this.matches = function() {};
+	        } else {
+	          this.matches = function(reverse, pos) {
+	            if (reverse) {
+	              var orig = doc.getLine(pos.line).slice(0, pos.ch), line = fold(orig);
+	              var match = line.lastIndexOf(query);
+	              if (match > -1) {
+	                match = adjustPos(orig, line, match);
+	                return {from: Pos(pos.line, match), to: Pos(pos.line, match + origQuery.length)};
+	              }
+	             } else {
+	               var orig = doc.getLine(pos.line).slice(pos.ch), line = fold(orig);
+	               var match = line.indexOf(query);
+	               if (match > -1) {
+	                 match = adjustPos(orig, line, match) + pos.ch;
+	                 return {from: Pos(pos.line, match), to: Pos(pos.line, match + origQuery.length)};
+	               }
+	            }
+	          };
+	        }
+	      } else {
+	        var origTarget = origQuery.split("\n");
+	        this.matches = function(reverse, pos) {
+	          var last = target.length - 1;
+	          if (reverse) {
+	            if (pos.line - (target.length - 1) < doc.firstLine()) return;
+	            if (fold(doc.getLine(pos.line).slice(0, origTarget[last].length)) != target[target.length - 1]) return;
+	            var to = Pos(pos.line, origTarget[last].length);
+	            for (var ln = pos.line - 1, i = last - 1; i >= 1; --i, --ln)
+	              if (target[i] != fold(doc.getLine(ln))) return;
+	            var line = doc.getLine(ln), cut = line.length - origTarget[0].length;
+	            if (fold(line.slice(cut)) != target[0]) return;
+	            return {from: Pos(ln, cut), to: to};
+	          } else {
+	            if (pos.line + (target.length - 1) > doc.lastLine()) return;
+	            var line = doc.getLine(pos.line), cut = line.length - origTarget[0].length;
+	            if (fold(line.slice(cut)) != target[0]) return;
+	            var from = Pos(pos.line, cut);
+	            for (var ln = pos.line + 1, i = 1; i < last; ++i, ++ln)
+	              if (target[i] != fold(doc.getLine(ln))) return;
+	            if (fold(doc.getLine(ln).slice(0, origTarget[last].length)) != target[last]) return;
+	            return {from: from, to: Pos(ln, origTarget[last].length)};
+	          }
+	        };
+	      }
+	    }
+	  }
+
+	  SearchCursor.prototype = {
+	    findNext: function() {return this.find(false);},
+	    findPrevious: function() {return this.find(true);},
+
+	    find: function(reverse) {
+	      var self = this, pos = this.doc.clipPos(reverse ? this.pos.from : this.pos.to);
+	      function savePosAndFail(line) {
+	        var pos = Pos(line, 0);
+	        self.pos = {from: pos, to: pos};
+	        self.atOccurrence = false;
+	        return false;
+	      }
+
+	      for (;;) {
+	        if (this.pos = this.matches(reverse, pos)) {
+	          this.atOccurrence = true;
+	          return this.pos.match || true;
+	        }
+	        if (reverse) {
+	          if (!pos.line) return savePosAndFail(0);
+	          pos = Pos(pos.line-1, this.doc.getLine(pos.line-1).length);
+	        }
+	        else {
+	          var maxLine = this.doc.lineCount();
+	          if (pos.line == maxLine - 1) return savePosAndFail(maxLine);
+	          pos = Pos(pos.line + 1, 0);
+	        }
+	      }
+	    },
+
+	    from: function() {if (this.atOccurrence) return this.pos.from;},
+	    to: function() {if (this.atOccurrence) return this.pos.to;},
+
+	    replace: function(newText, origin) {
+	      if (!this.atOccurrence) return;
+	      var lines = CodeMirror.splitLines(newText);
+	      this.doc.replaceRange(lines, this.pos.from, this.pos.to, origin);
+	      this.pos.to = Pos(this.pos.from.line + lines.length - 1,
+	                        lines[lines.length - 1].length + (lines.length == 1 ? this.pos.from.ch : 0));
+	    }
+	  };
+
+	  // Maps a position in a case-folded line back to a position in the original line
+	  // (compensating for codepoints increasing in number during folding)
+	  function adjustPos(orig, folded, pos) {
+	    if (orig.length == folded.length) return pos;
+	    for (var pos1 = Math.min(pos, orig.length);;) {
+	      var len1 = orig.slice(0, pos1).toLowerCase().length;
+	      if (len1 < pos) ++pos1;
+	      else if (len1 > pos) --pos1;
+	      else return pos1;
+	    }
+	  }
+
+	  CodeMirror.defineExtension("getSearchCursor", function(query, pos, caseFold) {
+	    return new SearchCursor(this.doc, query, pos, caseFold);
+	  });
+	  CodeMirror.defineDocExtension("getSearchCursor", function(query, pos, caseFold) {
+	    return new SearchCursor(this, query, pos, caseFold);
+	  });
+
+	  CodeMirror.defineExtension("selectMatches", function(query, caseFold) {
+	    var ranges = [];
+	    var cur = this.getSearchCursor(query, this.getCursor("from"), caseFold);
+	    while (cur.findNext()) {
+	      if (CodeMirror.cmpPos(cur.to(), this.getCursor("to")) > 0) break;
+	      ranges.push({anchor: cur.from(), head: cur.to()});
+	    }
+	    if (ranges.length)
+	      this.setSelections(ranges, 0);
+	  });
+	});
+
+
+/***/ },
+/* 278 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var _codemirror = __webpack_require__(267);
+
+	var _codemirror2 = _interopRequireDefault(_codemirror);
+
+	var _getHintsAtPosition = __webpack_require__(279);
+
+	var _getHintsAtPosition2 = _interopRequireDefault(_getHintsAtPosition);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 * Registers a "hint" helper for CodeMirror.
+	 *
+	 * Using CodeMirror's "hint" addon: https://codemirror.net/demo/complete.html
+	 * Given an editor, this helper will take the token at the cursor and return a
+	 * list of suggested tokens.
+	 *
+	 * Options:
+	 *
+	 *   - schema: GraphQLSchema provides the hinter with positionally relevant info
+	 *
+	 * Additional Events:
+	 *
+	 *   - hasCompletion (codemirror, data, token) - signaled when the hinter has a
+	 *     new list of completion suggestions.
+	 *
+	 */
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	_codemirror2.default.registerHelper('hint', 'graphql', function (editor, options) {
+	  var schema = options.schema;
+	  if (!schema) {
+	    return;
+	  }
+
+	  var cur = editor.getCursor();
+	  var token = editor.getTokenAt(cur);
+	  var results = (0, _getHintsAtPosition2.default)(schema, editor.getValue(), cur, token);
+	  if (results && results.list && results.list.length > 0) {
+	    results.from = _codemirror2.default.Pos(results.from.line, results.from.column);
+	    results.to = _codemirror2.default.Pos(results.to.line, results.to.column);
+	    _codemirror2.default.signal(editor, 'hasCompletion', editor, results, token);
+	  }
+
+	  return results;
+	});
+
+/***/ },
+/* 279 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = getHintsAtPosition;
+
+	var _graphql = __webpack_require__(185);
+
+	var _introspection = __webpack_require__(208);
+
+	var _forEachState = __webpack_require__(280);
+
+	var _forEachState2 = _interopRequireDefault(_forEachState);
+
+	var _hintList = __webpack_require__(281);
+
+	var _hintList2 = _interopRequireDefault(_hintList);
+
+	var _objectValues = __webpack_require__(282);
+
+	var _objectValues2 = _interopRequireDefault(_objectValues);
+
+	var _runParser = __webpack_require__(283);
+
+	var _runParser2 = _interopRequireDefault(_runParser);
+
+	var _Rules = __webpack_require__(286);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 * Given GraphQLSchema, sourceText, and context of the current position within
+	 * the source text, provide a list of typeahead entries.
+	 *
+	 * Options:
+	 *   - schema: GraphQLSchema
+	 *   - sourceText: string. A raw source text used to get fragmentDefinitions
+	 *                 in a source.
+	 *   - cursor: { line: Number, column: Number }. A current cursor position.
+	 *   - token: ContextToken. Includes a context for the current cursor position.
+	 *     Includes the token string/style (type), the start/end position, and the
+	 *     state at the end of the token.
+	 *
+	 */
+
+	function getHintsAtPosition(schema, sourceText, cursor, token) {
+	  var typeInfo = getTypeInfo(schema, token.state);
+	  var state = token.state;
+	  var kind = state.kind;
+	  var step = state.step;
+
+	  if (token.type === 'comment') {
+	    return;
+	  }
+
+	  // Definition kinds
+	  if (kind === 'Document') {
+	    return (0, _hintList2.default)(cursor, token, [{ text: 'query' }, { text: 'mutation' }, { text: 'subscription' }, { text: 'fragment' }, { text: '{' }]);
+	  }
+
+	  // Field names
+	  if (kind === 'SelectionSet' || kind === 'Field' || kind === 'AliasedField') {
+	    if (typeInfo.parentType) {
+	      var fields = typeInfo.parentType.getFields ? (0, _objectValues2.default)(typeInfo.parentType.getFields()) : [];
+	      if ((0, _graphql.isAbstractType)(typeInfo.parentType)) {
+	        fields.push(_introspection.TypeNameMetaFieldDef);
+	      }
+	      if (typeInfo.parentType === schema.getQueryType()) {
+	        fields.push(_introspection.SchemaMetaFieldDef, _introspection.TypeMetaFieldDef);
+	      }
+	      return (0, _hintList2.default)(cursor, token, fields.map(function (field) {
+	        return {
+	          text: field.name,
+	          type: field.type,
+	          description: field.description
+	        };
+	      }));
+	    }
+	  }
+
+	  // Argument names
+	  if (kind === 'Arguments' || kind === 'Argument' && step === 0) {
+	    var argDefs = typeInfo.argDefs;
+	    if (argDefs) {
+	      return (0, _hintList2.default)(cursor, token, argDefs.map(function (argDef) {
+	        return {
+	          text: argDef.name,
+	          type: argDef.type,
+	          description: argDef.description
+	        };
+	      }));
+	    }
+	  }
+
+	  // Input Object fields
+	  if (kind === 'ObjectValue' || kind === 'ObjectField' && step === 0) {
+	    if (typeInfo.objectFieldDefs) {
+	      var objectFields = (0, _objectValues2.default)(typeInfo.objectFieldDefs);
+	      return (0, _hintList2.default)(cursor, token, objectFields.map(function (field) {
+	        return {
+	          text: field.name,
+	          type: field.type,
+	          description: field.description
+	        };
+	      }));
+	    }
+	  }
+
+	  // Input values: Enum and Boolean
+	  if (kind === 'EnumValue' || kind === 'ListValue' && step === 1 || kind === 'ObjectField' && step === 2 || kind === 'Argument' && step === 2) {
+	    var _ret = function () {
+	      var namedInputType = (0, _graphql.getNamedType)(typeInfo.inputType);
+	      if (namedInputType instanceof _graphql.GraphQLEnumType) {
+	        var valueMap = namedInputType.getValues();
+	        var values = (0, _objectValues2.default)(valueMap);
+	        return {
+	          v: (0, _hintList2.default)(cursor, token, values.map(function (value) {
+	            return {
+	              text: value.name,
+	              type: namedInputType,
+	              description: value.description
+	            };
+	          }))
+	        };
+	      } else if (namedInputType === _graphql.GraphQLBoolean) {
+	        return {
+	          v: (0, _hintList2.default)(cursor, token, [{ text: 'true', type: _graphql.GraphQLBoolean, description: 'Not false.' }, { text: 'false', type: _graphql.GraphQLBoolean, description: 'Not true.' }])
+	        };
+	      }
+	    }();
+
+	    if (typeof _ret === "object") return _ret.v;
+	  }
+
+	  // Fragment type conditions
+	  if (kind === 'TypeCondition' && step === 1 || kind === 'NamedType' && state.prevState.kind === 'TypeCondition') {
+	    var possibleTypes = void 0;
+	    if (typeInfo.parentType) {
+	      if ((0, _graphql.isAbstractType)(typeInfo.parentType)) {
+	        (function () {
+	          // Collect both the possible Object types as well as the interfaces
+	          // they implement.
+	          var possibleObjTypes = schema.getPossibleTypes(typeInfo.parentType);
+	          var possibleIfaceMap = Object.create(null);
+	          possibleObjTypes.forEach(function (type) {
+	            type.getInterfaces().forEach(function (iface) {
+	              possibleIfaceMap[iface.name] = iface;
+	            });
+	          });
+	          possibleTypes = possibleObjTypes.concat((0, _objectValues2.default)(possibleIfaceMap));
+	        })();
+	      } else {
+	        // The parent type is a non-abstract Object type, so the only possible
+	        // type that can be used is that same type.
+	        possibleTypes = [typeInfo.parentType];
+	      }
+	    } else {
+	      var typeMap = schema.getTypeMap();
+	      possibleTypes = (0, _objectValues2.default)(typeMap).filter(_graphql.isCompositeType);
+	    }
+	    return (0, _hintList2.default)(cursor, token, possibleTypes.map(function (type) {
+	      return {
+	        text: type.name,
+	        description: type.description
+	      };
+	    }));
+	  }
+
+	  // Fragment spread names
+	  if (kind === 'FragmentSpread' && step === 1) {
+	    var _ret3 = function () {
+	      var typeMap = schema.getTypeMap();
+	      var defState = getDefinitionState(token.state);
+	      var fragments = getFragmentDefinitions(sourceText);
+
+	      // Filter down to only the fragments which may exist here.
+	      var relevantFrags = fragments.filter(function (frag) {
+	        return (
+	          // Only include fragments with known types.
+	          typeMap[frag.typeCondition.name.value] &&
+	          // Only include fragments which are not cyclic.
+	          !(defState && defState.kind === 'FragmentDefinition' && defState.name === frag.name.value) &&
+	          // Only include fragments which could possibly be spread here.
+	          (0, _graphql.doTypesOverlap)(schema, typeInfo.parentType, typeMap[frag.typeCondition.name.value])
+	        );
+	      });
+
+	      return {
+	        v: (0, _hintList2.default)(cursor, token, relevantFrags.map(function (frag) {
+	          return {
+	            text: frag.name.value,
+	            type: typeMap[frag.typeCondition.name.value],
+	            description: 'fragment ' + frag.name.value + ' on ' + frag.typeCondition.name.value
+	          };
+	        }))
+	      };
+	    }();
+
+	    if (typeof _ret3 === "object") return _ret3.v;
+	  }
+
+	  // Variable definition types
+	  if (kind === 'VariableDefinition' && step === 2 || kind === 'ListType' && step === 1 || kind === 'NamedType' && (state.prevState.kind === 'VariableDefinition' || state.prevState.kind === 'ListType')) {
+	    var inputTypeMap = schema.getTypeMap();
+	    var inputTypes = (0, _objectValues2.default)(inputTypeMap).filter(_graphql.isInputType);
+	    return (0, _hintList2.default)(cursor, token, inputTypes.map(function (type) {
+	      return {
+	        text: type.name,
+	        description: type.description
+	      };
+	    }));
+	  }
+
+	  // Directive names
+	  if (kind === 'Directive') {
+	    var directives = schema.getDirectives().filter(function (directive) {
+	      return canUseDirective(state.prevState.kind, directive);
+	    });
+	    return (0, _hintList2.default)(cursor, token, directives.map(function (directive) {
+	      return {
+	        text: directive.name,
+	        description: directive.description
+	      };
+	    }));
+	  }
+	} /**
+	   *  Copyright (c) 2015, Facebook, Inc.
+	   *  All rights reserved.
+	   *
+	   *  This source code is licensed under the BSD-style license found in the
+	   *  LICENSE file in the root directory of this source tree. An additional grant
+	   *  of patent rights can be found in the PATENTS file in the same directory.
+	   */
+
+	function canUseDirective(kind, directive) {
+	  var locations = directive.locations;
+	  switch (kind) {
+	    case 'Query':
+	      return locations.indexOf('QUERY') !== -1;
+	    case 'Mutation':
+	      return locations.indexOf('MUTATION') !== -1;
+	    case 'Subscription':
+	      return locations.indexOf('SUBSCRIPTION') !== -1;
+	    case 'Field':
+	    case 'AliasedField':
+	      return locations.indexOf('FIELD') !== -1;
+	    case 'FragmentDefinition':
+	      return locations.indexOf('FRAGMENT_DEFINITION') !== -1;
+	    case 'FragmentSpread':
+	      return locations.indexOf('FRAGMENT_SPREAD') !== -1;
+	    case 'InlineFragment':
+	      return locations.indexOf('INLINE_FRAGMENT') !== -1;
+	  }
+	  return false;
+	}
+
+	// Utility for collecting rich type information given any token's state
+	// from the graphql-mode parser.
+	function getTypeInfo(schema, tokenState) {
+	  var info = {
+	    type: null,
+	    parentType: null,
+	    inputType: null,
+	    directiveDef: null,
+	    fieldDef: null,
+	    argDef: null,
+	    argDefs: null,
+	    objectFieldDefs: null
+	  };
+
+	  (0, _forEachState2.default)(tokenState, function (state) {
+	    switch (state.kind) {
+	      case 'Query':
+	      case 'ShortQuery':
+	        info.type = schema.getQueryType();
+	        break;
+	      case 'Mutation':
+	        info.type = schema.getMutationType();
+	        break;
+	      case 'Subscription':
+	        info.type = schema.getSubscriptionType();
+	        break;
+	      case 'InlineFragment':
+	      case 'FragmentDefinition':
+	        if (state.type) {
+	          info.type = schema.getType(state.type);
+	        }
+	        break;
+	      case 'Field':
+	        info.fieldDef = info.type && state.name ? getFieldDef(schema, info.parentType, state.name) : null;
+	        info.type = info.fieldDef && info.fieldDef.type;
+	        break;
+	      case 'SelectionSet':
+	        info.parentType = (0, _graphql.getNamedType)(info.type);
+	        break;
+	      case 'Directive':
+	        info.directiveDef = state.name && schema.getDirective(state.name);
+	        break;
+	      case 'Arguments':
+	        info.argDefs = state.prevState.kind === 'Field' ? info.fieldDef && info.fieldDef.args : state.prevState.kind === 'Directive' ? info.directiveDef && info.directiveDef.args : state.prevState.kind === 'AliasedField' ? state.prevState.name && getFieldDef(schema, info.parentType, state.prevState.name).args : null;
+	        break;
+	      case 'Argument':
+	        info.argDef = null;
+	        if (info.argDefs) {
+	          for (var i = 0; i < info.argDefs.length; i++) {
+	            if (info.argDefs[i].name === state.name) {
+	              info.argDef = info.argDefs[i];
+	              break;
+	            }
+	          }
+	        }
+	        info.inputType = info.argDef && info.argDef.type;
+	        break;
+	      case 'ListValue':
+	        var nullableType = (0, _graphql.getNullableType)(info.inputType);
+	        info.inputType = nullableType instanceof _graphql.GraphQLList ? nullableType.ofType : null;
+	        break;
+	      case 'ObjectValue':
+	        var objectType = (0, _graphql.getNamedType)(info.inputType);
+	        info.objectFieldDefs = objectType instanceof _graphql.GraphQLInputObjectType ? objectType.getFields() : null;
+	        break;
+	      case 'ObjectField':
+	        var objectField = state.name && info.objectFieldDefs ? info.objectFieldDefs[state.name] : null;
+	        info.inputType = objectField && objectField.type;
+	        break;
+	    }
+	  });
+
+	  return info;
+	}
+
+	// Finds all fragment definition ASTs in a source.
+	function getFragmentDefinitions(sourceText) {
+	  var fragmentDefs = [];
+	  (0, _runParser2.default)(sourceText, {
+	    eatWhitespace: function eatWhitespace(stream) {
+	      return stream.eatWhile(_Rules.isIgnored);
+	    },
+	    LexRules: _Rules.LexRules,
+	    ParseRules: _Rules.ParseRules
+	  }, function (stream, state) {
+	    if (state.kind === 'FragmentDefinition' && state.name && state.type) {
+	      fragmentDefs.push({
+	        kind: 'FragmentDefinition',
+	        name: {
+	          kind: 'Name',
+	          value: state.name
+	        },
+	        typeCondition: {
+	          kind: 'NamedType',
+	          name: {
+	            kind: 'Name',
+	            value: state.type
+	          }
+	        }
+	      });
+	    }
+	  });
+
+	  return fragmentDefs;
+	}
+
+	// Utility for returning the state representing the Definition this token state
+	// is within, if any.
+	function getDefinitionState(tokenState) {
+	  var definitionState = void 0;
+
+	  (0, _forEachState2.default)(tokenState, function (state) {
+	    switch (state.kind) {
+	      case 'Query':
+	      case 'ShortQuery':
+	      case 'Mutation':
+	      case 'Subscription':
+	      case 'FragmentDefinition':
+	        definitionState = state;
+	        break;
+	    }
+	  });
+
+	  return definitionState;
+	}
+
+	// Gets the field definition given a type and field name
+	function getFieldDef(schema, type, fieldName) {
+	  if (fieldName === _introspection.SchemaMetaFieldDef.name && schema.getQueryType() === type) {
+	    return _introspection.SchemaMetaFieldDef;
+	  }
+	  if (fieldName === _introspection.TypeMetaFieldDef.name && schema.getQueryType() === type) {
+	    return _introspection.TypeMetaFieldDef;
+	  }
+	  if (fieldName === _introspection.TypeNameMetaFieldDef.name && (0, _graphql.isCompositeType)(type)) {
+	    return _introspection.TypeNameMetaFieldDef;
+	  }
+	  if (type.getFields) {
+	    return type.getFields()[fieldName];
+	  }
+	}
+
+/***/ },
+/* 280 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = forEachState;
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	// Utility for iterating through a CodeMirror parse state stack bottom-up.
+	function forEachState(stack, fn) {
+	  var reverseStateStack = [];
+	  var state = stack;
+	  while (state && state.kind) {
+	    reverseStateStack.push(state);
+	    state = state.prevState;
+	  }
+	  for (var i = reverseStateStack.length - 1; i >= 0; i--) {
+	    fn(reverseStateStack[i]);
+	  }
+	}
+
+/***/ },
+/* 281 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = hintList;
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	// Create the expected hint response given a possible list and a token
+	function hintList(cursor, token, list) {
+	  var hints = filterAndSortList(list, normalizeText(token.string));
+	  if (!hints) {
+	    return;
+	  }
+
+	  var tokenStart = token.type !== null && /"|\w/.test(token.string[0]) ? token.start : token.end;
+
+	  var results = {
+	    list: hints,
+	    from: { line: cursor.line, column: tokenStart },
+	    to: { line: cursor.line, column: token.end }
+	  };
+
+	  return results;
+	}
+
+	// Given a list of hint entries and currently typed text, sort and filter to
+	// provide a concise list.
+	function filterAndSortList(list, text) {
+	  var sorted = !text ? list : list.map(function (entry) {
+	    return {
+	      proximity: getProximity(normalizeText(entry.text), text),
+	      entry: entry
+	    };
+	  }).filter(function (pair) {
+	    return pair.proximity <= 2;
+	  }).sort(function (a, b) {
+	    return a.proximity - b.proximity || a.entry.text.length - b.entry.text.length;
+	  }).map(function (pair) {
+	    return pair.entry;
+	  });
+
+	  return sorted.length > 0 ? sorted : list;
+	}
+
+	function normalizeText(text) {
+	  return text.toLowerCase().replace(/\W/g, '');
+	}
+
+	// Determine a numeric proximity for a suggestion based on current text.
+	function getProximity(suggestion, text) {
+	  // start with lexical distance
+	  var proximity = lexicalDistance(text, suggestion);
+	  if (suggestion.length > text.length) {
+	    // do not penalize long suggestions.
+	    proximity -= suggestion.length - text.length - 1;
+	    // penalize suggestions not starting with this phrase
+	    proximity += suggestion.indexOf(text) === 0 ? 0 : 0.5;
+	  }
+	  return proximity;
+	}
+
+	/**
+	 * Computes the lexical distance between strings A and B.
+	 *
+	 * The "distance" between two strings is given by counting the minimum number
+	 * of edits needed to transform string A into string B. An edit can be an
+	 * insertion, deletion, or substitution of a single character, or a swap of two
+	 * adjacent characters.
+	 *
+	 * This distance can be useful for detecting typos in input or sorting
+	 *
+	 * @param {string} a
+	 * @param {string} b
+	 * @return {int} distance in number of edits
+	 */
+	function lexicalDistance(a, b) {
+	  var i = void 0;
+	  var j = void 0;
+	  var d = [];
+	  var aLength = a.length;
+	  var bLength = b.length;
+
+	  for (i = 0; i <= aLength; i++) {
+	    d[i] = [i];
+	  }
+
+	  for (j = 1; j <= bLength; j++) {
+	    d[0][j] = j;
+	  }
+
+	  for (i = 1; i <= aLength; i++) {
+	    for (j = 1; j <= bLength; j++) {
+	      var cost = a[i - 1] === b[j - 1] ? 0 : 1;
+
+	      d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+
+	      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+	        d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + cost);
+	      }
+	    }
+	  }
+
+	  return d[aLength][bLength];
+	}
+
+/***/ },
+/* 282 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = objectValues;
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function objectValues(object) {
+	  var keys = Object.keys(object);
+	  var len = keys.length;
+	  var values = new Array(len);
+	  for (var i = 0; i < len; ++i) {
+	    values[i] = object[keys[i]];
+	  }
+	  return values;
+	}
+
+/***/ },
+/* 283 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = runParser;
+
+	var _CharacterStream = __webpack_require__(284);
+
+	var _CharacterStream2 = _interopRequireDefault(_CharacterStream);
+
+	var _onlineParser = __webpack_require__(285);
+
+	var _onlineParser2 = _interopRequireDefault(_onlineParser);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function runParser(sourceText, parserOptions, callbackFn) {
+	  var parser = (0, _onlineParser2.default)(parserOptions);
+	  var state = parser.startState();
+	  var lines = sourceText.split('\n');
+
+	  lines.forEach(function (line) {
+	    var stream = new _CharacterStream2.default(line);
+	    while (!stream.eol()) {
+	      var style = parser.token(stream, state);
+	      callbackFn(stream, state, style);
+	    }
+	  });
+	}
+
+/***/ },
+/* 284 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	/**
+	 * CharacterStream implements a stream of character tokens given a source text.
+	 * The API design follows that of CodeMirror.StringStream.
+	 *
+	 * Required:
+	 *
+	 *      sourceText: (string), A raw GraphQL source text. Works best if a line
+	 *        is supplied.
+	 *
+	 */
+
+	var CharacterStream = function () {
+	  function CharacterStream(sourceText) {
+	    _classCallCheck(this, CharacterStream);
+
+	    this._start = 0;
+	    this._pos = 0;
+	    this._sourceText = sourceText;
+	  }
+
+	  CharacterStream.prototype.getStartOfToken = function getStartOfToken() {
+	    return this._start;
+	  };
+
+	  CharacterStream.prototype.getCurrentPosition = function getCurrentPosition() {
+	    return this._pos;
+	  };
+
+	  CharacterStream.prototype._testNextCharacter = function _testNextCharacter(pattern) {
+	    var character = this._sourceText.charAt(this._pos);
+	    return typeof pattern === 'string' ? character === pattern : pattern.test ? pattern.test(character) : pattern(character);
+	  };
+
+	  CharacterStream.prototype.eol = function eol() {
+	    return this._sourceText.length === this._pos;
+	  };
+
+	  CharacterStream.prototype.sol = function sol() {
+	    return this._pos === 0;
+	  };
+
+	  CharacterStream.prototype.peek = function peek() {
+	    return this._sourceText.charAt(this._pos) ? this._sourceText.charAt(this._pos) : null;
+	  };
+
+	  CharacterStream.prototype.next = function next() {
+	    var char = this._sourceText.charAt(this._pos);
+	    this._pos++;
+	    return char;
+	  };
+
+	  CharacterStream.prototype.eat = function eat(pattern) {
+	    var isMatched = this._testNextCharacter(pattern);
+	    if (isMatched) {
+	      this._start = this._pos;
+	      this._pos++;
+	      return this._sourceText.charAt(this._pos - 1);
+	    }
+	    return undefined;
+	  };
+
+	  CharacterStream.prototype.eatWhile = function eatWhile(match) {
+	    var isMatched = this._testNextCharacter(match);
+	    var didEat = false;
+
+	    // If a match, treat the total upcoming matches as one token
+	    if (isMatched) {
+	      didEat = isMatched;
+	      this._start = this._pos;
+	    }
+
+	    while (isMatched) {
+	      this._pos++;
+	      isMatched = this._testNextCharacter(match);
+	      didEat = true;
+	    }
+
+	    return didEat;
+	  };
+
+	  CharacterStream.prototype.eatSpace = function eatSpace() {
+	    return this.eatWhile(/[\s\u00a0]/);
+	  };
+
+	  CharacterStream.prototype.skipToEnd = function skipToEnd() {
+	    this._pos = this._sourceText.length;
+	  };
+
+	  CharacterStream.prototype.skipTo = function skipTo(position) {
+	    this._pos = position;
+	  };
+
+	  CharacterStream.prototype.match = function match(pattern) {
+	    var consume = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+	    var caseFold = arguments[2];
+
+	    var token = null;
+	    var match = null;
+
+	    switch (typeof pattern) {
+	      case 'string':
+	        var regex = new RegExp(pattern, caseFold ? 'i' : '');
+	        match = regex.test(this._sourceText.substr(this._pos, pattern.length));
+	        token = pattern;
+	        break;
+	      case 'object': // RegExp
+	      case 'function':
+	        match = this._sourceText.slice(this._pos).match(pattern);
+	        token = match && match[0];
+	        break;
+	    }
+
+	    if (match && (typeof pattern === 'string' || match.index === 0)) {
+	      if (consume) {
+	        this._start = this._pos;
+	        this._pos += token.length;
+	      }
+	      return match;
+	    }
+
+	    // No match available.
+	    return false;
+	  };
+
+	  CharacterStream.prototype.backUp = function backUp(num) {
+	    this._pos -= num;
+	  };
+
+	  CharacterStream.prototype.column = function column() {
+	    return this._pos;
+	  };
+
+	  CharacterStream.prototype.indentation = function indentation() {
+	    var match = this._sourceText.match(/\s*/);
+	    var indent = 0;
+	    if (match && match.index === 0) {
+	      var whitespaces = match[0];
+	      var pos = 0;
+	      while (whitespaces.length > pos) {
+	        if (whitespaces.charCodeAt(pos) === 9) {
+	          indent += 2;
+	        } else {
+	          indent++;
+	        }
+	        pos++;
+	      }
+	    }
+
+	    return indent;
+	  };
+
+	  CharacterStream.prototype.current = function current() {
+	    return this._sourceText.slice(this._start, this._pos);
+	  };
+
+	  return CharacterStream;
+	}();
+
+	exports.default = CharacterStream;
+
+/***/ },
+/* 285 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = onlineParser;
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	/**
+	 * Builds an online immutable parser, designed to be used as part of a syntax
+	 * highlighting and code intelligence tools.
+	 *
+	 * Options:
+	 *
+	 *     eatWhitespace: (
+	 *       stream: Stream | CodeMirror.StringStream | CharacterStream
+	 *     ) => boolean
+	 *       Use CodeMirror API.
+	 *
+	 *     LexRules: { [name: string]: RegExp }, Includes `Punctuation`.
+	 *
+	 *     ParseRules: { [name: string]: Array<Rule> }, Includes `Document`.
+	 *
+	 *     editorConfig: { [name: string]: mixed }, Provides an editor-specific
+	 *       configurations set.
+	 *
+	 */
+
+	function onlineParser(options) {
+	  return {
+	    startState: function startState() {
+	      var initialState = { level: 0 };
+	      pushRule(options.ParseRules, initialState, 'Document');
+	      return initialState;
+	    },
+	    token: function token(stream, state) {
+	      return getToken(stream, state, options);
+	    }
+	  };
+	}
+
+	function getToken(stream, state, options) {
+	  var LexRules = options.LexRules,
+	      ParseRules = options.ParseRules,
+	      eatWhitespace = options.eatWhitespace,
+	      editorConfig = options.editorConfig;
+
+	  if (state.needsAdvance) {
+	    state.needsAdvance = false;
+	    advanceRule(state, true);
+	  }
+
+	  // Remember initial indentation
+	  if (stream.sol()) {
+	    var tabSize = editorConfig && editorConfig.tabSize || 2;
+	    state.indentLevel = Math.floor(stream.indentation() / tabSize);
+	  }
+
+	  // Consume spaces and ignored characters
+	  if (eatWhitespace(stream)) {
+	    return 'ws';
+	  }
+
+	  // Peek a character forward and skip the entire line if it's a comment line
+	  if (stream.peek() === '#') {
+	    stream.skipToEnd();
+	    return 'comment';
+	  }
+
+	  // Get a matched token from the stream, using lex
+	  var token = lex(LexRules, stream);
+
+	  // If there's no matching token, skip ahead.
+	  if (!token) {
+	    stream.match(/\S+/);
+	    return 'invalidchar';
+	  }
+
+	  // Save state before continuing.
+	  saveState(state);
+
+	  // Handle changes in expected indentation level
+	  if (token.kind === 'Punctuation') {
+	    if (/^[{([]/.test(token.value)) {
+	      // Push on the stack of levels one level deeper than the current level.
+	      state.levels = (state.levels || []).concat(state.indentLevel + 1);
+	    } else if (/^[})\]]/.test(token.value)) {
+	      // Pop from the stack of levels.
+	      // If the top of the stack is lower than the current level, lower the
+	      // current level to match.
+	      var levels = state.levels = (state.levels || []).slice(0, -1);
+	      if (levels.length > 0 && levels[levels.length - 1] < state.indentLevel) {
+	        state.indentLevel = levels[levels.length - 1];
+	      }
+	    }
+	  }
+
+	  while (state.rule) {
+	    // If this is a forking rule, determine what rule to use based on
+	    // the current token, otherwise expect based on the current step.
+	    var expected = typeof state.rule === 'function' ? state.step === 0 ? state.rule(token, stream) : null : state.rule[state.step];
+
+	    // Seperator between list elements if necessary.
+	    if (state.needsSeperator) {
+	      expected = expected && expected.separator;
+	    }
+
+	    if (expected) {
+	      // Un-wrap optional/list ParseRules.
+	      if (expected.ofRule) {
+	        expected = expected.ofRule;
+	      }
+
+	      // A string represents a Rule
+	      if (typeof expected === 'string') {
+	        pushRule(ParseRules, state, expected);
+	        continue;
+	      }
+
+	      // Otherwise, match a Terminal.
+	      if (expected.match && expected.match(token)) {
+	        if (expected.update) {
+	          expected.update(state, token);
+	        }
+
+	        // If this token was a punctuator, advance the parse rule, otherwise
+	        // mark the state to be advanced before the next token. This ensures
+	        // that tokens which can be appended to keep the appropriate state.
+	        if (token.kind === 'Punctuation') {
+	          advanceRule(state, true);
+	        } else {
+	          state.needsAdvance = true;
+	        }
+
+	        return expected.style;
+	      }
+	    }
+
+	    unsuccessful(state);
+	  }
+
+	  // The parser does not know how to interpret this token, do not affect state.
+	  restoreState(state);
+	  return 'invalidchar';
+	}
+
+	function assign(to, from) {
+	  var keys = Object.keys(from);
+	  for (var i = 0; i < keys.length; i++) {
+	    to[keys[i]] = from[keys[i]];
+	  }
+	  return to;
+	}
+
+	var stateCache = {};
+
+	// Save the current state in the cache.
+	function saveState(state) {
+	  assign(stateCache, state);
+	}
+
+	// Restore from the state cache.
+	function restoreState(state) {
+	  assign(state, stateCache);
+	}
+
+	// Push a new rule onto the state.
+	function pushRule(ParseRules, state, ruleKind) {
+	  if (!ParseRules[ruleKind]) {
+	    throw new TypeError('Unknown rule: ' + ruleKind);
+	  }
+	  state.prevState = assign({}, state);
+	  state.kind = ruleKind;
+	  state.name = null;
+	  state.type = null;
+	  state.rule = ParseRules[ruleKind];
+	  state.step = 0;
+	  state.needsSeperator = false;
+	}
+
+	// Pop the current rule from the state.
+	function popRule(state) {
+	  state.kind = state.prevState.kind;
+	  state.name = state.prevState.name;
+	  state.type = state.prevState.type;
+	  state.rule = state.prevState.rule;
+	  state.step = state.prevState.step;
+	  state.needsSeperator = state.prevState.needsSeperator;
+	  state.prevState = state.prevState.prevState;
+	}
+
+	// Advance the step of the current rule.
+	function advanceRule(state, successful) {
+	  // If this is advancing successfully and the current state is a list, give
+	  // it an opportunity to repeat itself.
+	  if (isList(state)) {
+	    if (state.rule[state.step].separator) {
+	      state.needsSeperator = !state.needsSeperator;
+	      // If the next list iteration might accept a non-separator, then give it
+	      // an opportunity to repeat.
+	      if (!state.needsSeperator) {
+	        return;
+	      }
+	    }
+	    // If this was a successful list parse, then allow it to repeat itself.
+	    if (successful) {
+	      return;
+	    }
+	  }
+
+	  // Advance the step in the rule. If the rule is completed, pop
+	  // the rule and advance the parent rule as well (recursively).
+	  state.needsSeperator = false;
+	  state.step++;
+	  // While the current rule is completed.
+	  while (state.rule && !(Array.isArray(state.rule) && state.step < state.rule.length)) {
+	    popRule(state);
+
+	    if (state.rule) {
+	      // Do not advance a List step so it has the opportunity to repeat itself.
+	      if (isList(state)) {
+	        if (state.rule[state.step].separator) {
+	          state.needsSeperator = !state.needsSeperator;
+	        }
+	      } else {
+	        state.needsSeperator = false;
+	        state.step++;
+	      }
+	    }
+	  }
+	}
+
+	function isList(state) {
+	  return Array.isArray(state.rule) && state.rule[state.step].isList;
+	}
+
+	// Unwind the state after an unsuccessful match.
+	function unsuccessful(state) {
+	  // Fall back to the parent rule until you get to an optional or list rule or
+	  // until the entire stack of rules is empty.
+	  while (state.rule && !(Array.isArray(state.rule) && state.rule[state.step].ofRule)) {
+	    popRule(state);
+	  }
+
+	  // If there is still a rule, it must be an optional or list rule.
+	  // Consider this rule a success so that we may move past it.
+	  if (state.rule) {
+	    advanceRule(state, false);
+	  }
+	}
+
+	// Given a stream, returns a { kind, value } pair, or null.
+	function lex(LexRules, stream) {
+	  var kinds = Object.keys(LexRules);
+	  for (var i = 0; i < kinds.length; i++) {
+	    var match = stream.match(LexRules[kinds[i]]);
+	    if (match) {
+	      return { kind: kinds[i], value: match[0] };
+	    }
+	  }
+	}
+
+/***/ },
+/* 286 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.ParseRules = exports.LexRules = exports.isIgnored = undefined;
+
+	var _RuleHelpers = __webpack_require__(287);
+
+	/**
+	 * Whitespace tokens defined in GraphQL spec.
+	 */
+	var isIgnored = exports.isIgnored = function isIgnored(ch) {
+	  return ch === ' ' || ch === '\t' || ch === ',' || ch === '\n' || ch === '\r' || ch === '\uFEFF';
+	};
+
+	/**
+	 * The lexer rules. These are exactly as described by the spec.
+	 */
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	var LexRules = exports.LexRules = {
+	  // The Name token.
+	  Name: /^[_A-Za-z][_0-9A-Za-z]*/,
+
+	  // All Punctuation used in GraphQL
+	  Punctuation: /^(?:!|\$|\(|\)|\.\.\.|:|=|@|\[|]|\{|\||\})/,
+
+	  // Combines the IntValue and FloatValue tokens.
+	  Number: /^-?(?:0|(?:[1-9][0-9]*))(?:\.[0-9]*)?(?:[eE][+-]?[0-9]+)?/,
+
+	  // Note the closing quote is made optional as an IDE experience improvment.
+	  String: /^"(?:[^"\\]|\\(?:"|\/|\\|b|f|n|r|t|u[0-9a-fA-F]{4}))*"?/
+	};
+
+	/**
+	 * The parser rules. These are very close to, but not exactly the same as the
+	 * spec. Minor deviations allow for a simpler implementation. The resulting
+	 * parser can parse everything the spec declares possible.
+	 */
+	var ParseRules = exports.ParseRules = {
+	  Document: [(0, _RuleHelpers.list)('Definition')],
+	  Definition: function Definition(token) {
+	    switch (token.value) {
+	      case '{':
+	        return 'ShortQuery';
+	      case 'query':
+	        return 'Query';
+	      case 'mutation':
+	        return 'Mutation';
+	      case 'subscription':
+	        return 'Subscription';
+	      case 'fragment':
+	        return 'FragmentDefinition';
+	      case 'schema':
+	        return 'SchemaDef';
+	      case 'scalar':
+	        return 'ScalarDef';
+	      case 'type':
+	        return 'ObjectTypeDef';
+	      case 'interface':
+	        return 'InterfaceDef';
+	      case 'union':
+	        return 'UnionDef';
+	      case 'enum':
+	        return 'EnumDef';
+	      case 'input':
+	        return 'InputDef';
+	      case 'extend':
+	        return 'ExtendDef';
+	      case 'directive':
+	        return 'DirectiveDef';
+	    }
+	  },
+
+	  // Note: instead of "Operation", these rules have been separated out.
+	  ShortQuery: ['SelectionSet'],
+	  Query: [word('query'), (0, _RuleHelpers.opt)(name('def')), (0, _RuleHelpers.opt)('VariableDefinitions'), (0, _RuleHelpers.list)('Directive'), 'SelectionSet'],
+	  Mutation: [word('mutation'), (0, _RuleHelpers.opt)(name('def')), (0, _RuleHelpers.opt)('VariableDefinitions'), (0, _RuleHelpers.list)('Directive'), 'SelectionSet'],
+	  Subscription: [word('subscription'), (0, _RuleHelpers.opt)(name('def')), (0, _RuleHelpers.opt)('VariableDefinitions'), (0, _RuleHelpers.list)('Directive'), 'SelectionSet'],
+	  VariableDefinitions: [(0, _RuleHelpers.p)('('), (0, _RuleHelpers.list)('VariableDefinition'), (0, _RuleHelpers.p)(')')],
+	  VariableDefinition: ['Variable', (0, _RuleHelpers.p)(':'), 'Type', (0, _RuleHelpers.opt)('DefaultValue')],
+	  Variable: [(0, _RuleHelpers.p)('$', 'variable'), name('variable')],
+	  DefaultValue: [(0, _RuleHelpers.p)('='), 'Value'],
+	  SelectionSet: [(0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('Selection'), (0, _RuleHelpers.p)('}')],
+	  Selection: function Selection(token, stream) {
+	    return token.value === '...' ? stream.match(/[\s\u00a0,]*(on\b|@|{)/, false) ? 'InlineFragment' : 'FragmentSpread' : stream.match(/[\s\u00a0,]*:/, false) ? 'AliasedField' : 'Field';
+	  },
+
+	  // Note: this minor deviation of "AliasedField" simplifies the lookahead.
+	  AliasedField: [name('property'), (0, _RuleHelpers.p)(':'), name('qualifier'), (0, _RuleHelpers.opt)('Arguments'), (0, _RuleHelpers.list)('Directive'), (0, _RuleHelpers.opt)('SelectionSet')],
+	  Field: [name('property'), (0, _RuleHelpers.opt)('Arguments'), (0, _RuleHelpers.list)('Directive'), (0, _RuleHelpers.opt)('SelectionSet')],
+	  Arguments: [(0, _RuleHelpers.p)('('), (0, _RuleHelpers.list)('Argument'), (0, _RuleHelpers.p)(')')],
+	  Argument: [name('attribute'), (0, _RuleHelpers.p)(':'), 'Value'],
+	  FragmentSpread: [(0, _RuleHelpers.p)('...'), name('def'), (0, _RuleHelpers.list)('Directive')],
+	  InlineFragment: [(0, _RuleHelpers.p)('...'), (0, _RuleHelpers.opt)('TypeCondition'), (0, _RuleHelpers.list)('Directive'), 'SelectionSet'],
+	  FragmentDefinition: [word('fragment'), (0, _RuleHelpers.opt)((0, _RuleHelpers.butNot)(name('def'), [word('on')])), 'TypeCondition', (0, _RuleHelpers.list)('Directive'), 'SelectionSet'],
+	  TypeCondition: [word('on'), type('atom')],
+	  // Variables could be parsed in cases where only Const is expected by spec.
+	  Value: function Value(token) {
+	    switch (token.kind) {
+	      case 'Number':
+	        return 'NumberValue';
+	      case 'String':
+	        return 'StringValue';
+	      case 'Punctuation':
+	        switch (token.value) {
+	          case '[':
+	            return 'ListValue';
+	          case '{':
+	            return 'ObjectValue';
+	          case '$':
+	            return 'Variable';
+	        }
+	        return null;
+	      case 'Name':
+	        switch (token.value) {
+	          case 'true':case 'false':
+	            return 'BooleanValue';
+	        }
+	        if (token.value === 'null') {
+	          return 'NullValue';
+	        }
+	        return 'EnumValue';
+	    }
+	  },
+
+	  NumberValue: [(0, _RuleHelpers.t)('Number', 'number')],
+	  StringValue: [(0, _RuleHelpers.t)('String', 'string')],
+	  BooleanValue: [(0, _RuleHelpers.t)('Name', 'builtin')],
+	  NullValue: [(0, _RuleHelpers.t)('Name', 'keyword')],
+	  EnumValue: [name('string-2')],
+	  ListValue: [(0, _RuleHelpers.p)('['), (0, _RuleHelpers.list)('Value'), (0, _RuleHelpers.p)(']')],
+	  ObjectValue: [(0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('ObjectField'), (0, _RuleHelpers.p)('}')],
+	  ObjectField: [name('attribute'), (0, _RuleHelpers.p)(':'), 'Value'],
+	  Type: function Type(token) {
+	    return token.value === '[' ? 'ListType' : 'NamedType';
+	  },
+
+	  // NonNullType has been merged into ListType and NamedType to simplify.
+	  ListType: [(0, _RuleHelpers.p)('['), 'Type', (0, _RuleHelpers.p)(']'), (0, _RuleHelpers.opt)((0, _RuleHelpers.p)('!'))],
+	  NamedType: [name('atom'), (0, _RuleHelpers.opt)((0, _RuleHelpers.p)('!'))],
+	  Directive: [(0, _RuleHelpers.p)('@', 'meta'), name('meta'), (0, _RuleHelpers.opt)('Arguments')],
+	  // GraphQL schema language
+	  SchemaDef: [word('schema'), (0, _RuleHelpers.list)('Directive'), (0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('OperationTypeDef'), (0, _RuleHelpers.p)('}')],
+	  OperationTypeDef: [name('keyword'), (0, _RuleHelpers.p)(':'), name('atom')],
+	  ScalarDef: [word('scalar'), name('atom'), (0, _RuleHelpers.list)('Directive')],
+	  ObjectTypeDef: [word('type'), name('atom'), (0, _RuleHelpers.opt)('Implements'), (0, _RuleHelpers.list)('Directive'), (0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('FieldDef'), (0, _RuleHelpers.p)('}')],
+	  Implements: [word('implements'), (0, _RuleHelpers.list)(name('atom'))],
+	  FieldDef: [name('property'), (0, _RuleHelpers.opt)('ArgumentsDef'), (0, _RuleHelpers.p)(':'), 'Type', (0, _RuleHelpers.list)('Directive')],
+	  ArgumentsDef: [(0, _RuleHelpers.p)('('), (0, _RuleHelpers.list)('InputValueDef'), (0, _RuleHelpers.p)(')')],
+	  InputValueDef: [name('attribute'), (0, _RuleHelpers.p)(':'), 'Type', (0, _RuleHelpers.opt)('DefaultValue'), (0, _RuleHelpers.list)('Directive')],
+	  InterfaceDef: [word('interface'), name('atom'), (0, _RuleHelpers.list)('Directive'), (0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('FieldDef'), (0, _RuleHelpers.p)('}')],
+	  UnionDef: [word('union'), name('atom'), (0, _RuleHelpers.list)('Directive'), (0, _RuleHelpers.p)('='), name('atom'), (0, _RuleHelpers.list)('UnionMember')],
+	  UnionMember: [(0, _RuleHelpers.p)('|'), name('atom')],
+	  EnumDef: [word('enum'), name('atom'), (0, _RuleHelpers.list)('Directive'), (0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('EnumValueDef'), (0, _RuleHelpers.p)('}')],
+	  EnumValueDef: [name('string-2'), (0, _RuleHelpers.list)('Directive')],
+	  InputDef: [word('input'), name('atom'), (0, _RuleHelpers.list)('Directive'), (0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('InputValueDef'), (0, _RuleHelpers.p)('}')],
+	  ExtendDef: [word('extend'), 'ObjectTypeDef'],
+	  DirectiveDef: [word('directive'), (0, _RuleHelpers.p)('@', 'meta'), name('meta'), (0, _RuleHelpers.opt)('ArgumentsDef'), word('on'), name('string-2'), (0, _RuleHelpers.list)('DirectiveLocation')],
+	  DirectiveLocation: [(0, _RuleHelpers.p)('|'), name('string-2')]
+	};
+
+	// A keyword Token.
+	function word(value) {
+	  return {
+	    style: 'keyword',
+	    match: function match(token) {
+	      return token.kind === 'Name' && token.value === value;
+	    }
+	  };
+	}
+
+	// A Name Token which will decorate the state with a `name`.
+	function name(style) {
+	  return {
+	    style: style,
+	    match: function match(token) {
+	      return token.kind === 'Name';
+	    },
+	    update: function update(state, token) {
+	      state.name = token.value;
+	    }
+	  };
+	}
+
+	// A Name Token which will decorate the previous state with a `type`.
+	function type(style) {
+	  return {
+	    style: style,
+	    match: function match(token) {
+	      return token.kind === 'Name';
+	    },
+	    update: function update(state, token) {
+	      state.prevState.type = token.value;
+	    }
+	  };
+	}
+
+/***/ },
+/* 287 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.opt = opt;
+	exports.list = list;
+	exports.butNot = butNot;
+	exports.t = t;
+	exports.p = p;
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+	// These functions help build matching rules for ParseRules.
+
+	// An optional rule.
+	function opt(ofRule) {
+	  return { ofRule: ofRule };
+	}
+
+	// A list of another rule.
+	function list(ofRule, separator) {
+	  return { ofRule: ofRule, isList: true, separator: separator };
+	}
+
+	// An constraint described as `but not` in the GraphQL spec.
+	function butNot(rule, exclusions) {
+	  var ruleMatch = rule.match;
+	  rule.match = function (token) {
+	    return ruleMatch(token) && exclusions.every(function (exclusion) {
+	      return !exclusion.match(token);
+	    });
+	  };
+	  return rule;
+	}
+
+	// Token of a kind
+	function t(kind, style) {
+	  return { style: style, match: function match(token) {
+	      return token.kind === kind;
+	    } };
+	}
+
+	// Punctuator
+	function p(value, style) {
+	  return {
+	    style: style || 'punctuation',
+	    match: function match(token) {
+	      return token.kind === 'Punctuation' && token.value === value;
+	    }
+	  };
+	}
+
+/***/ },
+/* 288 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var _codemirror = __webpack_require__(267);
+
+	var _codemirror2 = _interopRequireDefault(_codemirror);
+
+	var _graphql = __webpack_require__(185);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 * Registers a "lint" helper for CodeMirror.
+	 *
+	 * Using CodeMirror's "lint" addon: https://codemirror.net/demo/lint.html
+	 * Given the text within an editor, this helper will take that text and return
+	 * a list of linter issues, derived from GraphQL's parse and validate steps.
+	 *
+	 * Options:
+	 *
+	 *   - schema: GraphQLSchema provides the linter with positionally relevant info
+	 *
+	 */
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	_codemirror2.default.registerHelper('lint', 'graphql', function (text, options, editor) {
+	  var schema = options.schema;
+	  try {
+	    var ast = (0, _graphql.parse)(text);
+	    var errors = schema ? (0, _graphql.validate)(schema, ast) : [];
+	    return mapCat(errors, function (error) {
+	      return errorAnnotations(editor, error);
+	    });
+	  } catch (error) {
+	    var location = error.locations[0];
+	    var pos = _codemirror2.default.Pos(location.line - 1, location.column);
+	    var token = editor.getTokenAt(pos);
+	    return [{
+	      message: error.message,
+	      severity: 'error',
+	      type: 'syntax',
+	      from: _codemirror2.default.Pos(location.line - 1, token.start),
+	      to: _codemirror2.default.Pos(location.line - 1, token.end)
+	    }];
+	  }
+	});
+
+	function errorAnnotations(editor, error) {
+	  return error.nodes.map(function (node) {
+	    var highlightNode = node.kind !== 'Variable' && node.name ? node.name : node.variable ? node.variable : node;
+	    return {
+	      message: error.message,
+	      severity: 'error',
+	      type: 'validation',
+	      from: editor.posFromIndex(highlightNode.loc.start),
+	      to: editor.posFromIndex(highlightNode.loc.end)
+	    };
+	  });
+	}
+
+	// General utility for map-cating (aka flat-mapping).
+	function mapCat(array, mapper) {
+	  return Array.prototype.concat.apply([], array.map(mapper));
+	}
+
+/***/ },
+/* 289 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var _codemirror = __webpack_require__(267);
+
+	var _codemirror2 = _interopRequireDefault(_codemirror);
+
+	var _onlineParser = __webpack_require__(285);
+
+	var _onlineParser2 = _interopRequireDefault(_onlineParser);
+
+	var _Rules = __webpack_require__(286);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 * The GraphQL mode is defined as a tokenizer along with a list of rules, each
+	 * of which is either a function or an array.
+	 *
+	 *   * Function: Provided a token and the stream, returns an expected next step.
+	 *   * Array: A list of steps to take in order.
+	 *
+	 * A step is either another rule, or a terminal description of a token. If it
+	 * is a rule, that rule is pushed onto the stack and the parsing continues from
+	 * that point.
+	 *
+	 * If it is a terminal description, the token is checked against it using a
+	 * `match` function. If the match is successful, the token is colored and the
+	 * rule is stepped forward. If the match is unsuccessful, the remainder of the
+	 * rule is skipped and the previous rule is advanced.
+	 *
+	 * This parsing algorithm allows for incremental online parsing within various
+	 * levels of the syntax tree and results in a structured `state` linked-list
+	 * which contains the relevant information to produce valuable typeaheads.
+	 */
+	_codemirror2.default.defineMode('graphql', function (config) {
+	  var parser = (0, _onlineParser2.default)({
+	    eatWhitespace: function eatWhitespace(stream) {
+	      return stream.eatWhile(_Rules.isIgnored);
+	    },
+	    LexRules: _Rules.LexRules,
+	    ParseRules: _Rules.ParseRules,
+	    editorConfig: { tabSize: config.tabSize }
+	  });
+
+	  return {
+	    config: config,
+	    startState: parser.startState,
+	    token: parser.token,
+	    indent: indent,
+	    electricInput: /^\s*[})\]]/,
+	    fold: 'brace',
+	    lineComment: '#',
+	    closeBrackets: {
+	      pairs: '()[]{}""',
+	      explode: '()[]{}'
+	    }
+	  };
+	}); /**
+	     *  Copyright (c) 2015, Facebook, Inc.
+	     *  All rights reserved.
+	     *
+	     *  This source code is licensed under the BSD-style license found in the
+	     *  LICENSE file in the root directory of this source tree. An additional grant
+	     *  of patent rights can be found in the PATENTS file in the same directory.
+	     */
+
+	function indent(state, textAfter) {
+	  var levels = state.levels;
+	  // If there is no stack of levels, use the current level.
+	  // Otherwise, use the top level, pre-emptively dedenting for close braces.
+	  var level = !levels || levels.length === 0 ? state.indentLevel : levels[levels.length - 1] - (this.electricInput.test(textAfter) ? 1 : 0);
+	  return level * this.config.indentUnit;
+	}
+
+/***/ },
+/* 290 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.VariableEditor = undefined;
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _react = __webpack_require__(1);
+
+	var _react2 = _interopRequireDefault(_react);
+
+	var _reactDom = __webpack_require__(32);
+
+	var _reactDom2 = _interopRequireDefault(_reactDom);
+
+	var _onHasCompletion = __webpack_require__(265);
+
+	var _onHasCompletion2 = _interopRequireDefault(_onHasCompletion);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /**
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  Copyright (c) 2015, Facebook, Inc.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  All rights reserved.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  This source code is licensed under the license found in the
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  LICENSE-examples file in the root directory of this source tree.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
+
+	/**
+	 * VariableEditor
+	 *
+	 * An instance of CodeMirror for editing variables defined in QueryEditor.
+	 *
+	 * Props:
+	 *
+	 *   - variableToType: A mapping of variable name to GraphQLType.
+	 *   - value: The text of the editor.
+	 *   - onEdit: A function called when the editor changes, given the edited text.
+	 *
+	 */
+	var VariableEditor = exports.VariableEditor = function (_React$Component) {
+	  _inherits(VariableEditor, _React$Component);
+
+	  function VariableEditor(props) {
+	    _classCallCheck(this, VariableEditor);
+
+	    // Keep a cached version of the value, this cache will be updated when the
+	    // editor is updated, which can later be used to protect the editor from
+	    // unnecessary updates during the update lifecycle.
+	    var _this = _possibleConstructorReturn(this, (VariableEditor.__proto__ || Object.getPrototypeOf(VariableEditor)).call(this));
+
+	    _this._onKeyUp = function (cm, event) {
+	      var code = event.keyCode;
+	      if (code >= 65 && code <= 90 || // letters
+	      !event.shiftKey && code >= 48 && code <= 57 || // numbers
+	      event.shiftKey && code === 189 || // underscore
+	      event.shiftKey && code === 222 // "
+	      ) {
+	          _this.editor.execCommand('autocomplete');
+	        }
+	    };
+
+	    _this._onEdit = function () {
+	      if (!_this.ignoreChangeEvent) {
+	        _this.cachedValue = _this.editor.getValue();
+	        if (_this.props.onEdit) {
+	          _this.props.onEdit(_this.cachedValue);
+	        }
+	      }
+	    };
+
+	    _this._onHasCompletion = function (cm, data) {
+	      (0, _onHasCompletion2.default)(cm, data, _this.props.onHintInformationRender);
+	    };
+
+	    _this.cachedValue = props.value || '';
+	    return _this;
+	  }
+
+	  _createClass(VariableEditor, [{
+	    key: 'componentDidMount',
+	    value: function componentDidMount() {
+	      var _this2 = this;
+
+	      // Lazily require to ensure requiring GraphiQL outside of a Browser context
+	      // does not produce an error.
+	      var CodeMirror = __webpack_require__(267);
+	      __webpack_require__(268);
+	      __webpack_require__(270);
+	      __webpack_require__(271);
+	      __webpack_require__(274);
+	      __webpack_require__(272);
+	      __webpack_require__(275);
+	      __webpack_require__(276);
+	      __webpack_require__(291);
+	      __webpack_require__(292);
+	      __webpack_require__(294);
+
+	      this.editor = CodeMirror(_reactDom2.default.findDOMNode(this), {
+	        value: this.props.value || '',
+	        lineNumbers: true,
+	        tabSize: 2,
+	        mode: 'graphql-variables',
+	        theme: 'graphiql',
+	        keyMap: 'sublime',
+	        autoCloseBrackets: true,
+	        matchBrackets: true,
+	        showCursorWhenSelecting: true,
+	        foldGutter: {
+	          minFoldSize: 4
+	        },
+	        lint: {
+	          variableToType: this.props.variableToType
+	        },
+	        hintOptions: {
+	          variableToType: this.props.variableToType
+	        },
+	        gutters: ['CodeMirror-linenumbers', 'CodeMirror-foldgutter'],
+	        extraKeys: {
+	          'Cmd-Space': function CmdSpace() {
+	            return _this2.editor.showHint({ completeSingle: false });
+	          },
+	          'Ctrl-Space': function CtrlSpace() {
+	            return _this2.editor.showHint({ completeSingle: false });
+	          },
+	          'Alt-Space': function AltSpace() {
+	            return _this2.editor.showHint({ completeSingle: false });
+	          },
+	          'Shift-Space': function ShiftSpace() {
+	            return _this2.editor.showHint({ completeSingle: false });
+	          },
+
+	          'Cmd-Enter': function CmdEnter() {
+	            if (_this2.props.onRunQuery) {
+	              _this2.props.onRunQuery();
+	            }
+	          },
+	          'Ctrl-Enter': function CtrlEnter() {
+	            if (_this2.props.onRunQuery) {
+	              _this2.props.onRunQuery();
+	            }
+	          },
+
+	          // Editor improvements
+	          'Ctrl-Left': 'goSubwordLeft',
+	          'Ctrl-Right': 'goSubwordRight',
+	          'Alt-Left': 'goGroupLeft',
+	          'Alt-Right': 'goGroupRight'
+	        }
+	      });
+
+	      this.editor.on('change', this._onEdit);
+	      this.editor.on('keyup', this._onKeyUp);
+	      this.editor.on('hasCompletion', this._onHasCompletion);
+	    }
+	  }, {
+	    key: 'componentDidUpdate',
+	    value: function componentDidUpdate(prevProps) {
+	      var CodeMirror = __webpack_require__(267);
+
+	      // Ensure the changes caused by this update are not interpretted as
+	      // user-input changes which could otherwise result in an infinite
+	      // event loop.
+	      this.ignoreChangeEvent = true;
+	      if (this.props.variableToType !== prevProps.variableToType) {
+	        this.editor.options.lint.variableToType = this.props.variableToType;
+	        this.editor.options.hintOptions.variableToType = this.props.variableToType;
+	        CodeMirror.signal(this.editor, 'change', this.editor);
+	      }
+	      if (this.props.value !== prevProps.value && this.props.value !== this.cachedValue) {
+	        this.cachedValue = this.props.value;
+	        this.editor.setValue(this.props.value);
+	      }
+	      this.ignoreChangeEvent = false;
+	    }
+	  }, {
+	    key: 'componentWillUnmount',
+	    value: function componentWillUnmount() {
+	      this.editor.off('change', this._onEdit);
+	      this.editor.off('keyup', this._onKeyUp);
+	      this.editor.off('hasCompletion', this._onHasCompletion);
+	      this.editor = null;
+	    }
+	  }, {
+	    key: 'render',
+	    value: function render() {
+	      return _react2.default.createElement('div', { className: 'codemirrorWrap' });
+	    }
+
+	    /**
+	     * Public API for retrieving the CodeMirror instance from this
+	     * React component.
+	     */
+
+	  }, {
+	    key: 'getCodeMirror',
+	    value: function getCodeMirror() {
+	      return this.editor;
+	    }
+	  }]);
+
+	  return VariableEditor;
+	}(_react2.default.Component);
+
+	VariableEditor.propTypes = {
+	  variableToType: _react.PropTypes.object,
+	  value: _react.PropTypes.string,
+	  onEdit: _react.PropTypes.func,
+	  onHintInformationRender: _react.PropTypes.func,
+	  onRunQuery: _react.PropTypes.func
+	};
+
+/***/ },
+/* 291 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var _codemirror = __webpack_require__(267);
+
+	var _codemirror2 = _interopRequireDefault(_codemirror);
+
+	var _graphql = __webpack_require__(185);
+
+	var _forEachState = __webpack_require__(280);
+
+	var _forEachState2 = _interopRequireDefault(_forEachState);
+
+	var _hintList = __webpack_require__(281);
+
+	var _hintList2 = _interopRequireDefault(_hintList);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 * Registers a "hint" helper for CodeMirror.
+	 *
+	 * Using CodeMirror's "hint" addon: https://codemirror.net/demo/complete.html
+	 * Given an editor, this helper will take the token at the cursor and return a
+	 * list of suggested tokens.
+	 *
+	 * Options:
+	 *
+	 *   - variableToType: { [variable: string]: GraphQLInputType }
+	 *
+	 * Additional Events:
+	 *
+	 *   - hasCompletion (codemirror, data, token) - signaled when the hinter has a
+	 *     new list of completion suggestions.
+	 *
+	 */
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	_codemirror2.default.registerHelper('hint', 'graphql-variables', function (editor, options) {
+	  var cur = editor.getCursor();
+	  var token = editor.getTokenAt(cur);
+
+	  var results = getVariablesHint(cur, token, options);
+	  if (results && results.list && results.list.length > 0) {
+	    results.from = _codemirror2.default.Pos(results.from.line, results.from.column);
+	    results.to = _codemirror2.default.Pos(results.to.line, results.to.column);
+	    _codemirror2.default.signal(editor, 'hasCompletion', editor, results, token);
+	  }
+
+	  return results;
+	});
+
+	function getVariablesHint(cur, token, options) {
+	  var state = token.state;
+	  var kind = state.kind;
+	  var step = state.step;
+
+	  // Variables can only be an object literal.
+	  if (kind === 'Document' && step === 0) {
+	    return (0, _hintList2.default)(cur, token, [{ text: '{' }]);
+	  }
+
+	  var variableToType = options.variableToType;
+	  if (!variableToType) {
+	    return;
+	  }
+
+	  var typeInfo = getTypeInfo(variableToType, token.state);
+
+	  // Top level should typeahead possible variables.
+	  if (kind === 'Document' || kind === 'Variable' && step === 0) {
+	    var variableNames = Object.keys(variableToType);
+	    return (0, _hintList2.default)(cur, token, variableNames.map(function (name) {
+	      return {
+	        text: '"' + name + '": ',
+	        type: variableToType[name]
+	      };
+	    }));
+	  }
+
+	  // Input Object fields
+	  if (kind === 'ObjectValue' || kind === 'ObjectField' && step === 0) {
+	    if (typeInfo.fields) {
+	      var inputFields = Object.keys(typeInfo.fields).map(function (fieldName) {
+	        return typeInfo.fields[fieldName];
+	      });
+	      return (0, _hintList2.default)(cur, token, inputFields.map(function (field) {
+	        return {
+	          text: '"' + field.name + '": ',
+	          type: field.type,
+	          description: field.description
+	        };
+	      }));
+	    }
+	  }
+
+	  // Input values.
+	  if (kind === 'StringValue' || kind === 'NumberValue' || kind === 'BooleanValue' || kind === 'NullValue' || kind === 'ListValue' && step === 1 || kind === 'ObjectField' && step === 2 || kind === 'Variable' && step === 2) {
+	    var _ret = function () {
+	      var namedInputType = (0, _graphql.getNamedType)(typeInfo.type);
+	      if (namedInputType instanceof _graphql.GraphQLInputObjectType) {
+	        return {
+	          v: (0, _hintList2.default)(cur, token, [{ text: '{' }])
+	        };
+	      } else if (namedInputType instanceof _graphql.GraphQLEnumType) {
+	        var _ret2 = function () {
+	          var valueMap = namedInputType.getValues();
+	          var values = Object.keys(valueMap).map(function (name) {
+	            return valueMap[name];
+	          });
+	          return {
+	            v: {
+	              v: (0, _hintList2.default)(cur, token, values.map(function (value) {
+	                return {
+	                  text: '"' + value.name + '"',
+	                  type: namedInputType,
+	                  description: value.description
+	                };
+	              }))
+	            }
+	          };
+	        }();
+
+	        if (typeof _ret2 === "object") return _ret2.v;
+	      } else if (namedInputType === _graphql.GraphQLBoolean) {
+	        return {
+	          v: (0, _hintList2.default)(cur, token, [{ text: 'true', type: _graphql.GraphQLBoolean, description: 'Not false.' }, { text: 'false', type: _graphql.GraphQLBoolean, description: 'Not true.' }])
+	        };
+	      }
+	    }();
+
+	    if (typeof _ret === "object") return _ret.v;
+	  }
+	}
+
+	// Utility for collecting rich type information given any token's state
+	// from the graphql-variables-mode parser.
+	function getTypeInfo(variableToType, tokenState) {
+	  var info = {
+	    type: null,
+	    fields: null
+	  };
+
+	  (0, _forEachState2.default)(tokenState, function (state) {
+	    if (state.kind === 'Variable') {
+	      info.type = variableToType[state.name];
+	    } else if (state.kind === 'ListValue') {
+	      var nullableType = (0, _graphql.getNullableType)(info.type);
+	      info.type = nullableType instanceof _graphql.GraphQLList ? nullableType.ofType : null;
+	    } else if (state.kind === 'ObjectValue') {
+	      var objectType = (0, _graphql.getNamedType)(info.type);
+	      info.fields = objectType instanceof _graphql.GraphQLInputObjectType ? objectType.getFields() : null;
+	    } else if (state.kind === 'ObjectField') {
+	      var objectField = state.name && info.fields ? info.fields[state.name] : null;
+	      info.type = objectField && objectField.type;
+	    }
+	  });
+
+	  return info;
+	}
+
+/***/ },
+/* 292 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var _codemirror = __webpack_require__(267);
+
+	var _codemirror2 = _interopRequireDefault(_codemirror);
+
+	var _graphql = __webpack_require__(185);
+
+	var _jsonParse = __webpack_require__(293);
+
+	var _jsonParse2 = _interopRequireDefault(_jsonParse);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 * Registers a "lint" helper for CodeMirror.
+	 *
+	 * Using CodeMirror's "lint" addon: https://codemirror.net/demo/lint.html
+	 * Given the text within an editor, this helper will take that text and return
+	 * a list of linter issues ensuring that correct variables were provided.
+	 *
+	 * Options:
+	 *
+	 *   - variableToType: { [variable: string]: GraphQLInputType }
+	 *
+	 */
+	_codemirror2.default.registerHelper('lint', 'graphql-variables', function (text, options, editor) {
+	  // If there's no text, do nothing.
+	  if (!text) {
+	    return [];
+	  }
+
+	  // First, linter needs to determine if there are any parsing errors.
+	  var ast = void 0;
+	  try {
+	    ast = (0, _jsonParse2.default)(text);
+	  } catch (syntaxError) {
+	    if (syntaxError.stack) {
+	      throw syntaxError;
+	    }
+	    return [lintError(editor, syntaxError, syntaxError.message)];
+	  }
+
+	  // If there are not yet known variables, do nothing.
+	  var variableToType = options.variableToType;
+	  if (!variableToType) {
+	    return [];
+	  }
+
+	  // Then highlight any issues with the provided variables.
+	  return validateVariables(editor, variableToType, ast);
+	});
+
+	// Given a variableToType object, a source text, and a JSON AST, produces a
+	// list of CodeMirror annotations for any variable validation errors.
+	/* eslint-disable max-len */
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function validateVariables(editor, variableToType, variablesAST) {
+	  var errors = [];
+
+	  variablesAST.members.forEach(function (member) {
+	    var variableName = member.key.value;
+	    var type = variableToType[variableName];
+	    if (!type) {
+	      errors.push(lintError(editor, member.key, 'Variable "$' + variableName + '" does not appear in any GraphQL query.'));
+	    } else {
+	      validateValue(type, member.value).forEach(function (_ref) {
+	        var node = _ref[0],
+	            message = _ref[1];
+
+	        errors.push(lintError(editor, node, message));
+	      });
+	    }
+	  });
+
+	  return errors;
+	}
+
+	// Returns a list of validation errors in the form Array<[Node, String]>.
+	function validateValue(type, valueAST) {
+	  // Validate non-nullable values.
+	  if (type instanceof _graphql.GraphQLNonNull) {
+	    if (valueAST.kind === 'Null') {
+	      return [[valueAST, 'Type "' + type + '" is non-nullable and cannot be null.']];
+	    }
+	    return validateValue(type.ofType, valueAST);
+	  }
+
+	  if (valueAST.kind === 'Null') {
+	    return [];
+	  }
+
+	  // Validate lists of values, accepting a non-list as a list of one.
+	  if (type instanceof _graphql.GraphQLList) {
+	    var _ret = function () {
+	      var itemType = type.ofType;
+	      if (valueAST.kind === 'Array') {
+	        return {
+	          v: mapCat(valueAST.values, function (item) {
+	            return validateValue(itemType, item);
+	          })
+	        };
+	      }
+	      return {
+	        v: validateValue(itemType, valueAST)
+	      };
+	    }();
+
+	    if (typeof _ret === "object") return _ret.v;
+	  }
+
+	  // Validate input objects.
+	  if (type instanceof _graphql.GraphQLInputObjectType) {
+	    var _ret2 = function () {
+	      if (valueAST.kind !== 'Object') {
+	        return {
+	          v: [[valueAST, 'Type "' + type + '" must be an Object.']]
+	        };
+	      }
+
+	      // Validate each field in the input object.
+	      var providedFields = Object.create(null);
+	      var fieldErrors = mapCat(valueAST.members, function (member) {
+	        var fieldName = member.key.value;
+	        providedFields[fieldName] = true;
+	        var inputField = type.getFields()[fieldName];
+	        if (!inputField) {
+	          return [[member.key, 'Type "' + type + '" does not have a field "' + fieldName + '".']];
+	        }
+	        var fieldType = inputField ? inputField.type : undefined;
+	        return validateValue(fieldType, member.value);
+	      });
+
+	      // Look for missing non-nullable fields.
+	      Object.keys(type.getFields()).forEach(function (fieldName) {
+	        if (!providedFields[fieldName]) {
+	          var fieldType = type.getFields()[fieldName].type;
+	          if (fieldType instanceof _graphql.GraphQLNonNull) {
+	            fieldErrors.push([valueAST, 'Object of type "' + type + '" is missing required field "' + fieldName + '".']);
+	          }
+	        }
+	      });
+
+	      return {
+	        v: fieldErrors
+	      };
+	    }();
+
+	    if (typeof _ret2 === "object") return _ret2.v;
+	  }
+
+	  // Validate common scalars.
+	  if (type.name === 'Boolean' && valueAST.kind !== 'Boolean' || type.name === 'String' && valueAST.kind !== 'String' || type.name === 'ID' && valueAST.kind !== 'Number' && valueAST.kind !== 'String' || type.name === 'Float' && valueAST.kind !== 'Number' || type.name === 'Int' && (valueAST.kind !== 'Number' || (valueAST.value | 0) !== valueAST.value)) {
+	    return [[valueAST, 'Expected value of type "' + type + '".']];
+	  }
+
+	  // Validate enums and custom scalars.
+	  if (type instanceof _graphql.GraphQLEnumType || type instanceof _graphql.GraphQLScalarType) {
+	    if (valueAST.kind !== 'String' && valueAST.kind !== 'Number' && valueAST.kind !== 'Boolean' && valueAST.kind !== 'Null' || isNullish(type.parseValue(valueAST.value))) {
+	      return [[valueAST, 'Expected value of type "' + type + '".']];
+	    }
+	  }
+
+	  return [];
+	}
+
+	// Give a parent text, an AST node with location, and a message, produces a
+	// CodeMirror annotation object.
+	function lintError(editor, node, message) {
+	  return {
+	    message: message,
+	    severity: 'error',
+	    type: 'validation',
+	    from: editor.posFromIndex(node.start),
+	    to: editor.posFromIndex(node.end)
+	  };
+	}
+
+	function isNullish(value) {
+	  return value === null || value === undefined || value !== value;
+	}
+
+	function mapCat(array, mapper) {
+	  return Array.prototype.concat.apply([], array.map(mapper));
+	}
+
+/***/ },
+/* 293 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = jsonParse;
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	/**
+	 * This JSON parser simply walks the input, generating an AST. Use this in lieu
+	 * of JSON.parse if you need character offset parse errors and an AST parse tree
+	 * with location information.
+	 *
+	 * If an error is encountered, a SyntaxError will be thrown, with properties:
+	 *
+	 *   - message: string
+	 *   - start: int - the start inclusive offset of the syntax error
+	 *   - end: int - the end exclusive offset of the syntax error
+	 *
+	 */
+	function jsonParse(str) {
+	  string = str;
+	  strLen = str.length;
+	  start = end = lastEnd = -1;
+	  ch();
+	  lex();
+	  var ast = parseObj();
+	  expect('EOF');
+	  return ast;
+	}
+
+	var string = void 0;
+	var strLen = void 0;
+	var start = void 0;
+	var end = void 0;
+	var lastEnd = void 0;
+	var code = void 0;
+	var kind = void 0;
+
+	function parseObj() {
+	  var nodeStart = start;
+	  var members = [];
+	  expect('{');
+	  if (!skip('}')) {
+	    do {
+	      members.push(parseMember());
+	    } while (skip(','));
+	    expect('}');
+	  }
+	  return {
+	    kind: 'Object',
+	    start: nodeStart,
+	    end: lastEnd,
+	    members: members
+	  };
+	}
+
+	function parseMember() {
+	  var nodeStart = start;
+	  var key = kind === 'String' ? curToken() : null;
+	  expect('String');
+	  expect(':');
+	  var value = parseVal();
+	  return {
+	    kind: 'Member',
+	    start: nodeStart,
+	    end: lastEnd,
+	    key: key,
+	    value: value
+	  };
+	}
+
+	function parseArr() {
+	  var nodeStart = start;
+	  var values = [];
+	  expect('[');
+	  if (!skip(']')) {
+	    do {
+	      values.push(parseVal());
+	    } while (skip(','));
+	    expect(']');
+	  }
+	  return {
+	    kind: 'Array',
+	    start: nodeStart,
+	    end: lastEnd,
+	    values: values
+	  };
+	}
+
+	function parseVal() {
+	  switch (kind) {
+	    case '[':
+	      return parseArr();
+	    case '{':
+	      return parseObj();
+	    case 'String':
+	    case 'Number':
+	    case 'Boolean':
+	    case 'Null':
+	      var token = curToken();
+	      lex();
+	      return token;
+	  }
+	  return expect('Value');
+	}
+
+	function curToken() {
+	  return { kind: kind, start: start, end: end, value: JSON.parse(string.slice(start, end)) };
+	}
+
+	function expect(str) {
+	  if (kind === str) {
+	    lex();
+	    return;
+	  }
+
+	  var found = void 0;
+	  if (kind === 'EOF') {
+	    found = '[end of file]';
+	  } else if (end - start > 1) {
+	    found = '`' + string.slice(start, end) + '`';
+	  } else {
+	    var match = string.slice(start).match(/^.+?\b/);
+	    found = '`' + (match ? match[0] : string[start]) + '`';
+	  }
+
+	  throw syntaxError('Expected ' + str + ' but found ' + found + '.');
+	}
+
+	function syntaxError(message) {
+	  return { message: message, start: start, end: end };
+	}
+
+	function skip(k) {
+	  if (kind === k) {
+	    lex();
+	    return true;
+	  }
+	}
+
+	function ch() {
+	  if (end < strLen) {
+	    end++;
+	    code = end === strLen ? 0 : string.charCodeAt(end);
+	  }
+	}
+
+	function lex() {
+	  lastEnd = end;
+
+	  while (code === 9 || code === 10 || code === 13 || code === 32) {
+	    ch();
+	  }
+
+	  if (code === 0) {
+	    kind = 'EOF';
+	    return;
+	  }
+
+	  start = end;
+
+	  switch (code) {
+	    // "
+	    case 34:
+	      kind = 'String';
+	      return readString();
+	    // -, 0-9
+	    case 45:
+	    case 48:case 49:case 50:case 51:case 52:
+	    case 53:case 54:case 55:case 56:case 57:
+	      kind = 'Number';
+	      return readNumber();
+	    // f
+	    case 102:
+	      if (string.slice(start, start + 5) !== 'false') {
+	        break;
+	      }
+	      end += 4;ch();
+
+	      kind = 'Boolean';
+	      return;
+	    // n
+	    case 110:
+	      if (string.slice(start, start + 4) !== 'null') {
+	        break;
+	      }
+	      end += 3;ch();
+
+	      kind = 'Null';
+	      return;
+	    // t
+	    case 116:
+	      if (string.slice(start, start + 4) !== 'true') {
+	        break;
+	      }
+	      end += 3;ch();
+
+	      kind = 'Boolean';
+	      return;
+	  }
+
+	  kind = string[start];
+	  ch();
+	}
+
+	function readString() {
+	  ch();
+	  while (code !== 34 && code > 31) {
+	    if (code === 92) {
+	      // \
+	      ch();
+	      switch (code) {
+	        case 34: // "
+	        case 47: // /
+	        case 92: // \
+	        case 98: // b
+	        case 102: // f
+	        case 110: // n
+	        case 114: // r
+	        case 116:
+	          // t
+	          ch();
+	          break;
+	        case 117:
+	          // u
+	          ch();
+	          readHex();
+	          readHex();
+	          readHex();
+	          readHex();
+	          break;
+	        default:
+	          throw syntaxError('Bad character escape sequence.');
+	      }
+	    } else if (end === strLen) {
+	      throw syntaxError('Unterminated string.');
+	    } else {
+	      ch();
+	    }
+	  }
+
+	  if (code === 34) {
+	    ch();
+	    return;
+	  }
+
+	  throw syntaxError('Unterminated string.');
+	}
+
+	function readHex() {
+	  if (code >= 48 && code <= 57 || // 0-9
+	  code >= 65 && code <= 70 || // A-F
+	  code >= 97 && code <= 102 // a-f
+	  ) {
+	      return ch();
+	    }
+	  throw syntaxError('Expected hexadecimal digit.');
+	}
+
+	function readNumber() {
+	  if (code === 45) {
+	    // -
+	    ch();
+	  }
+
+	  if (code === 48) {
+	    // 0
+	    ch();
+	  } else {
+	    readDigits();
+	  }
+
+	  if (code === 46) {
+	    // .
+	    ch();
+	    readDigits();
+	  }
+
+	  if (code === 69 || code === 101) {
+	    // E e
+	    ch();
+	    if (code === 43 || code === 45) {
+	      // + -
+	      ch();
+	    }
+	    readDigits();
+	  }
+	}
+
+	function readDigits() {
+	  if (code < 48 || code > 57) {
+	    // 0 - 9
+	    throw syntaxError('Expected decimal digit.');
+	  }
+	  do {
+	    ch();
+	  } while (code >= 48 && code <= 57); // 0 - 9
+	}
+
+/***/ },
+/* 294 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var _codemirror = __webpack_require__(267);
+
+	var _codemirror2 = _interopRequireDefault(_codemirror);
+
+	var _onlineParser = __webpack_require__(285);
+
+	var _onlineParser2 = _interopRequireDefault(_onlineParser);
+
+	var _RuleHelpers = __webpack_require__(287);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 * This mode defines JSON, but provides a data-laden parser state to enable
+	 * better code intelligence.
+	 */
+	_codemirror2.default.defineMode('graphql-variables', function (config) {
+	  var parser = (0, _onlineParser2.default)({
+	    eatWhitespace: function eatWhitespace(stream) {
+	      return stream.eatSpace();
+	    },
+	    LexRules: LexRules,
+	    ParseRules: ParseRules,
+	    editorConfig: { tabSize: config.tabSize }
+	  });
+
+	  return {
+	    config: config,
+	    startState: parser.startState,
+	    token: parser.token,
+	    indent: indent,
+	    electricInput: /^\s*[}\]]/,
+	    fold: 'brace',
+	    closeBrackets: {
+	      pairs: '[]{}""',
+	      explode: '[]{}'
+	    }
+	  };
+	}); /**
+	     *  Copyright (c) 2015, Facebook, Inc.
+	     *  All rights reserved.
+	     *
+	     *  This source code is licensed under the BSD-style license found in the
+	     *  LICENSE file in the root directory of this source tree. An additional grant
+	     *  of patent rights can be found in the PATENTS file in the same directory.
+	     */
+
+	function indent(state, textAfter) {
+	  var levels = state.levels;
+	  // If there is no stack of levels, use the current level.
+	  // Otherwise, use the top level, pre-emptively dedenting for close braces.
+	  var level = !levels || levels.length === 0 ? state.indentLevel : levels[levels.length - 1] - (this.electricInput.test(textAfter) ? 1 : 0);
+	  return level * this.config.indentUnit;
+	}
+
+	/**
+	 * The lexer rules. These are exactly as described by the spec.
+	 */
+	var LexRules = {
+	  // All Punctuation used in JSON.
+	  Punctuation: /^\[|]|\{|\}|:|,/,
+
+	  // JSON Number.
+	  Number: /^-?(?:0|(?:[1-9][0-9]*))(?:\.[0-9]*)?(?:[eE][+-]?[0-9]+)?/,
+
+	  // JSON String.
+	  String: /^"(?:[^"\\]|\\(?:"|\/|\\|b|f|n|r|t|u[0-9a-fA-F]{4}))*"?/,
+
+	  // JSON literal keywords.
+	  Keyword: /^true|false|null/
+	};
+
+	/**
+	 * The parser rules for JSON.
+	 */
+	var ParseRules = {
+	  Document: [(0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('Variable', (0, _RuleHelpers.p)(',')), (0, _RuleHelpers.p)('}')],
+	  Variable: [namedKey('variable'), (0, _RuleHelpers.p)(':'), 'Value'],
+	  Value: function Value(token) {
+	    switch (token.kind) {
+	      case 'Number':
+	        return 'NumberValue';
+	      case 'String':
+	        return 'StringValue';
+	      case 'Punctuation':
+	        switch (token.value) {
+	          case '[':
+	            return 'ListValue';
+	          case '{':
+	            return 'ObjectValue';
+	        }
+	        return null;
+	      case 'Keyword':
+	        switch (token.value) {
+	          case 'true':case 'false':
+	            return 'BooleanValue';
+	          case 'null':
+	            return 'NullValue';
+	        }
+	        return null;
+	    }
+	  },
+
+	  NumberValue: [(0, _RuleHelpers.t)('Number', 'number')],
+	  StringValue: [(0, _RuleHelpers.t)('String', 'string')],
+	  BooleanValue: [(0, _RuleHelpers.t)('Keyword', 'builtin')],
+	  NullValue: [(0, _RuleHelpers.t)('Keyword', 'keyword')],
+	  ListValue: [(0, _RuleHelpers.p)('['), (0, _RuleHelpers.list)('Value', (0, _RuleHelpers.p)(',')), (0, _RuleHelpers.p)(']')],
+	  ObjectValue: [(0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('ObjectField', (0, _RuleHelpers.p)(',')), (0, _RuleHelpers.p)('}')],
+	  ObjectField: [namedKey('attribute'), (0, _RuleHelpers.p)(':'), 'Value']
+	};
+
+	// A namedKey Token which will decorate the state with a `name`
+	function namedKey(style) {
+	  return {
+	    style: style,
+	    match: function match(token) {
+	      return token.kind === 'String';
+	    },
+	    update: function update(state, token) {
+	      state.name = token.value.slice(1, -1); // Remove quotes.
+	    }
+	  };
+	}
+
+/***/ },
+/* 295 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.ResultViewer = undefined;
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _react = __webpack_require__(1);
+
+	var _react2 = _interopRequireDefault(_react);
+
+	var _reactDom = __webpack_require__(32);
+
+	var _reactDom2 = _interopRequireDefault(_reactDom);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /**
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  Copyright (c) 2015, Facebook, Inc.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  All rights reserved.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  This source code is licensed under the license found in the
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  LICENSE-examples file in the root directory of this source tree.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
+
+	/**
+	 * ResultViewer
+	 *
+	 * Maintains an instance of CodeMirror for viewing a GraphQL response.
+	 *
+	 * Props:
+	 *
+	 *   - value: The text of the editor.
+	 *
+	 */
+	var ResultViewer = exports.ResultViewer = function (_React$Component) {
+	  _inherits(ResultViewer, _React$Component);
+
+	  function ResultViewer() {
+	    _classCallCheck(this, ResultViewer);
+
+	    return _possibleConstructorReturn(this, (ResultViewer.__proto__ || Object.getPrototypeOf(ResultViewer)).apply(this, arguments));
+	  }
+
+	  _createClass(ResultViewer, [{
+	    key: 'componentDidMount',
+	    value: function componentDidMount() {
+	      // Lazily require to ensure requiring GraphiQL outside of a Browser context
+	      // does not produce an error.
+	      var CodeMirror = __webpack_require__(267);
+	      __webpack_require__(272);
+	      __webpack_require__(274);
+	      __webpack_require__(296);
+	      __webpack_require__(297);
+	      __webpack_require__(276);
+	      __webpack_require__(298);
+
+	      this.viewer = CodeMirror(_reactDom2.default.findDOMNode(this), {
+	        lineWrapping: true,
+	        value: this.props.value || '',
+	        readOnly: true,
+	        theme: 'graphiql',
+	        mode: 'graphql-results',
+	        keyMap: 'sublime',
+	        foldGutter: {
+	          minFoldSize: 4
+	        },
+	        gutters: ['CodeMirror-foldgutter'],
+	        extraKeys: {
+	          // Editor improvements
+	          'Ctrl-Left': 'goSubwordLeft',
+	          'Ctrl-Right': 'goSubwordRight',
+	          'Alt-Left': 'goGroupLeft',
+	          'Alt-Right': 'goGroupRight'
+	        }
+	      });
+	    }
+	  }, {
+	    key: 'shouldComponentUpdate',
+	    value: function shouldComponentUpdate(nextProps) {
+	      return this.props.value !== nextProps.value;
+	    }
+	  }, {
+	    key: 'componentDidUpdate',
+	    value: function componentDidUpdate() {
+	      this.viewer.setValue(this.props.value || '');
+	    }
+	  }, {
+	    key: 'componentWillUnmount',
+	    value: function componentWillUnmount() {
+	      this.viewer = null;
+	    }
+	  }, {
+	    key: 'render',
+	    value: function render() {
+	      return _react2.default.createElement('div', { className: 'result-window' });
+	    }
+
+	    /**
+	     * Public API for retrieving the CodeMirror instance from this
+	     * React component.
+	     */
+
+	  }, {
+	    key: 'getCodeMirror',
+	    value: function getCodeMirror() {
+	      return this.viewer;
+	    }
+	  }]);
+
+	  return ResultViewer;
+	}(_react2.default.Component);
+
+	ResultViewer.propTypes = {
+	  value: _react.PropTypes.string
+	};
+
+/***/ },
+/* 296 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// CodeMirror, copyright (c) by Marijn Haverbeke and others
+	// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+	// Open simple dialogs on top of an editor. Relies on dialog.css.
+
+	(function(mod) {
+	  if (true) // CommonJS
+	    mod(__webpack_require__(267));
+	  else if (typeof define == "function" && define.amd) // AMD
+	    define(["../../lib/codemirror"], mod);
+	  else // Plain browser env
+	    mod(CodeMirror);
+	})(function(CodeMirror) {
+	  function dialogDiv(cm, template, bottom) {
+	    var wrap = cm.getWrapperElement();
+	    var dialog;
+	    dialog = wrap.appendChild(document.createElement("div"));
+	    if (bottom)
+	      dialog.className = "CodeMirror-dialog CodeMirror-dialog-bottom";
+	    else
+	      dialog.className = "CodeMirror-dialog CodeMirror-dialog-top";
+
+	    if (typeof template == "string") {
+	      dialog.innerHTML = template;
+	    } else { // Assuming it's a detached DOM element.
+	      dialog.appendChild(template);
+	    }
+	    return dialog;
+	  }
+
+	  function closeNotification(cm, newVal) {
+	    if (cm.state.currentNotificationClose)
+	      cm.state.currentNotificationClose();
+	    cm.state.currentNotificationClose = newVal;
+	  }
+
+	  CodeMirror.defineExtension("openDialog", function(template, callback, options) {
+	    if (!options) options = {};
+
+	    closeNotification(this, null);
+
+	    var dialog = dialogDiv(this, template, options.bottom);
+	    var closed = false, me = this;
+	    function close(newVal) {
+	      if (typeof newVal == 'string') {
+	        inp.value = newVal;
+	      } else {
+	        if (closed) return;
+	        closed = true;
+	        dialog.parentNode.removeChild(dialog);
+	        me.focus();
+
+	        if (options.onClose) options.onClose(dialog);
+	      }
+	    }
+
+	    var inp = dialog.getElementsByTagName("input")[0], button;
+	    if (inp) {
+	      inp.focus();
+
+	      if (options.value) {
+	        inp.value = options.value;
+	        if (options.selectValueOnOpen !== false) {
+	          inp.select();
+	        }
+	      }
+
+	      if (options.onInput)
+	        CodeMirror.on(inp, "input", function(e) { options.onInput(e, inp.value, close);});
+	      if (options.onKeyUp)
+	        CodeMirror.on(inp, "keyup", function(e) {options.onKeyUp(e, inp.value, close);});
+
+	      CodeMirror.on(inp, "keydown", function(e) {
+	        if (options && options.onKeyDown && options.onKeyDown(e, inp.value, close)) { return; }
+	        if (e.keyCode == 27 || (options.closeOnEnter !== false && e.keyCode == 13)) {
+	          inp.blur();
+	          CodeMirror.e_stop(e);
+	          close();
+	        }
+	        if (e.keyCode == 13) callback(inp.value, e);
+	      });
+
+	      if (options.closeOnBlur !== false) CodeMirror.on(inp, "blur", close);
+	    } else if (button = dialog.getElementsByTagName("button")[0]) {
+	      CodeMirror.on(button, "click", function() {
+	        close();
+	        me.focus();
+	      });
+
+	      if (options.closeOnBlur !== false) CodeMirror.on(button, "blur", close);
+
+	      button.focus();
+	    }
+	    return close;
+	  });
+
+	  CodeMirror.defineExtension("openConfirm", function(template, callbacks, options) {
+	    closeNotification(this, null);
+	    var dialog = dialogDiv(this, template, options && options.bottom);
+	    var buttons = dialog.getElementsByTagName("button");
+	    var closed = false, me = this, blurring = 1;
+	    function close() {
+	      if (closed) return;
+	      closed = true;
+	      dialog.parentNode.removeChild(dialog);
+	      me.focus();
+	    }
+	    buttons[0].focus();
+	    for (var i = 0; i < buttons.length; ++i) {
+	      var b = buttons[i];
+	      (function(callback) {
+	        CodeMirror.on(b, "click", function(e) {
+	          CodeMirror.e_preventDefault(e);
+	          close();
+	          if (callback) callback(me);
+	        });
+	      })(callbacks[i]);
+	      CodeMirror.on(b, "blur", function() {
+	        --blurring;
+	        setTimeout(function() { if (blurring <= 0) close(); }, 200);
+	      });
+	      CodeMirror.on(b, "focus", function() { ++blurring; });
+	    }
+	  });
+
+	  /*
+	   * openNotification
+	   * Opens a notification, that can be closed with an optional timer
+	   * (default 5000ms timer) and always closes on click.
+	   *
+	   * If a notification is opened while another is opened, it will close the
+	   * currently opened one and open the new one immediately.
+	   */
+	  CodeMirror.defineExtension("openNotification", function(template, options) {
+	    closeNotification(this, close);
+	    var dialog = dialogDiv(this, template, options && options.bottom);
+	    var closed = false, doneTimer;
+	    var duration = options && typeof options.duration !== "undefined" ? options.duration : 5000;
+
+	    function close() {
+	      if (closed) return;
+	      closed = true;
+	      clearTimeout(doneTimer);
+	      dialog.parentNode.removeChild(dialog);
+	    }
+
+	    CodeMirror.on(dialog, 'click', function(e) {
+	      CodeMirror.e_preventDefault(e);
+	      close();
+	    });
+
+	    if (duration)
+	      doneTimer = setTimeout(close, duration);
+
+	    return close;
+	  });
+	});
+
+
+/***/ },
+/* 297 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// CodeMirror, copyright (c) by Marijn Haverbeke and others
+	// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+	// Define search commands. Depends on dialog.js or another
+	// implementation of the openDialog method.
+
+	// Replace works a little oddly -- it will do the replace on the next
+	// Ctrl-G (or whatever is bound to findNext) press. You prevent a
+	// replace by making sure the match is no longer selected when hitting
+	// Ctrl-G.
+
+	(function(mod) {
+	  if (true) // CommonJS
+	    mod(__webpack_require__(267), __webpack_require__(277), __webpack_require__(296));
+	  else if (typeof define == "function" && define.amd) // AMD
+	    define(["../../lib/codemirror", "./searchcursor", "../dialog/dialog"], mod);
+	  else // Plain browser env
+	    mod(CodeMirror);
+	})(function(CodeMirror) {
+	  "use strict";
+
+	  function searchOverlay(query, caseInsensitive) {
+	    if (typeof query == "string")
+	      query = new RegExp(query.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"), caseInsensitive ? "gi" : "g");
+	    else if (!query.global)
+	      query = new RegExp(query.source, query.ignoreCase ? "gi" : "g");
+
+	    return {token: function(stream) {
+	      query.lastIndex = stream.pos;
+	      var match = query.exec(stream.string);
+	      if (match && match.index == stream.pos) {
+	        stream.pos += match[0].length || 1;
+	        return "searching";
+	      } else if (match) {
+	        stream.pos = match.index;
+	      } else {
+	        stream.skipToEnd();
+	      }
+	    }};
+	  }
+
+	  function SearchState() {
+	    this.posFrom = this.posTo = this.lastQuery = this.query = null;
+	    this.overlay = null;
+	  }
+
+	  function getSearchState(cm) {
+	    return cm.state.search || (cm.state.search = new SearchState());
+	  }
+
+	  function queryCaseInsensitive(query) {
+	    return typeof query == "string" && query == query.toLowerCase();
+	  }
+
+	  function getSearchCursor(cm, query, pos) {
+	    // Heuristic: if the query string is all lowercase, do a case insensitive search.
+	    return cm.getSearchCursor(query, pos, queryCaseInsensitive(query));
+	  }
+
+	  function persistentDialog(cm, text, deflt, onEnter, onKeyDown) {
+	    cm.openDialog(text, onEnter, {
+	      value: deflt,
+	      selectValueOnOpen: true,
+	      closeOnEnter: false,
+	      onClose: function() { clearSearch(cm); },
+	      onKeyDown: onKeyDown
+	    });
+	  }
+
+	  function dialog(cm, text, shortText, deflt, f) {
+	    if (cm.openDialog) cm.openDialog(text, f, {value: deflt, selectValueOnOpen: true});
+	    else f(prompt(shortText, deflt));
+	  }
+
+	  function confirmDialog(cm, text, shortText, fs) {
+	    if (cm.openConfirm) cm.openConfirm(text, fs);
+	    else if (confirm(shortText)) fs[0]();
+	  }
+
+	  function parseString(string) {
+	    return string.replace(/\\(.)/g, function(_, ch) {
+	      if (ch == "n") return "\n"
+	      if (ch == "r") return "\r"
+	      return ch
+	    })
+	  }
+
+	  function parseQuery(query) {
+	    var isRE = query.match(/^\/(.*)\/([a-z]*)$/);
+	    if (isRE) {
+	      try { query = new RegExp(isRE[1], isRE[2].indexOf("i") == -1 ? "" : "i"); }
+	      catch(e) {} // Not a regular expression after all, do a string search
+	    } else {
+	      query = parseString(query)
+	    }
+	    if (typeof query == "string" ? query == "" : query.test(""))
+	      query = /x^/;
+	    return query;
+	  }
+
+	  var queryDialog =
+	    'Search: <input type="text" style="width: 10em" class="CodeMirror-search-field"/> <span style="color: #888" class="CodeMirror-search-hint">(Use /re/ syntax for regexp search)</span>';
+
+	  function startSearch(cm, state, query) {
+	    state.queryText = query;
+	    state.query = parseQuery(query);
+	    cm.removeOverlay(state.overlay, queryCaseInsensitive(state.query));
+	    state.overlay = searchOverlay(state.query, queryCaseInsensitive(state.query));
+	    cm.addOverlay(state.overlay);
+	    if (cm.showMatchesOnScrollbar) {
+	      if (state.annotate) { state.annotate.clear(); state.annotate = null; }
+	      state.annotate = cm.showMatchesOnScrollbar(state.query, queryCaseInsensitive(state.query));
+	    }
+	  }
+
+	  function doSearch(cm, rev, persistent, immediate) {
+	    var state = getSearchState(cm);
+	    if (state.query) return findNext(cm, rev);
+	    var q = cm.getSelection() || state.lastQuery;
+	    if (persistent && cm.openDialog) {
+	      var hiding = null
+	      var searchNext = function(query, event) {
+	        CodeMirror.e_stop(event);
+	        if (!query) return;
+	        if (query != state.queryText) {
+	          startSearch(cm, state, query);
+	          state.posFrom = state.posTo = cm.getCursor();
+	        }
+	        if (hiding) hiding.style.opacity = 1
+	        findNext(cm, event.shiftKey, function(_, to) {
+	          var dialog
+	          if (to.line < 3 && document.querySelector &&
+	              (dialog = cm.display.wrapper.querySelector(".CodeMirror-dialog")) &&
+	              dialog.getBoundingClientRect().bottom - 4 > cm.cursorCoords(to, "window").top)
+	            (hiding = dialog).style.opacity = .4
+	        })
+	      };
+	      persistentDialog(cm, queryDialog, q, searchNext, function(event, query) {
+	        var keyName = CodeMirror.keyName(event)
+	        var cmd = CodeMirror.keyMap[cm.getOption("keyMap")][keyName]
+	        if (!cmd) cmd = cm.getOption('extraKeys')[keyName]
+	        if (cmd == "findNext" || cmd == "findPrev" ||
+	          cmd == "findPersistentNext" || cmd == "findPersistentPrev") {
+	          CodeMirror.e_stop(event);
+	          startSearch(cm, getSearchState(cm), query);
+	          cm.execCommand(cmd);
+	        } else if (cmd == "find" || cmd == "findPersistent") {
+	          CodeMirror.e_stop(event);
+	          searchNext(query, event);
+	        }
+	      });
+	      if (immediate && q) {
+	        startSearch(cm, state, q);
+	        findNext(cm, rev);
+	      }
+	    } else {
+	      dialog(cm, queryDialog, "Search for:", q, function(query) {
+	        if (query && !state.query) cm.operation(function() {
+	          startSearch(cm, state, query);
+	          state.posFrom = state.posTo = cm.getCursor();
+	          findNext(cm, rev);
+	        });
+	      });
+	    }
+	  }
+
+	  function findNext(cm, rev, callback) {cm.operation(function() {
+	    var state = getSearchState(cm);
+	    var cursor = getSearchCursor(cm, state.query, rev ? state.posFrom : state.posTo);
+	    if (!cursor.find(rev)) {
+	      cursor = getSearchCursor(cm, state.query, rev ? CodeMirror.Pos(cm.lastLine()) : CodeMirror.Pos(cm.firstLine(), 0));
+	      if (!cursor.find(rev)) return;
+	    }
+	    cm.setSelection(cursor.from(), cursor.to());
+	    cm.scrollIntoView({from: cursor.from(), to: cursor.to()}, 20);
+	    state.posFrom = cursor.from(); state.posTo = cursor.to();
+	    if (callback) callback(cursor.from(), cursor.to())
+	  });}
+
+	  function clearSearch(cm) {cm.operation(function() {
+	    var state = getSearchState(cm);
+	    state.lastQuery = state.query;
+	    if (!state.query) return;
+	    state.query = state.queryText = null;
+	    cm.removeOverlay(state.overlay);
+	    if (state.annotate) { state.annotate.clear(); state.annotate = null; }
+	  });}
+
+	  var replaceQueryDialog =
+	    ' <input type="text" style="width: 10em" class="CodeMirror-search-field"/> <span style="color: #888" class="CodeMirror-search-hint">(Use /re/ syntax for regexp search)</span>';
+	  var replacementQueryDialog = 'With: <input type="text" style="width: 10em" class="CodeMirror-search-field"/>';
+	  var doReplaceConfirm = "Replace? <button>Yes</button> <button>No</button> <button>All</button> <button>Stop</button>";
+
+	  function replaceAll(cm, query, text) {
+	    cm.operation(function() {
+	      for (var cursor = getSearchCursor(cm, query); cursor.findNext();) {
+	        if (typeof query != "string") {
+	          var match = cm.getRange(cursor.from(), cursor.to()).match(query);
+	          cursor.replace(text.replace(/\$(\d)/g, function(_, i) {return match[i];}));
+	        } else cursor.replace(text);
+	      }
+	    });
+	  }
+
+	  function replace(cm, all) {
+	    if (cm.getOption("readOnly")) return;
+	    var query = cm.getSelection() || getSearchState(cm).lastQuery;
+	    var dialogText = all ? "Replace all:" : "Replace:"
+	    dialog(cm, dialogText + replaceQueryDialog, dialogText, query, function(query) {
+	      if (!query) return;
+	      query = parseQuery(query);
+	      dialog(cm, replacementQueryDialog, "Replace with:", "", function(text) {
+	        text = parseString(text)
+	        if (all) {
+	          replaceAll(cm, query, text)
+	        } else {
+	          clearSearch(cm);
+	          var cursor = getSearchCursor(cm, query, cm.getCursor("from"));
+	          var advance = function() {
+	            var start = cursor.from(), match;
+	            if (!(match = cursor.findNext())) {
+	              cursor = getSearchCursor(cm, query);
+	              if (!(match = cursor.findNext()) ||
+	                  (start && cursor.from().line == start.line && cursor.from().ch == start.ch)) return;
+	            }
+	            cm.setSelection(cursor.from(), cursor.to());
+	            cm.scrollIntoView({from: cursor.from(), to: cursor.to()});
+	            confirmDialog(cm, doReplaceConfirm, "Replace?",
+	                          [function() {doReplace(match);}, advance,
+	                           function() {replaceAll(cm, query, text)}]);
+	          };
+	          var doReplace = function(match) {
+	            cursor.replace(typeof query == "string" ? text :
+	                           text.replace(/\$(\d)/g, function(_, i) {return match[i];}));
+	            advance();
+	          };
+	          advance();
+	        }
+	      });
+	    });
+	  }
+
+	  CodeMirror.commands.find = function(cm) {clearSearch(cm); doSearch(cm);};
+	  CodeMirror.commands.findPersistent = function(cm) {clearSearch(cm); doSearch(cm, false, true);};
+	  CodeMirror.commands.findPersistentNext = function(cm) {doSearch(cm, false, true, true);};
+	  CodeMirror.commands.findPersistentPrev = function(cm) {doSearch(cm, true, true, true);};
+	  CodeMirror.commands.findNext = doSearch;
+	  CodeMirror.commands.findPrev = function(cm) {doSearch(cm, true);};
+	  CodeMirror.commands.clearSearch = clearSearch;
+	  CodeMirror.commands.replace = replace;
+	  CodeMirror.commands.replaceAll = function(cm) {replace(cm, true);};
+	});
+
+
+/***/ },
+/* 298 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	var _codemirror = __webpack_require__(267);
+
+	var _codemirror2 = _interopRequireDefault(_codemirror);
+
+	var _onlineParser = __webpack_require__(285);
+
+	var _onlineParser2 = _interopRequireDefault(_onlineParser);
+
+	var _RuleHelpers = __webpack_require__(287);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	/**
+	 * This mode defines JSON, but provides a data-laden parser state to enable
+	 * better code intelligence.
+	 */
+	_codemirror2.default.defineMode('graphql-results', function (config) {
+	  var parser = (0, _onlineParser2.default)({
+	    eatWhitespace: function eatWhitespace(stream) {
+	      return stream.eatSpace();
+	    },
+	    LexRules: LexRules,
+	    ParseRules: ParseRules,
+	    editorConfig: { tabSize: config.tabSize }
+	  });
+
+	  return {
+	    config: config,
+	    startState: parser.startState,
+	    token: parser.token,
+	    indent: indent,
+	    electricInput: /^\s*[}\]]/,
+	    fold: 'brace',
+	    closeBrackets: {
+	      pairs: '[]{}""',
+	      explode: '[]{}'
+	    }
+	  };
+	}); /**
+	     *  Copyright (c) 2015, Facebook, Inc.
+	     *  All rights reserved.
+	     *
+	     *  This source code is licensed under the BSD-style license found in the
+	     *  LICENSE file in the root directory of this source tree. An additional grant
+	     *  of patent rights can be found in the PATENTS file in the same directory.
+	     */
+
+	function indent(state, textAfter) {
+	  var levels = state.levels;
+	  // If there is no stack of levels, use the current level.
+	  // Otherwise, use the top level, pre-emptively dedenting for close braces.
+	  var level = !levels || levels.length === 0 ? state.indentLevel : levels[levels.length - 1] - (this.electricInput.test(textAfter) ? 1 : 0);
+	  return level * this.config.indentUnit;
+	}
+
+	/**
+	 * The lexer rules. These are exactly as described by the spec.
+	 */
+	var LexRules = {
+	  // All Punctuation used in JSON.
+	  Punctuation: /^\[|]|\{|\}|:|,/,
+
+	  // JSON Number.
+	  Number: /^-?(?:0|(?:[1-9][0-9]*))(?:\.[0-9]*)?(?:[eE][+-]?[0-9]+)?/,
+
+	  // JSON String.
+	  String: /^"(?:[^"\\]|\\(?:"|\/|\\|b|f|n|r|t|u[0-9a-fA-F]{4}))*"?/,
+
+	  // JSON literal keywords.
+	  Keyword: /^true|false|null/
+	};
+
+	/**
+	 * The parser rules for JSON.
+	 */
+	var ParseRules = {
+	  Document: [(0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('Entry', (0, _RuleHelpers.p)(',')), (0, _RuleHelpers.p)('}')],
+	  Entry: [(0, _RuleHelpers.t)('String', 'def'), (0, _RuleHelpers.p)(':'), 'Value'],
+	  Value: function Value(token) {
+	    switch (token.kind) {
+	      case 'Number':
+	        return 'NumberValue';
+	      case 'String':
+	        return 'StringValue';
+	      case 'Punctuation':
+	        switch (token.value) {
+	          case '[':
+	            return 'ListValue';
+	          case '{':
+	            return 'ObjectValue';
+	        }
+	        return null;
+	      case 'Keyword':
+	        switch (token.value) {
+	          case 'true':case 'false':
+	            return 'BooleanValue';
+	          case 'null':
+	            return 'NullValue';
+	        }
+	        return null;
+	    }
+	  },
+
+	  NumberValue: [(0, _RuleHelpers.t)('Number', 'number')],
+	  StringValue: [(0, _RuleHelpers.t)('String', 'string')],
+	  BooleanValue: [(0, _RuleHelpers.t)('Keyword', 'builtin')],
+	  NullValue: [(0, _RuleHelpers.t)('Keyword', 'keyword')],
+	  ListValue: [(0, _RuleHelpers.p)('['), (0, _RuleHelpers.list)('Value', (0, _RuleHelpers.p)(',')), (0, _RuleHelpers.p)(']')],
+	  ObjectValue: [(0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('ObjectField', (0, _RuleHelpers.p)(',')), (0, _RuleHelpers.p)('}')],
+	  ObjectField: [(0, _RuleHelpers.t)('String', 'property'), (0, _RuleHelpers.p)(':'), 'Value']
+	};
+
+/***/ },
+/* 299 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.DocExplorer = undefined;
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _react = __webpack_require__(1);
+
+	var _react2 = _interopRequireDefault(_react);
+
+	var _marked = __webpack_require__(266);
+
+	var _marked2 = _interopRequireDefault(_marked);
+
+	var _graphql = __webpack_require__(185);
+
+	var _debounce = __webpack_require__(300);
+
+	var _debounce2 = _interopRequireDefault(_debounce);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /**
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  Copyright (c) 2015, Facebook, Inc.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  All rights reserved.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  This source code is licensed under the license found in the
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  LICENSE-examples file in the root directory of this source tree.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
+
+	/**
+	 * DocExplorer
+	 *
+	 * Shows documentations for GraphQL definitions from the schema.
+	 *
+	 * Props:
+	 *
+	 *   - schema: A required GraphQLSchema instance that provides GraphQL document
+	 *     definitions.
+	 *
+	 * Children:
+	 *
+	 *   - Any provided children will be positioned in the right-hand-side of the
+	 *     top bar. Typically this will be a "close" button for temporary explorer.
+	 *
+	 */
+	var DocExplorer = exports.DocExplorer = function (_React$Component) {
+	  _inherits(DocExplorer, _React$Component);
+
+	  function DocExplorer() {
+	    _classCallCheck(this, DocExplorer);
+
+	    var _this = _possibleConstructorReturn(this, (DocExplorer.__proto__ || Object.getPrototypeOf(DocExplorer)).call(this));
+
+	    _this.handleNavBackClick = function () {
+	      _this.setState({ navStack: _this.state.navStack.slice(0, -1) });
+	    };
+
+	    _this.handleClickTypeOrField = function (typeOrField) {
+	      _this.showDoc(typeOrField);
+	    };
+
+	    _this.handleSearch = function (value) {
+	      _this.showSearch({
+	        name: 'Search Results',
+	        searchValue: value
+	      });
+	    };
+
+	    _this.state = { navStack: [] };
+	    return _this;
+	  }
+
+	  _createClass(DocExplorer, [{
+	    key: 'shouldComponentUpdate',
+	    value: function shouldComponentUpdate(nextProps, nextState) {
+	      return this.props.schema !== nextProps.schema || this.state.navStack !== nextState.navStack || this.state.searchValue !== nextState.searchValue;
+	    }
+	  }, {
+	    key: 'render',
+	    value: function render() {
+	      var schema = this.props.schema;
+	      var navStack = this.state.navStack;
+
+	      var navItem = void 0;
+	      if (navStack.length > 0) {
+	        navItem = navStack[navStack.length - 1];
+	      }
+
+	      var title = void 0;
+	      var content = void 0;
+	      if (navItem) {
+	        if (navItem.name === 'Search Results') {
+	          title = navItem.name;
+	          content = _react2.default.createElement(SearchDoc, {
+	            searchValue: navItem.searchValue,
+	            schema: schema,
+	            onClickType: this.handleClickTypeOrField,
+	            onClickField: this.handleClickTypeOrField
+	          });
+	        } else {
+	          title = navItem.name;
+	          if ((0, _graphql.isType)(navItem)) {
+	            content = _react2.default.createElement(TypeDoc, {
+	              key: navItem.name,
+	              schema: schema,
+	              type: navItem,
+	              onClickType: this.handleClickTypeOrField,
+	              onClickField: this.handleClickTypeOrField
+	            });
+	          } else {
+	            content = _react2.default.createElement(FieldDoc, {
+	              key: navItem.name,
+	              field: navItem,
+	              onClickType: this.handleClickTypeOrField
+	            });
+	          }
+	        }
+	      } else if (schema) {
+	        title = 'Documentation Explorer';
+	        content = _react2.default.createElement(SchemaDoc, { schema: schema, onClickType: this.handleClickTypeOrField });
+	      }
+
+	      var prevName = void 0;
+	      if (navStack.length === 1) {
+	        prevName = 'Schema';
+	      } else if (navStack.length > 1) {
+	        prevName = navStack[navStack.length - 2].name;
+	      }
+
+	      var spinnerDiv = _react2.default.createElement(
+	        'div',
+	        { className: 'spinner-container' },
+	        _react2.default.createElement('div', { className: 'spinner' })
+	      );
+
+	      var shouldSearchBoxAppear = content && (content.type === SearchDoc || content.type === SchemaDoc);
+
+	      return _react2.default.createElement(
+	        'div',
+	        { className: 'doc-explorer' },
+	        _react2.default.createElement(
+	          'div',
+	          { className: 'doc-explorer-title-bar' },
+	          prevName && _react2.default.createElement(
+	            'div',
+	            {
+	              className: 'doc-explorer-back',
+	              onClick: this.handleNavBackClick },
+	            prevName
+	          ),
+	          _react2.default.createElement(
+	            'div',
+	            { className: 'doc-explorer-title' },
+	            title
+	          ),
+	          _react2.default.createElement(
+	            'div',
+	            { className: 'doc-explorer-rhs' },
+	            this.props.children
+	          )
+	        ),
+	        _react2.default.createElement(
+	          'div',
+	          { className: 'doc-explorer-contents' },
+	          _react2.default.createElement(SearchBox, {
+	            isShown: shouldSearchBoxAppear,
+	            onSearch: this.handleSearch
+	          }),
+	          this.props.schema ? content : spinnerDiv
+	        )
+	      );
+	    }
+
+	    // Public API
+
+	  }, {
+	    key: 'showDoc',
+	    value: function showDoc(typeOrField) {
+	      var navStack = this.state.navStack;
+	      var isCurrentlyShown = navStack.length > 0 && navStack[navStack.length - 1] === typeOrField;
+	      if (!isCurrentlyShown) {
+	        navStack = navStack.concat([typeOrField]);
+	      }
+
+	      this.setState({ navStack: navStack });
+	    }
+
+	    // Public API
+
+	  }, {
+	    key: 'showSearch',
+	    value: function showSearch(searchItem) {
+	      var navStack = this.state.navStack;
+	      var lastEntry = navStack.length > 0 && navStack[navStack.length - 1];
+	      if (!lastEntry) {
+	        navStack = navStack.concat([searchItem]);
+	      } else if (lastEntry.searchValue !== searchItem.searchValue) {
+	        navStack = navStack.slice(0, -1).concat([searchItem]);
+	      }
+
+	      this.setState({ navStack: navStack });
+	    }
+	  }]);
+
+	  return DocExplorer;
+	}(_react2.default.Component);
+
+	DocExplorer.propTypes = {
+	  schema: _react.PropTypes.instanceOf(_graphql.GraphQLSchema)
+	};
+
+	var SearchBox = function (_React$Component2) {
+	  _inherits(SearchBox, _React$Component2);
+
+	  function SearchBox(props) {
+	    _classCallCheck(this, SearchBox);
+
+	    var _this2 = _possibleConstructorReturn(this, (SearchBox.__proto__ || Object.getPrototypeOf(SearchBox)).call(this, props));
+
+	    _this2.handleChange = function (event) {
+	      _this2.setState({ value: event.target.value });
+	      _this2._debouncedOnSearch();
+	    };
+
+	    _this2.state = { value: '' };
+
+	    _this2._debouncedOnSearch = (0, _debounce2.default)(200, function () {
+	      _this2.props.onSearch(_this2.state.value);
+	    });
+	    return _this2;
+	  }
+
+	  _createClass(SearchBox, [{
+	    key: 'shouldComponentUpdate',
+	    value: function shouldComponentUpdate(nextProps, nextState) {
+	      return nextProps.isShown !== this.props.isShown || nextState.value !== this.state.value;
+	    }
+	  }, {
+	    key: 'render',
+	    value: function render() {
+	      return _react2.default.createElement(
+	        'div',
+	        null,
+	        this.props.isShown && _react2.default.createElement(
+	          'label',
+	          { className: 'search-box-outer' },
+	          _react2.default.createElement('input', { className: 'search-box-input',
+	            onChange: this.handleChange,
+	            type: 'text',
+	            value: this.state.value,
+	            placeholder: 'Search the schema ...'
+	          })
+	        )
+	      );
+	    }
+	  }]);
+
+	  return SearchBox;
+	}(_react2.default.Component);
+
+	// Render Search Results
+
+
+	SearchBox.propTypes = {
+	  isShown: _react.PropTypes.bool,
+	  onSearch: _react.PropTypes.func
+	};
+
+	var SearchDoc = function (_React$Component3) {
+	  _inherits(SearchDoc, _React$Component3);
+
+	  function SearchDoc() {
+	    _classCallCheck(this, SearchDoc);
+
+	    return _possibleConstructorReturn(this, (SearchDoc.__proto__ || Object.getPrototypeOf(SearchDoc)).apply(this, arguments));
+	  }
+
+	  _createClass(SearchDoc, [{
+	    key: 'shouldComponentUpdate',
+	    value: function shouldComponentUpdate(nextProps) {
+	      return this.props.schema !== nextProps.schema || this.props.searchValue !== nextProps.searchValue;
+	    }
+	  }, {
+	    key: 'render',
+	    value: function render() {
+	      var _this4 = this;
+
+	      var searchValue = this.props.searchValue;
+	      var schema = this.props.schema;
+	      var onClickType = this.props.onClickType;
+	      var onClickField = this.props.onClickField;
+
+	      var typeMap = schema.getTypeMap();
+
+	      var matchedTypes = [];
+	      var matchedFields = [];
+
+	      var typeNames = Object.keys(typeMap);
+	      var _iteratorNormalCompletion = true;
+	      var _didIteratorError = false;
+	      var _iteratorError = undefined;
+
+	      try {
+	        var _loop = function _loop() {
+	          var typeName = _step.value;
+
+	          if (matchedTypes.length + matchedFields.length >= 100) {
+	            return 'break';
+	          }
+
+	          var type = typeMap[typeName];
+	          var matchedOn = [];
+	          if (_this4._isMatch(typeName, searchValue)) {
+	            matchedOn.push('Type Name');
+	          }
+
+	          if (matchedOn.length) {
+	            matchedTypes.push(_react2.default.createElement(
+	              'div',
+	              { className: 'doc-category-item' },
+	              _react2.default.createElement(TypeLink, { type: type, onClick: onClickType })
+	            ));
+	          }
+
+	          if (type.getFields) {
+	            (function () {
+	              var fields = type.getFields();
+	              Object.keys(fields).forEach(function (fieldName) {
+	                var field = fields[fieldName];
+	                if (_this4._isMatch(fieldName, searchValue)) {
+	                  matchedFields.push(_react2.default.createElement(
+	                    'div',
+	                    { className: 'doc-category-item' },
+	                    _react2.default.createElement(
+	                      'a',
+	                      { className: 'field-name',
+	                        onClick: function onClick(event) {
+	                          return onClickField(field, type, event);
+	                        } },
+	                      field.name
+	                    ),
+	                    ' on ',
+	                    _react2.default.createElement(TypeLink, { type: type, onClick: onClickType })
+	                  ));
+	                } else if (field.args && field.args.length) {
+	                  var matches = field.args.filter(function (arg) {
+	                    return _this4._isMatch(arg.name, searchValue);
+	                  });
+	                  if (matches.length > 0) {
+	                    matchedFields.push(_react2.default.createElement(
+	                      'div',
+	                      { className: 'doc-category-item' },
+	                      _react2.default.createElement(
+	                        'a',
+	                        { className: 'field-name',
+	                          onClick: function onClick(event) {
+	                            return onClickField(field, type, event);
+	                          } },
+	                        field.name
+	                      ),
+	                      '(',
+	                      _react2.default.createElement(
+	                        'span',
+	                        null,
+	                        matches.map(function (arg) {
+	                          return _react2.default.createElement(
+	                            'span',
+	                            { className: 'arg', key: arg.name },
+	                            _react2.default.createElement(
+	                              'span',
+	                              { className: 'arg-name' },
+	                              arg.name
+	                            ),
+	                            ': ',
+	                            _react2.default.createElement(TypeLink, { type: arg.type, onClick: onClickType })
+	                          );
+	                        })
+	                      ),
+	                      ')',
+	                      ' on ',
+	                      _react2.default.createElement(TypeLink, { type: type, onClick: onClickType })
+	                    ));
+	                  }
+	                }
+	              });
+	            })();
+	          }
+	        };
+
+	        for (var _iterator = typeNames[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+	          var _ret = _loop();
+
+	          if (_ret === 'break') break;
+	        }
+	      } catch (err) {
+	        _didIteratorError = true;
+	        _iteratorError = err;
+	      } finally {
+	        try {
+	          if (!_iteratorNormalCompletion && _iterator.return) {
+	            _iterator.return();
+	          }
+	        } finally {
+	          if (_didIteratorError) {
+	            throw _iteratorError;
+	          }
+	        }
+	      }
+
+	      if (matchedTypes.length === 0 && matchedFields.length === 0) {
+	        return _react2.default.createElement(
+	          'span',
+	          { className: 'doc-alert-text' },
+	          'No results found.'
+	        );
+	      }
+
+	      return _react2.default.createElement(
+	        'div',
+	        null,
+	        _react2.default.createElement(
+	          'div',
+	          { className: 'doc-category' },
+	          (matchedTypes.length > 0 || matchedFields.length > 0) && _react2.default.createElement(
+	            'div',
+	            { className: 'doc-category-title' },
+	            'search results'
+	          ),
+	          matchedTypes,
+	          matchedFields
+	        )
+	      );
+	    }
+	  }, {
+	    key: '_isMatch',
+	    value: function _isMatch(sourceText, searchValue) {
+	      try {
+	        var escaped = searchValue.replace(/[^_0-9A-Za-z]/g, function (ch) {
+	          return '\\' + ch;
+	        });
+	        return sourceText.search(new RegExp(escaped, 'i')) !== -1;
+	      } catch (e) {
+	        return sourceText.toLowerCase().indexOf(searchValue.toLowerCase()) !== -1;
+	      }
+	    }
+	  }]);
+
+	  return SearchDoc;
+	}(_react2.default.Component);
+
+	// Render the top level Schema
+
+
+	SearchDoc.propTypes = {
+	  schema: _react.PropTypes.object,
+	  searchValue: _react.PropTypes.string,
+	  onClickType: _react.PropTypes.func,
+	  onClickField: _react.PropTypes.func
+	};
+
+	var SchemaDoc = function (_React$Component4) {
+	  _inherits(SchemaDoc, _React$Component4);
+
+	  function SchemaDoc() {
+	    _classCallCheck(this, SchemaDoc);
+
+	    return _possibleConstructorReturn(this, (SchemaDoc.__proto__ || Object.getPrototypeOf(SchemaDoc)).apply(this, arguments));
+	  }
+
+	  _createClass(SchemaDoc, [{
+	    key: 'shouldComponentUpdate',
+	    value: function shouldComponentUpdate(nextProps) {
+	      return this.props.schema !== nextProps.schema;
+	    }
+	  }, {
+	    key: 'render',
+	    value: function render() {
+	      var schema = this.props.schema;
+	      var queryType = schema.getQueryType();
+	      var mutationType = schema.getMutationType && schema.getMutationType();
+	      var subscriptionType = schema.getSubscriptionType && schema.getSubscriptionType();
+
+	      return _react2.default.createElement(
+	        'div',
+	        null,
+	        _react2.default.createElement(MarkdownContent, {
+	          className: 'doc-type-description',
+	          markdown: 'A GraphQL schema provides a root type for each kind of operation.'
+	        }),
+	        _react2.default.createElement(
+	          'div',
+	          { className: 'doc-category' },
+	          _react2.default.createElement(
+	            'div',
+	            { className: 'doc-category-title' },
+	            'root types'
+	          ),
+	          _react2.default.createElement(
+	            'div',
+	            { className: 'doc-category-item' },
+	            _react2.default.createElement(
+	              'span',
+	              { className: 'keyword' },
+	              'query'
+	            ),
+	            ': ',
+	            _react2.default.createElement(TypeLink, { type: queryType, onClick: this.props.onClickType })
+	          ),
+	          mutationType && _react2.default.createElement(
+	            'div',
+	            { className: 'doc-category-item' },
+	            _react2.default.createElement(
+	              'span',
+	              { className: 'keyword' },
+	              'mutation'
+	            ),
+	            ': ',
+	            _react2.default.createElement(TypeLink, { type: mutationType, onClick: this.props.onClickType })
+	          ),
+	          subscriptionType && _react2.default.createElement(
+	            'div',
+	            { className: 'doc-category-item' },
+	            _react2.default.createElement(
+	              'span',
+	              { className: 'keyword' },
+	              'subscription'
+	            ),
+	            ': ',
+	            _react2.default.createElement(TypeLink, {
+	              type: subscriptionType,
+	              onClick: this.props.onClickType
+	            })
+	          )
+	        )
+	      );
+	    }
+	  }]);
+
+	  return SchemaDoc;
+	}(_react2.default.Component);
+
+	// Documentation for a Type
+
+
+	SchemaDoc.propTypes = {
+	  schema: _react.PropTypes.object,
+	  onClickType: _react.PropTypes.func
+	};
+
+	var TypeDoc = function (_React$Component5) {
+	  _inherits(TypeDoc, _React$Component5);
+
+	  function TypeDoc() {
+	    _classCallCheck(this, TypeDoc);
+
+	    return _possibleConstructorReturn(this, (TypeDoc.__proto__ || Object.getPrototypeOf(TypeDoc)).apply(this, arguments));
+	  }
+
+	  _createClass(TypeDoc, [{
+	    key: 'shouldComponentUpdate',
+	    value: function shouldComponentUpdate(nextProps) {
+	      return this.props.type !== nextProps.type || this.props.schema !== nextProps.schema;
+	    }
+	  }, {
+	    key: 'render',
+	    value: function render() {
+	      var schema = this.props.schema;
+	      var type = this.props.type;
+	      var onClickType = this.props.onClickType;
+	      var onClickField = this.props.onClickField;
+
+	      var typesTitle = void 0;
+	      var types = void 0;
+	      if (type instanceof _graphql.GraphQLUnionType) {
+	        typesTitle = 'possible types';
+	        types = schema.getPossibleTypes(type);
+	      } else if (type instanceof _graphql.GraphQLInterfaceType) {
+	        typesTitle = 'implementations';
+	        types = schema.getPossibleTypes(type);
+	      } else if (type instanceof _graphql.GraphQLObjectType) {
+	        typesTitle = 'implements';
+	        types = type.getInterfaces();
+	      }
+
+	      var typesDef = void 0;
+	      if (types && types.length > 0) {
+	        typesDef = _react2.default.createElement(
+	          'div',
+	          { className: 'doc-category' },
+	          _react2.default.createElement(
+	            'div',
+	            { className: 'doc-category-title' },
+	            typesTitle
+	          ),
+	          types.map(function (subtype) {
+	            return _react2.default.createElement(
+	              'div',
+	              { key: subtype.name, className: 'doc-category-item' },
+	              _react2.default.createElement(TypeLink, { type: subtype, onClick: onClickType })
+	            );
+	          })
+	        );
+	      }
+
+	      // InputObject and Object
+	      var fieldsDef = void 0;
+	      if (type.getFields) {
+	        (function () {
+	          var fieldMap = type.getFields();
+	          var fields = Object.keys(fieldMap).map(function (name) {
+	            return fieldMap[name];
+	          });
+	          fieldsDef = _react2.default.createElement(
+	            'div',
+	            { className: 'doc-category' },
+	            _react2.default.createElement(
+	              'div',
+	              { className: 'doc-category-title' },
+	              'fields'
+	            ),
+	            fields.map(function (field) {
+
+	              // Field arguments
+	              var argsDef = void 0;
+	              if (field.args && field.args.length > 0) {
+	                argsDef = field.args.map(function (arg) {
+	                  return _react2.default.createElement(
+	                    'span',
+	                    { className: 'arg', key: arg.name },
+	                    _react2.default.createElement(
+	                      'span',
+	                      { className: 'arg-name' },
+	                      arg.name
+	                    ),
+	                    ': ',
+	                    _react2.default.createElement(TypeLink, { type: arg.type, onClick: onClickType })
+	                  );
+	                });
+	              }
+
+	              return _react2.default.createElement(
+	                'div',
+	                { key: field.name, className: 'doc-category-item' },
+	                _react2.default.createElement(
+	                  'a',
+	                  {
+	                    className: 'field-name',
+	                    onClick: function onClick(event) {
+	                      return onClickField(field, type, event);
+	                    } },
+	                  field.name
+	                ),
+	                argsDef && ['(', _react2.default.createElement(
+	                  'span',
+	                  { key: 'args' },
+	                  argsDef
+	                ), ')'],
+	                ': ',
+	                _react2.default.createElement(TypeLink, { type: field.type, onClick: onClickType }),
+	                (field.isDeprecated || field.deprecationReason) && _react2.default.createElement(
+	                  'span',
+	                  { className: 'doc-alert-text' },
+	                  ' (DEPRECATED)'
+	                )
+	              );
+	            })
+	          );
+	        })();
+	      }
+
+	      var valuesDef = void 0;
+	      if (type instanceof _graphql.GraphQLEnumType) {
+	        valuesDef = _react2.default.createElement(
+	          'div',
+	          { className: 'doc-category' },
+	          _react2.default.createElement(
+	            'div',
+	            { className: 'doc-category-title' },
+	            'values'
+	          ),
+	          type.getValues().map(function (value) {
+	            return _react2.default.createElement(
+	              'div',
+	              { key: value.name, className: 'doc-category-item' },
+	              _react2.default.createElement(
+	                'div',
+	                { className: 'enum-value' },
+	                value.name,
+	                (value.isDeprecated || value.deprecationReason) && _react2.default.createElement(
+	                  'span',
+	                  { className: 'doc-alert-text' },
+	                  ' (DEPRECATED)'
+	                )
+	              ),
+	              _react2.default.createElement(MarkdownContent, {
+	                className: 'doc-value-description',
+	                markdown: value.description
+	              }),
+	              value.deprecationReason && _react2.default.createElement(MarkdownContent, {
+	                className: 'doc-alert-text',
+	                markdown: value.deprecationReason
+	              })
+	            );
+	          })
+	        );
+	      }
+
+	      return _react2.default.createElement(
+	        'div',
+	        null,
+	        _react2.default.createElement(MarkdownContent, {
+	          className: 'doc-type-description',
+	          markdown: type.description || 'No Description'
+	        }),
+	        type instanceof _graphql.GraphQLObjectType && typesDef,
+	        fieldsDef,
+	        valuesDef,
+	        !(type instanceof _graphql.GraphQLObjectType) && typesDef
+	      );
+	    }
+	  }]);
+
+	  return TypeDoc;
+	}(_react2.default.Component);
+
+	// Documentation for a field
+
+
+	TypeDoc.propTypes = {
+	  schema: _react.PropTypes.instanceOf(_graphql.GraphQLSchema),
+	  type: _react.PropTypes.object,
+	  onClickType: _react.PropTypes.func,
+	  onClickField: _react.PropTypes.func
+	};
+
+	var FieldDoc = function (_React$Component6) {
+	  _inherits(FieldDoc, _React$Component6);
+
+	  function FieldDoc() {
+	    _classCallCheck(this, FieldDoc);
+
+	    return _possibleConstructorReturn(this, (FieldDoc.__proto__ || Object.getPrototypeOf(FieldDoc)).apply(this, arguments));
+	  }
+
+	  _createClass(FieldDoc, [{
+	    key: 'shouldComponentUpdate',
+	    value: function shouldComponentUpdate(nextProps) {
+	      return this.props.field !== nextProps.field;
+	    }
+	  }, {
+	    key: 'render',
+	    value: function render() {
+	      var _this8 = this;
+
+	      var field = this.props.field;
+
+	      var argsDef = void 0;
+	      if (field.args && field.args.length > 0) {
+	        argsDef = _react2.default.createElement(
+	          'div',
+	          { className: 'doc-category' },
+	          _react2.default.createElement(
+	            'div',
+	            { className: 'doc-category-title' },
+	            'arguments'
+	          ),
+	          field.args.map(function (arg) {
+	            return _react2.default.createElement(
+	              'div',
+	              { key: arg.name, className: 'doc-category-item' },
+	              _react2.default.createElement(
+	                'div',
+	                null,
+	                _react2.default.createElement(
+	                  'span',
+	                  { className: 'arg-name' },
+	                  arg.name
+	                ),
+	                ': ',
+	                _react2.default.createElement(TypeLink, { type: arg.type, onClick: _this8.props.onClickType })
+	              ),
+	              _react2.default.createElement(MarkdownContent, {
+	                className: 'doc-value-description',
+	                markdown: arg.description
+	              })
+	            );
+	          })
+	        );
+	      }
+
+	      return _react2.default.createElement(
+	        'div',
+	        null,
+	        _react2.default.createElement(MarkdownContent, {
+	          className: 'doc-type-description',
+	          markdown: field.description || 'No Description'
+	        }),
+	        field.deprecationReason && _react2.default.createElement(MarkdownContent, {
+	          className: 'doc-alert-text',
+	          markdown: field.deprecationReason
+	        }),
+	        _react2.default.createElement(
+	          'div',
+	          { className: 'doc-category' },
+	          _react2.default.createElement(
+	            'div',
+	            { className: 'doc-category-title' },
+	            'type'
+	          ),
+	          _react2.default.createElement(TypeLink, { type: field.type, onClick: this.props.onClickType })
+	        ),
+	        argsDef
+	      );
+	    }
+	  }]);
+
+	  return FieldDoc;
+	}(_react2.default.Component);
+
+	// Renders a type link
+
+
+	FieldDoc.propTypes = {
+	  field: _react.PropTypes.object,
+	  onClickType: _react.PropTypes.func
+	};
+
+	var TypeLink = function (_React$Component7) {
+	  _inherits(TypeLink, _React$Component7);
+
+	  function TypeLink() {
+	    _classCallCheck(this, TypeLink);
+
+	    return _possibleConstructorReturn(this, (TypeLink.__proto__ || Object.getPrototypeOf(TypeLink)).apply(this, arguments));
+	  }
+
+	  _createClass(TypeLink, [{
+	    key: 'shouldComponentUpdate',
+	    value: function shouldComponentUpdate(nextProps) {
+	      return this.props.type !== nextProps.type;
+	    }
+	  }, {
+	    key: 'render',
+	    value: function render() {
+	      return renderType(this.props.type, this.props.onClick);
+	    }
+	  }]);
+
+	  return TypeLink;
+	}(_react2.default.Component);
+
+	TypeLink.propTypes = {
+	  type: _react.PropTypes.object,
+	  onClick: _react.PropTypes.func
+	};
+
+
+	function renderType(type, _onClick) {
+	  if (type instanceof _graphql.GraphQLNonNull) {
+	    return _react2.default.createElement(
+	      'span',
+	      null,
+	      renderType(type.ofType, _onClick),
+	      '!'
+	    );
+	  }
+	  if (type instanceof _graphql.GraphQLList) {
+	    return _react2.default.createElement(
+	      'span',
+	      null,
+	      '[',
+	      renderType(type.ofType, _onClick),
+	      ']'
+	    );
+	  }
+	  return _react2.default.createElement(
+	    'a',
+	    { className: 'type-name', onClick: function onClick(event) {
+	        return _onClick(type, event);
+	      } },
+	    type.name
+	  );
+	}
+
+	// Renders arbitrary markdown content
+
+	var MarkdownContent = function (_React$Component8) {
+	  _inherits(MarkdownContent, _React$Component8);
+
+	  function MarkdownContent() {
+	    _classCallCheck(this, MarkdownContent);
+
+	    return _possibleConstructorReturn(this, (MarkdownContent.__proto__ || Object.getPrototypeOf(MarkdownContent)).apply(this, arguments));
+	  }
+
+	  _createClass(MarkdownContent, [{
+	    key: 'shouldComponentUpdate',
+	    value: function shouldComponentUpdate(nextProps) {
+	      return this.props.markdown !== nextProps.markdown;
+	    }
+	  }, {
+	    key: 'render',
+	    value: function render() {
+	      var markdown = this.props.markdown;
+	      if (!markdown) {
+	        return _react2.default.createElement('div', null);
+	      }
+
+	      var html = (0, _marked2.default)(markdown, { sanitize: true });
+	      return _react2.default.createElement('div', {
+	        className: this.props.className,
+	        dangerouslySetInnerHTML: { __html: html }
+	      });
+	    }
+	  }]);
+
+	  return MarkdownContent;
+	}(_react2.default.Component);
+
+	MarkdownContent.propTypes = {
+	  markdown: _react.PropTypes.string,
+	  className: _react.PropTypes.string
+	};
+
+/***/ },
+/* 300 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = debounce;
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the license found in the
+	 *  LICENSE-examples file in the root directory of this source tree.
+	 */
+
+	/**
+	 * Provided a duration and a function, returns a new function which is called
+	 * `duration` milliseconds after the last call.
+	 */
+	function debounce(duration, fn) {
+	  var timeout = void 0;
+	  return function () {
+	    var _this = this,
+	        _arguments = arguments;
+
+	    clearTimeout(timeout);
+	    timeout = setTimeout(function () {
+	      timeout = null;
+	      fn.apply(_this, _arguments);
+	    }, duration);
+	  };
+	}
+
+/***/ },
+/* 301 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /**
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      *  Copyright (c) 2015, Facebook, Inc.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      *  All rights reserved.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      *
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      *  This source code is licensed under the license found in the
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      *  LICENSE-examples file in the root directory of this source tree.
+	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      */
+
+	var _reactDom = __webpack_require__(32);
+
+	var _reactDom2 = _interopRequireDefault(_reactDom);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	/**
+	 * When a containing DOM node's height has been altered, trigger a resize of
+	 * the related CodeMirror instance so that it is always correctly sized.
+	 */
+	var CodeMirrorSizer = function () {
+	  function CodeMirrorSizer() {
+	    _classCallCheck(this, CodeMirrorSizer);
+
+	    this.sizes = [];
+	  }
+
+	  _createClass(CodeMirrorSizer, [{
+	    key: 'updateSizes',
+	    value: function updateSizes(components) {
+	      var _this = this;
+
+	      components.forEach(function (component, i) {
+	        var size = _reactDom2.default.findDOMNode(component).clientHeight;
+	        if (i <= _this.sizes.length && size !== _this.sizes[i]) {
+	          component.getCodeMirror().setSize();
+	        }
+	        _this.sizes[i] = size;
+	      });
+	    }
+	  }]);
+
+	  return CodeMirrorSizer;
+	}();
+
+	exports.default = CodeMirrorSizer;
+
+/***/ },
+/* 302 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = getQueryFacts;
+	exports.collectVariables = collectVariables;
+
+	var _graphql = __webpack_require__(185);
+
+	/**
+	 * Provided previous "queryFacts", a GraphQL schema, and a query document
+	 * string, return a set of facts about that query useful for GraphiQL features.
+	 *
+	 * If the query cannot be parsed, returns undefined.
+	 */
+	function getQueryFacts(schema, documentStr) {
+	  if (!documentStr) {
+	    return;
+	  }
+
+	  var documentAST = void 0;
+	  try {
+	    documentAST = (0, _graphql.parse)(documentStr);
+	  } catch (e) {
+	    return;
+	  }
+
+	  var variableToType = schema ? collectVariables(schema, documentAST) : null;
+
+	  // Collect operations by their names.
+	  var operations = [];
+	  documentAST.definitions.forEach(function (def) {
+	    if (def.kind === 'OperationDefinition') {
+	      operations.push(def);
+	    }
+	  });
+
+	  return { variableToType: variableToType, operations: operations };
+	}
+
+	/**
+	 * Provided a schema and a document, produces a `variableToType` Object.
+	 */
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the license found in the
+	 *  LICENSE-examples file in the root directory of this source tree.
+	 */
+
+	function collectVariables(schema, documentAST) {
+	  var variableToType = Object.create(null);
+	  documentAST.definitions.forEach(function (definition) {
+	    if (definition.kind === 'OperationDefinition') {
+	      var variableDefinitions = definition.variableDefinitions;
+	      if (variableDefinitions) {
+	        variableDefinitions.forEach(function (_ref) {
+	          var variable = _ref.variable,
+	              type = _ref.type;
+
+	          var inputType = (0, _graphql.typeFromAST)(schema, type);
+	          if (inputType) {
+	            variableToType[variable.name.value] = inputType;
+	          }
+	        });
+	      }
+	    }
+	  });
+	  return variableToType;
+	}
+
+/***/ },
+/* 303 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = getSelectedOperationName;
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the license found in the
+	 *  LICENSE-examples file in the root directory of this source tree.
+	 */
+
+	/**
+	 * Provided optional previous operations and selected name, and a next list of
+	 * operations, determine what the next selected operation should be.
+	 */
+	function getSelectedOperationName(prevOperations, prevSelectedOperationName, operations) {
+	  // If there are not enough operations to bother with, return nothing.
+	  if (!operations || operations.length < 1) {
+	    return;
+	  }
+
+	  // If a previous selection still exists, continue to use it.
+	  var names = operations.map(function (op) {
+	    return op.name && op.name.value;
+	  });
+	  if (prevSelectedOperationName && names.indexOf(prevSelectedOperationName) !== -1) {
+	    return prevSelectedOperationName;
+	  }
+
+	  // If a previous selection was the Nth operation, use the same Nth.
+	  if (prevSelectedOperationName && prevOperations) {
+	    var prevNames = prevOperations.map(function (op) {
+	      return op.name && op.name.value;
+	    });
+	    var prevIndex = prevNames.indexOf(prevSelectedOperationName);
+	    if (prevIndex && prevIndex < names.length) {
+	      return names[prevIndex];
+	    }
+	  }
+
+	  // Use the first operation.
+	  return names[0];
+	}
+
+/***/ },
+/* 304 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = find;
+
+	/* eslint-disable no-undef */
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the BSD-style license found in the
+	 *  LICENSE file in the root directory of this source tree. An additional grant
+	 *  of patent rights can be found in the PATENTS file in the same directory.
+	 */
+
+	function find(list, predicate) {
+	  for (var i = 0; i < list.length; i++) {
+	    if (predicate(list[i])) {
+	      return list[i];
+	    }
+	  }
+	}
+
+/***/ },
+/* 305 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.fillLeafs = fillLeafs;
+
+	var _graphql = __webpack_require__(185);
+
+	/**
+	 * Given a document string which may not be valid due to terminal fields not
+	 * representing leaf values (Spec Section: "Leaf Field Selections"), and a
+	 * function which provides reasonable default field names for a given type,
+	 * this function will attempt to produce a schema which is valid after filling
+	 * in selection sets for the invalid fields.
+	 *
+	 * Note that there is no guarantee that the result will be a valid query, this
+	 * utility represents a "best effort" which may be useful within IDE tools.
+	 */
+	function fillLeafs(schema, docString, getDefaultFieldNames) {
+	  var insertions = [];
+
+	  if (!schema) {
+	    return { insertions: insertions, result: docString };
+	  }
+
+	  var ast = void 0;
+	  try {
+	    ast = (0, _graphql.parse)(docString);
+	  } catch (error) {
+	    return { insertions: insertions, result: docString };
+	  }
+
+	  var fieldNameFn = getDefaultFieldNames || defaultGetDefaultFieldNames;
+	  var typeInfo = new _graphql.TypeInfo(schema);
+	  (0, _graphql.visit)(ast, {
+	    leave: function leave(node) {
+	      typeInfo.leave(node);
+	    },
+	    enter: function enter(node) {
+	      typeInfo.enter(node);
+	      if (node.kind === 'Field' && !node.selectionSet) {
+	        var fieldType = typeInfo.getType();
+	        var selectionSet = buildSelectionSet(fieldType, fieldNameFn);
+	        if (selectionSet) {
+	          var indent = getIndentation(docString, node.loc.start);
+	          insertions.push({
+	            index: node.loc.end,
+	            string: ' ' + (0, _graphql.print)(selectionSet).replace(/\n/g, '\n' + indent)
+	          });
+	        }
+	      }
+	    }
+	  });
+
+	  // Apply the insertions, but also return the insertions metadata.
+	  return {
+	    insertions: insertions,
+	    result: withInsertions(docString, insertions)
+	  };
+	}
+
+	// The default function to use for producing the default fields from a type.
+	// This function first looks for some common patterns, and falls back to
+	// including all leaf-type fields.
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the license found in the
+	 *  LICENSE-examples file in the root directory of this source tree.
+	 */
+
+	function defaultGetDefaultFieldNames(type) {
+	  // If this type cannot access fields, then return an empty set.
+	  if (!type.getFields) {
+	    return [];
+	  }
+
+	  var fields = type.getFields();
+
+	  // Is there an `id` field?
+	  if (fields['id']) {
+	    return ['id'];
+	  }
+
+	  // Is there an `edges` field?
+	  if (fields['edges']) {
+	    return ['edges'];
+	  }
+
+	  // Is there an `node` field?
+	  if (fields['node']) {
+	    return ['node'];
+	  }
+
+	  // Include all leaf-type fields.
+	  var leafFieldNames = [];
+	  Object.keys(fields).forEach(function (fieldName) {
+	    if ((0, _graphql.isLeafType)(fields[fieldName].type)) {
+	      leafFieldNames.push(fieldName);
+	    }
+	  });
+	  return leafFieldNames;
+	}
+
+	// Given a GraphQL type, and a function which produces field names, recursively
+	// generate a SelectionSet which includes default fields.
+	function buildSelectionSet(type, getDefaultFieldNames) {
+	  // Unwrap any non-null or list types.
+	  var namedType = (0, _graphql.getNamedType)(type);
+
+	  // Unknown types and leaf types do not have selection sets.
+	  if (!type || (0, _graphql.isLeafType)(type)) {
+	    return;
+	  }
+
+	  // Get an array of field names to use.
+	  var fieldNames = getDefaultFieldNames(namedType);
+
+	  // If there are no field names to use, return no selection set.
+	  if (!Array.isArray(fieldNames) || fieldNames.length === 0) {
+	    return;
+	  }
+
+	  // Build a selection set of each field, calling buildSelectionSet recursively.
+	  return {
+	    kind: 'SelectionSet',
+	    selections: fieldNames.map(function (fieldName) {
+	      var fieldDef = namedType.getFields()[fieldName];
+	      var fieldType = fieldDef ? fieldDef.type : null;
+	      return {
+	        kind: 'Field',
+	        name: {
+	          kind: 'Name',
+	          value: fieldName
+	        },
+	        selectionSet: buildSelectionSet(fieldType, getDefaultFieldNames)
+	      };
+	    })
+	  };
+	}
+
+	// Given an initial string, and a list of "insertion" { index, string } objects,
+	// return a new string with these insertions applied.
+	function withInsertions(initial, insertions) {
+	  if (insertions.length === 0) {
+	    return initial;
+	  }
+	  var edited = '';
+	  var prevIndex = 0;
+	  insertions.forEach(function (_ref) {
+	    var index = _ref.index,
+	        string = _ref.string;
+
+	    edited += initial.slice(prevIndex, index) + string;
+	    prevIndex = index;
+	  });
+	  edited += initial.slice(prevIndex);
+	  return edited;
+	}
+
+	// Given a string and an index, look backwards to find the string of whitespace
+	// following the next previous line break.
+	function getIndentation(str, index) {
+	  var indentStart = index;
+	  var indentEnd = index;
+	  while (indentStart) {
+	    var c = str.charCodeAt(indentStart - 1);
+	    // line break
+	    if (c === 10 || c === 13 || c === 0x2028 || c === 0x2029) {
+	      break;
+	    }
+	    indentStart--;
+	    // not white space
+	    if (c !== 9 && c !== 11 && c !== 12 && c !== 32 && c !== 160) {
+	      indentEnd = indentStart;
+	    }
+	  }
+	  return str.substring(indentStart, indentEnd);
+	}
+
+/***/ },
+/* 306 */
+/***/ function(module, exports) {
+
+	"use strict";
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.getLeft = getLeft;
+	exports.getTop = getTop;
+	/**
+	 *  Copyright (c) 2015, Facebook, Inc.
+	 *  All rights reserved.
+	 *
+	 *  This source code is licensed under the license found in the
+	 *  LICENSE-examples file in the root directory of this source tree.
+	 */
+
+	/**
+	 * Utility functions to get a pixel distance from left/top of the window.
+	 */
+
+	function getLeft(initialElem) {
+	  var pt = 0;
+	  var elem = initialElem;
+	  while (elem.offsetParent) {
+	    pt += elem.offsetLeft;
+	    elem = elem.offsetParent;
+	  }
+	  return pt;
+	}
+
+	function getTop(initialElem) {
+	  var pt = 0;
+	  var elem = initialElem;
+	  while (elem.offsetParent) {
+	    pt += elem.offsetTop;
+	    elem = elem.offsetParent;
+	  }
+	  return pt;
+	}
+
+/***/ },
+/* 307 */
+/***/ function(module, exports, __webpack_require__) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _graphql = __webpack_require__(185);
+
+	Object.defineProperty(exports, 'introspectionQuery', {
+	  enumerable: true,
+	  get: function get() {
+	    return _graphql.introspectionQuery;
+	  }
+	});
+
+
+	// Some GraphQL services do not support subscriptions and fail an introspection
+	// query which includes the `subscriptionType` field as the stock introspection
+	// query does. This backup query removes that field.
+	var introspectionQuerySansSubscriptions = exports.introspectionQuerySansSubscriptions = '\n  query IntrospectionQuery {\n    __schema {\n      queryType { name }\n      mutationType { name }\n      types {\n        ...FullType\n      }\n      directives {\n        name\n        description\n        locations\n        args {\n          ...InputValue\n        }\n      }\n    }\n  }\n\n  fragment FullType on __Type {\n    kind\n    name\n    description\n    fields(includeDeprecated: true) {\n      name\n      description\n      args {\n        ...InputValue\n      }\n      type {\n        ...TypeRef\n      }\n      isDeprecated\n      deprecationReason\n    }\n    inputFields {\n      ...InputValue\n    }\n    interfaces {\n      ...TypeRef\n    }\n    enumValues(includeDeprecated: true) {\n      name\n      description\n      isDeprecated\n      deprecationReason\n    }\n    possibleTypes {\n      ...TypeRef\n    }\n  }\n\n  fragment InputValue on __InputValue {\n    name\n    description\n    type { ...TypeRef }\n    defaultValue\n  }\n\n  fragment TypeRef on __Type {\n    kind\n    name\n    ofType {\n      kind\n      name\n      ofType {\n        kind\n        name\n        ofType {\n          kind\n          name\n          ofType {\n            kind\n            name\n            ofType {\n              kind\n              name\n              ofType {\n                kind\n                name\n                ofType {\n                  kind\n                  name\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n';
+
+/***/ },
+/* 308 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// the whatwg-fetch polyfill installs the fetch() function
+	// on the global object (window or self)
+	//
+	// Return that as the export for use in Webpack, Browserify etc.
+	__webpack_require__(309);
+	module.exports = self.fetch.bind(self);
+
+
+/***/ },
+/* 309 */
+/***/ function(module, exports) {
+
+	(function(self) {
+	  'use strict';
+
+	  if (self.fetch) {
+	    return
+	  }
+
+	  var support = {
+	    searchParams: 'URLSearchParams' in self,
+	    iterable: 'Symbol' in self && 'iterator' in Symbol,
+	    blob: 'FileReader' in self && 'Blob' in self && (function() {
+	      try {
+	        new Blob()
+	        return true
+	      } catch(e) {
+	        return false
+	      }
+	    })(),
+	    formData: 'FormData' in self,
+	    arrayBuffer: 'ArrayBuffer' in self
+	  }
+
+	  if (support.arrayBuffer) {
+	    var viewClasses = [
+	      '[object Int8Array]',
+	      '[object Uint8Array]',
+	      '[object Uint8ClampedArray]',
+	      '[object Int16Array]',
+	      '[object Uint16Array]',
+	      '[object Int32Array]',
+	      '[object Uint32Array]',
+	      '[object Float32Array]',
+	      '[object Float64Array]'
+	    ]
+
+	    var isDataView = function(obj) {
+	      return obj && DataView.prototype.isPrototypeOf(obj)
+	    }
+
+	    var isArrayBufferView = ArrayBuffer.isView || function(obj) {
+	      return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
+	    }
+	  }
+
+	  function normalizeName(name) {
+	    if (typeof name !== 'string') {
+	      name = String(name)
+	    }
+	    if (/[^a-z0-9\-#$%&'*+.\^_`|~]/i.test(name)) {
+	      throw new TypeError('Invalid character in header field name')
+	    }
+	    return name.toLowerCase()
+	  }
+
+	  function normalizeValue(value) {
+	    if (typeof value !== 'string') {
+	      value = String(value)
+	    }
+	    return value
+	  }
+
+	  // Build a destructive iterator for the value list
+	  function iteratorFor(items) {
+	    var iterator = {
+	      next: function() {
+	        var value = items.shift()
+	        return {done: value === undefined, value: value}
+	      }
+	    }
+
+	    if (support.iterable) {
+	      iterator[Symbol.iterator] = function() {
+	        return iterator
+	      }
+	    }
+
+	    return iterator
+	  }
+
+	  function Headers(headers) {
+	    this.map = {}
+
+	    if (headers instanceof Headers) {
+	      headers.forEach(function(value, name) {
+	        this.append(name, value)
+	      }, this)
+
+	    } else if (headers) {
+	      Object.getOwnPropertyNames(headers).forEach(function(name) {
+	        this.append(name, headers[name])
+	      }, this)
+	    }
+	  }
+
+	  Headers.prototype.append = function(name, value) {
+	    name = normalizeName(name)
+	    value = normalizeValue(value)
+	    var oldValue = this.map[name]
+	    this.map[name] = oldValue ? oldValue+','+value : value
+	  }
+
+	  Headers.prototype['delete'] = function(name) {
+	    delete this.map[normalizeName(name)]
+	  }
+
+	  Headers.prototype.get = function(name) {
+	    name = normalizeName(name)
+	    return this.has(name) ? this.map[name] : null
+	  }
+
+	  Headers.prototype.has = function(name) {
+	    return this.map.hasOwnProperty(normalizeName(name))
+	  }
+
+	  Headers.prototype.set = function(name, value) {
+	    this.map[normalizeName(name)] = normalizeValue(value)
+	  }
+
+	  Headers.prototype.forEach = function(callback, thisArg) {
+	    for (var name in this.map) {
+	      if (this.map.hasOwnProperty(name)) {
+	        callback.call(thisArg, this.map[name], name, this)
+	      }
+	    }
+	  }
+
+	  Headers.prototype.keys = function() {
+	    var items = []
+	    this.forEach(function(value, name) { items.push(name) })
+	    return iteratorFor(items)
+	  }
+
+	  Headers.prototype.values = function() {
+	    var items = []
+	    this.forEach(function(value) { items.push(value) })
+	    return iteratorFor(items)
+	  }
+
+	  Headers.prototype.entries = function() {
+	    var items = []
+	    this.forEach(function(value, name) { items.push([name, value]) })
+	    return iteratorFor(items)
+	  }
+
+	  if (support.iterable) {
+	    Headers.prototype[Symbol.iterator] = Headers.prototype.entries
+	  }
+
+	  function consumed(body) {
+	    if (body.bodyUsed) {
+	      return Promise.reject(new TypeError('Already read'))
+	    }
+	    body.bodyUsed = true
+	  }
+
+	  function fileReaderReady(reader) {
+	    return new Promise(function(resolve, reject) {
+	      reader.onload = function() {
+	        resolve(reader.result)
+	      }
+	      reader.onerror = function() {
+	        reject(reader.error)
+	      }
+	    })
+	  }
+
+	  function readBlobAsArrayBuffer(blob) {
+	    var reader = new FileReader()
+	    var promise = fileReaderReady(reader)
+	    reader.readAsArrayBuffer(blob)
+	    return promise
+	  }
+
+	  function readBlobAsText(blob) {
+	    var reader = new FileReader()
+	    var promise = fileReaderReady(reader)
+	    reader.readAsText(blob)
+	    return promise
+	  }
+
+	  function readArrayBufferAsText(buf) {
+	    var view = new Uint8Array(buf)
+	    var chars = new Array(view.length)
+
+	    for (var i = 0; i < view.length; i++) {
+	      chars[i] = String.fromCharCode(view[i])
+	    }
+	    return chars.join('')
+	  }
+
+	  function bufferClone(buf) {
+	    if (buf.slice) {
+	      return buf.slice(0)
+	    } else {
+	      var view = new Uint8Array(buf.byteLength)
+	      view.set(new Uint8Array(buf))
+	      return view.buffer
+	    }
+	  }
+
+	  function Body() {
+	    this.bodyUsed = false
+
+	    this._initBody = function(body) {
+	      this._bodyInit = body
+	      if (!body) {
+	        this._bodyText = ''
+	      } else if (typeof body === 'string') {
+	        this._bodyText = body
+	      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
+	        this._bodyBlob = body
+	      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
+	        this._bodyFormData = body
+	      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+	        this._bodyText = body.toString()
+	      } else if (support.arrayBuffer && support.blob && isDataView(body)) {
+	        this._bodyArrayBuffer = bufferClone(body.buffer)
+	        // IE 10-11 can't handle a DataView body.
+	        this._bodyInit = new Blob([this._bodyArrayBuffer])
+	      } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
+	        this._bodyArrayBuffer = bufferClone(body)
+	      } else {
+	        throw new Error('unsupported BodyInit type')
+	      }
+
+	      if (!this.headers.get('content-type')) {
+	        if (typeof body === 'string') {
+	          this.headers.set('content-type', 'text/plain;charset=UTF-8')
+	        } else if (this._bodyBlob && this._bodyBlob.type) {
+	          this.headers.set('content-type', this._bodyBlob.type)
+	        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+	          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8')
+	        }
+	      }
+	    }
+
+	    if (support.blob) {
+	      this.blob = function() {
+	        var rejected = consumed(this)
+	        if (rejected) {
+	          return rejected
+	        }
+
+	        if (this._bodyBlob) {
+	          return Promise.resolve(this._bodyBlob)
+	        } else if (this._bodyArrayBuffer) {
+	          return Promise.resolve(new Blob([this._bodyArrayBuffer]))
+	        } else if (this._bodyFormData) {
+	          throw new Error('could not read FormData body as blob')
+	        } else {
+	          return Promise.resolve(new Blob([this._bodyText]))
+	        }
+	      }
+
+	      this.arrayBuffer = function() {
+	        if (this._bodyArrayBuffer) {
+	          return consumed(this) || Promise.resolve(this._bodyArrayBuffer)
+	        } else {
+	          return this.blob().then(readBlobAsArrayBuffer)
+	        }
+	      }
+	    }
+
+	    this.text = function() {
+	      var rejected = consumed(this)
+	      if (rejected) {
+	        return rejected
+	      }
+
+	      if (this._bodyBlob) {
+	        return readBlobAsText(this._bodyBlob)
+	      } else if (this._bodyArrayBuffer) {
+	        return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
+	      } else if (this._bodyFormData) {
+	        throw new Error('could not read FormData body as text')
+	      } else {
+	        return Promise.resolve(this._bodyText)
+	      }
+	    }
+
+	    if (support.formData) {
+	      this.formData = function() {
+	        return this.text().then(decode)
+	      }
+	    }
+
+	    this.json = function() {
+	      return this.text().then(JSON.parse)
+	    }
+
+	    return this
+	  }
+
+	  // HTTP methods whose capitalization should be normalized
+	  var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT']
+
+	  function normalizeMethod(method) {
+	    var upcased = method.toUpperCase()
+	    return (methods.indexOf(upcased) > -1) ? upcased : method
+	  }
+
+	  function Request(input, options) {
+	    options = options || {}
+	    var body = options.body
+
+	    if (typeof input === 'string') {
+	      this.url = input
+	    } else {
+	      if (input.bodyUsed) {
+	        throw new TypeError('Already read')
+	      }
+	      this.url = input.url
+	      this.credentials = input.credentials
+	      if (!options.headers) {
+	        this.headers = new Headers(input.headers)
+	      }
+	      this.method = input.method
+	      this.mode = input.mode
+	      if (!body && input._bodyInit != null) {
+	        body = input._bodyInit
+	        input.bodyUsed = true
+	      }
+	    }
+
+	    this.credentials = options.credentials || this.credentials || 'omit'
+	    if (options.headers || !this.headers) {
+	      this.headers = new Headers(options.headers)
+	    }
+	    this.method = normalizeMethod(options.method || this.method || 'GET')
+	    this.mode = options.mode || this.mode || null
+	    this.referrer = null
+
+	    if ((this.method === 'GET' || this.method === 'HEAD') && body) {
+	      throw new TypeError('Body not allowed for GET or HEAD requests')
+	    }
+	    this._initBody(body)
+	  }
+
+	  Request.prototype.clone = function() {
+	    return new Request(this, { body: this._bodyInit })
+	  }
+
+	  function decode(body) {
+	    var form = new FormData()
+	    body.trim().split('&').forEach(function(bytes) {
+	      if (bytes) {
+	        var split = bytes.split('=')
+	        var name = split.shift().replace(/\+/g, ' ')
+	        var value = split.join('=').replace(/\+/g, ' ')
+	        form.append(decodeURIComponent(name), decodeURIComponent(value))
+	      }
+	    })
+	    return form
+	  }
+
+	  function parseHeaders(rawHeaders) {
+	    var headers = new Headers()
+	    rawHeaders.split('\r\n').forEach(function(line) {
+	      var parts = line.split(':')
+	      var key = parts.shift().trim()
+	      if (key) {
+	        var value = parts.join(':').trim()
+	        headers.append(key, value)
+	      }
+	    })
+	    return headers
+	  }
+
+	  Body.call(Request.prototype)
+
+	  function Response(bodyInit, options) {
+	    if (!options) {
+	      options = {}
+	    }
+
+	    this.type = 'default'
+	    this.status = 'status' in options ? options.status : 200
+	    this.ok = this.status >= 200 && this.status < 300
+	    this.statusText = 'statusText' in options ? options.statusText : 'OK'
+	    this.headers = new Headers(options.headers)
+	    this.url = options.url || ''
+	    this._initBody(bodyInit)
+	  }
+
+	  Body.call(Response.prototype)
+
+	  Response.prototype.clone = function() {
+	    return new Response(this._bodyInit, {
+	      status: this.status,
+	      statusText: this.statusText,
+	      headers: new Headers(this.headers),
+	      url: this.url
+	    })
+	  }
+
+	  Response.error = function() {
+	    var response = new Response(null, {status: 0, statusText: ''})
+	    response.type = 'error'
+	    return response
+	  }
+
+	  var redirectStatuses = [301, 302, 303, 307, 308]
+
+	  Response.redirect = function(url, status) {
+	    if (redirectStatuses.indexOf(status) === -1) {
+	      throw new RangeError('Invalid status code')
+	    }
+
+	    return new Response(null, {status: status, headers: {location: url}})
+	  }
+
+	  self.Headers = Headers
+	  self.Request = Request
+	  self.Response = Response
+
+	  self.fetch = function(input, init) {
+	    return new Promise(function(resolve, reject) {
+	      var request = new Request(input, init)
+	      var xhr = new XMLHttpRequest()
+
+	      xhr.onload = function() {
+	        var options = {
+	          status: xhr.status,
+	          statusText: xhr.statusText,
+	          headers: parseHeaders(xhr.getAllResponseHeaders() || '')
+	        }
+	        options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL')
+	        var body = 'response' in xhr ? xhr.response : xhr.responseText
+	        resolve(new Response(body, options))
+	      }
+
+	      xhr.onerror = function() {
+	        reject(new TypeError('Network request failed'))
+	      }
+
+	      xhr.ontimeout = function() {
+	        reject(new TypeError('Network request failed'))
+	      }
+
+	      xhr.open(request.method, request.url, true)
+
+	      if (request.credentials === 'include') {
+	        xhr.withCredentials = true
+	      }
+
+	      if ('responseType' in xhr && support.blob) {
+	        xhr.responseType = 'blob'
+	      }
+
+	      request.headers.forEach(function(value, name) {
+	        xhr.setRequestHeader(name, value)
+	      })
+
+	      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit)
+	    })
+	  }
+	  self.fetch.polyfill = true
+	})(typeof self !== 'undefined' ? self : this);
+
+
+/***/ },
+/* 310 */
+/***/ function(module, exports, __webpack_require__) {
+
+	// style-loader: Adds some css to the DOM by adding a <style> tag
+
+	// load the styles
+	var content = __webpack_require__(311);
+	if(typeof content === 'string') content = [[module.id, content, '']];
+	// add the styles to the DOM
+	var update = __webpack_require__(313)(content, {});
+	if(content.locals) module.exports = content.locals;
+	// Hot Module Replacement
+	if(false) {
+		// When the styles change, update the <style> tags
+		if(!content.locals) {
+			module.hot.accept("!!./../css-loader/index.js!./graphiql.css", function() {
+				var newContent = require("!!./../css-loader/index.js!./graphiql.css");
+				if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
+				update(newContent);
+			});
+		}
+		// When the module is disposed, remove the <style> tags
+		module.hot.dispose(function() { update(); });
+	}
+
+/***/ },
+/* 311 */
+/***/ function(module, exports, __webpack_require__) {
+
+	exports = module.exports = __webpack_require__(312)();
+	// imports
+
+
+	// module
+	exports.push([module.id, ".graphiql-container {\n  color: #141823;\n  display: -webkit-flex;\n  display: -ms-flexbox;\n  -webkit-flex-direction: row;\n      -ms-flex-direction: row;\n          flex-direction: row;\n  font-family:\n    system,\n    -apple-system,\n    'San Francisco',\n    '.SFNSDisplay-Regular',\n    'Segoe UI',\n    Segoe,\n    'Segoe WP',\n    'Helvetica Neue',\n    helvetica,\n    'Lucida Grande',\n    arial,\n    sans-serif;\n  font-size: 14px;\n  height: 100%;\n  margin: 0;\n  overflow: hidden;\n  width: 100%;\n}\n\n.graphiql-container .editorWrap {\n  display: -webkit-flex;\n  display: -ms-flexbox;\n  display: -ms-flexbox;\n  -webkit-flex-direction: column;\n      -ms-flex-direction: column;\n          flex-direction: column;\n  -webkit-flex: 1;\n      -ms-flex: 1;\n          flex: 1;\n}\n\n.graphiql-container .title {\n  font-size: 18px;\n}\n\n.graphiql-container .title em {\n  font-family: georgia;\n  font-size: 19px;\n}\n\n.graphiql-container .topBarWrap {\n  display: -webkit-flex;\n  display: -ms-flexbox;\n  -webkit-flex-direction: row;\n      -ms-flex-direction: row;\n          flex-direction: row;\n}\n\n.graphiql-container .topBar {\n  -webkit-align-items: center;\n      -ms-align-items: center;\n          align-items: center;\n  background: -webkit-linear-gradient(#f7f7f7, #e2e2e2);\n  background:         linear-gradient(#f7f7f7, #e2e2e2);\n  border-bottom: 1px solid #d0d0d0;\n  cursor: default;\n  display: -webkit-flex;\n  display: -ms-flexbox;\n  height: 34px;\n  padding: 7px 14px 6px;\n  -webkit-flex: 1;\n      -ms-flex: 1;\n          flex: 1;\n  -webkit-flex-direction: row;\n      -ms-flex-direction: row;\n          flex-direction: row;\n  -webkit-user-select: none;\n      -ms-user-select: none;\n          user-select: none;\n}\n\n.graphiql-container .toolbar {\n  overflow-x: auto;\n}\n\n.graphiql-container .docExplorerShow {\n  background: -webkit-linear-gradient(#f7f7f7, #e2e2e2);\n  background:         linear-gradient(#f7f7f7, #e2e2e2);\n  border-bottom: 1px solid #d0d0d0;\n  border-left: 1px solid rgba(0, 0, 0, 0.2);\n  border-right: none;\n  border-top: none;\n  color: #3B5998;\n  cursor: pointer;\n  font-size: 14px;\n  outline: 0;\n  margin: 0;\n  padding: 2px 20px 0 18px;\n}\n\n.graphiql-container .docExplorerShow:before {\n  border-left: 2px solid #3B5998;\n  border-top: 2px solid #3B5998;\n  content: '';\n  display: inline-block;\n  height: 9px;\n  margin: 0 3px -1px 0;\n  position: relative;\n  -webkit-transform: rotate(-45deg);\n      -ms-transform: rotate(-45deg);\n          transform: rotate(-45deg);\n  width: 9px;\n}\n\n.graphiql-container .editorBar {\n  display: -webkit-flex;\n  display: -ms-flexbox;\n  -webkit-flex: 1;\n      -ms-flex: 1;\n          flex: 1;\n  -webkit-flex-direction: row;\n      -ms-flex-direction: row;\n          flex-direction: row;\n}\n\n.graphiql-container .queryWrap {\n  display: -webkit-flex;\n  display: -ms-flexbox;\n  -webkit-flex: 1;\n      -ms-flex: 1;\n          flex: 1;\n  -webkit-flex-direction: column;\n      -ms-flex-direction: column;\n          flex-direction: column;\n}\n\n.graphiql-container .resultWrap {\n  border-left: solid 1px #e0e0e0;\n  display: -webkit-flex;\n  display:         flex;\n  position: relative;\n  -webkit-flex: 1;\n      -ms-flex: 1;\n          flex: 1;\n  -webkit-flex-direction: column;\n      -ms-flex-direction: column;\n          flex-direction: column;\n}\n\n.graphiql-container .docExplorerWrap {\n  background: white;\n  box-shadow: 0 0 8px rgba(0, 0, 0, 0.15);\n  position: relative;\n  z-index: 3;\n}\n\n.graphiql-container .docExplorerResizer {\n  cursor: col-resize;\n  height: 100%;\n  left: -5px;\n  position: absolute;\n  top: 0;\n  width: 10px;\n  z-index: 10;\n}\n\n.graphiql-container .docExplorerHide {\n  cursor: pointer;\n  font-size: 18px;\n  margin: -7px -8px -6px 0;\n  padding: 18px 16px 15px 12px;\n}\n\n.graphiql-container .query-editor {\n  -webkit-flex: 1;\n      -ms-flex: 1;\n          flex: 1;\n  position: relative;\n}\n\n.graphiql-container .variable-editor {\n  display: -webkit-flex;\n  display:     -ms-flex;\n  display:         flex;\n  height: 29px;\n  -webkit-flex-direction: column;\n      -ms-flex-direction: column;\n          flex-direction: column;\n  position: relative;\n}\n\n.graphiql-container .variable-editor-title {\n  background: #eeeeee;\n  border-bottom: 1px solid #d6d6d6;\n  border-top: 1px solid #e0e0e0;\n  color: #777;\n  font-variant: small-caps;\n  font-weight: bold;\n  letter-spacing: 1px;\n  line-height: 14px;\n  padding: 6px 0 8px 43px;\n  text-transform: lowercase;\n  -webkit-user-select: none;\n      -ms-user-select: none;\n          user-select: none;\n}\n\n.graphiql-container .codemirrorWrap {\n  -webkit-flex: 1;\n      -ms-flex: 1;\n          flex: 1;\n  position: relative;\n  height: 100%;\n}\n\n.graphiql-container .result-window {\n  -webkit-flex: 1;\n      -ms-flex: 1;\n          flex: 1;\n  position: relative;\n  height: 100%;\n}\n\n.graphiql-container .footer {\n  background: #f6f7f8;\n  border-left: 1px solid #e0e0e0;\n  border-top: 1px solid #e0e0e0;\n  margin-left: 12px;\n  position: relative;\n}\n\n.graphiql-container .footer:before {\n  background: #eeeeee;\n  bottom: 0;\n  content: \" \";\n  left: -13px;\n  position: absolute;\n  top: -1px;\n  width: 12px;\n}\n\n.graphiql-container .result-window .CodeMirror {\n  background: #f6f7f8;\n}\n\n.graphiql-container .result-window .CodeMirror-gutters {\n  background-color: #eeeeee;\n  border-color: #e0e0e0;\n  cursor: col-resize;\n}\n\n.graphiql-container .result-window .CodeMirror-foldgutter,\n.graphiql-container .result-window .CodeMirror-foldgutter-open:after,\n.graphiql-container .result-window .CodeMirror-foldgutter-folded:after {\n  padding-left: 3px;\n}\n\n.graphiql-container .toolbar-button {\n  background: #fdfdfd;\n  background: -webkit-linear-gradient(#fbfbfb, #f8f8f8);\n  background:         linear-gradient(#fbfbfb, #f8f8f8);\n  border-width: 0.5px;\n  border-style: solid;\n  border-color: #d3d3d3 #d0d0d0 #bababa;\n  border-radius: 4px;\n  box-shadow: 0 1px 1px -1px rgba(0, 0, 0, 0.13), inset 0 1px #fff;\n  color: #444;\n  cursor: pointer;\n  display: inline-block;\n  margin: 0 5px 0;\n  padding: 2px 8px 4px;\n  text-decoration: none;\n}\n\n.graphiql-container .toolbar-button:active {\n  background: -webkit-linear-gradient(#ececec, #d8d8d8);\n  background:         linear-gradient(#ececec, #d8d8d8);\n  border-color: #cacaca #c9c9c9 #b0b0b0;\n  box-shadow:\n    0 1px 0 #fff,\n    inset 0 1px rgba(255, 255, 255, 0.2),\n    inset 0 1px 1px rgba(0, 0, 0, 0.08);\n}\n\n.graphiql-container .toolbar-button.error {\n  background: -webkit-linear-gradient(#fdf3f3, #e6d6d7);\n  background:         linear-gradient(#fdf3f3, #e6d6d7);\n  color: #b00;\n}\n\n.graphiql-container .execute-button-wrap {\n  position: relative;\n  margin: 0 14px 0 28px;\n  height: 34px;\n}\n\n.graphiql-container .execute-button {\n  background: -webkit-linear-gradient(#fdfdfd, #d2d3d6);\n  background:         linear-gradient(#fdfdfd, #d2d3d6);\n  border: 1px solid rgba(0,0,0,0.25);\n  border-radius: 17px;\n  box-shadow: 0 1px 0 #fff;\n  cursor: pointer;\n  fill: #444;\n  height: 34px;\n  margin: 0;\n  padding: 0;\n  width: 34px;\n}\n\n.graphiql-container .execute-button svg {\n  pointer-events: none;\n}\n\n.graphiql-container .execute-button:active {\n  background: -webkit-linear-gradient(#e6e6e6, #c0c0c0);\n  background:         linear-gradient(#e6e6e6, #c0c0c0);\n  box-shadow:\n    0 1px 0 #fff,\n    inset 0 0 2px rgba(0, 0, 0, 0.3),\n    inset 0 0 6px rgba(0, 0, 0, 0.2);\n}\n\n.graphiql-container .execute-button:focus {\n  outline: 0;\n}\n\n.graphiql-container .execute-options {\n  background: #fff;\n  box-shadow:\n    0 0 0 1px rgba(0,0,0,0.1),\n    0 2px 4px rgba(0,0,0,0.25);\n  left: -1px;\n  margin: 0;\n  padding: 8px 0;\n  position: absolute;\n  top: 37px;\n  z-index: 100;\n}\n\n.graphiql-container .execute-options li {\n  padding: 2px 30px 4px 10px;\n  list-style: none;\n  min-width: 100px;\n  cursor: pointer;\n}\n\n.graphiql-container .execute-options li.selected {\n  background: #e10098;\n  color: white;\n}\n\n.graphiql-container .CodeMirror-scroll {\n  -webkit-overflow-scrolling: touch;\n      -ms-overflow-scrolling: touch;\n}\n\n.graphiql-container .CodeMirror {\n  color: #141823;\n  font-family:\n    'Consolas',\n    'Inconsolata',\n    'Droid Sans Mono',\n    'Monaco',\n    monospace;\n  font-size: 13px;\n  height: 100%;\n  left: 0;\n  position: absolute;\n  top: 0;\n  width: 100%;\n}\n\n.graphiql-container .CodeMirror-lines {\n  padding: 20px 0;\n}\n\n.CodeMirror-hint-information .content {\n  -webkit-box-orient: vertical;\n      -ms-box-orient: vertical;\n          box-orient: vertical;\n  color: #141823;\n  display: -webkit-box;\n  font-family: system, -apple-system, 'San Francisco', '.SFNSDisplay-Regular', 'Segoe UI', Segoe, 'Segoe WP', 'Helvetica Neue', helvetica, 'Lucida Grande', arial, sans-serif;\n  font-size: 13px;\n  -webkit-line-clamp: 3;\n          line-clamp: 3;\n  line-height: 16px;\n  max-height: 48px;\n  overflow: hidden;\n  text-overflow: -o-ellipsis-lastline;\n}\n\n.CodeMirror-hint-information .content p:first-child {\n  margin-top: 0;\n}\n\n.CodeMirror-hint-information .content p:last-child {\n  margin-bottom: 0;\n}\n\n.CodeMirror-hint-information .infoType {\n  color: #30a;\n  cursor: pointer;\n  display: inline;\n  margin-right: 0.5em;\n}\n\n.autoInsertedLeaf.cm-property {\n  -webkit-animation-duration: 6s;\n     -moz-animation-duration: 6s;\n      -ms-animation-duration: 6s;\n          animation-duration: 6s;\n  -webkit-animation-name: insertionFade;\n     -moz-animation-name: insertionFade;\n      -ms-animation-name: insertionFade;\n          animation-name: insertionFade;\n  border-bottom: 2px solid rgba(255, 255, 255, 0);\n  border-radius: 2px;\n  margin: -2px -4px -1px;\n  padding: 2px 4px 1px;\n}\n\n@-moz-keyframes insertionFade {\n  from, to {\n    background: rgba(255, 255, 255, 0);\n    border-color: rgba(255, 255, 255, 0);\n  }\n\n  15%, 85% {\n    background: #fbffc9;\n    border-color: #f0f3c0;\n  }\n}\n\n@-webkit-keyframes insertionFade {\n  from, to {\n    background: rgba(255, 255, 255, 0);\n    border-color: rgba(255, 255, 255, 0);\n  }\n\n  15%, 85% {\n    background: #fbffc9;\n    border-color: #f0f3c0;\n  }\n}\n\n@keyframes insertionFade {\n  from, to {\n    background: rgba(255, 255, 255, 0);\n    border-color: rgba(255, 255, 255, 0);\n  }\n\n  15%, 85% {\n    background: #fbffc9;\n    border-color: #f0f3c0;\n  }\n}\n\ndiv.CodeMirror-lint-tooltip {\n  background-color: white;\n  border: 0;\n  border-radius: 2px;\n  color: #141823;\n  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.45);\n  font-family:\n    system,\n    -apple-system,\n    'San Francisco',\n    '.SFNSDisplay-Regular',\n    'Segoe UI',\n    Segoe,\n    'Segoe WP',\n    'Helvetica Neue',\n    helvetica,\n    'Lucida Grande',\n    arial,\n    sans-serif;\n  font-size: 13px;\n  line-height: 16px;\n  opacity: 0;\n  padding: 6px 10px;\n  -webkit-transition: opacity 0.15s;\n     -moz-transition: opacity 0.15s;\n      -ms-transition: opacity 0.15s;\n       -o-transition: opacity 0.15s;\n          transition: opacity 0.15s;\n}\n\ndiv.CodeMirror-lint-message-error, div.CodeMirror-lint-message-warning {\n  padding-left: 23px;\n}\n\n/* COLORS */\n\n.graphiql-container .CodeMirror-foldmarker {\n  border-radius: 4px;\n  background: #08f;\n  background: -webkit-linear-gradient(#43A8FF, #0F83E8);\n  background:    -moz-linear-gradient(#43A8FF, #0F83E8);\n  background:     -ms-linear-gradient(#43A8FF, #0F83E8);\n  background:         linear-gradient(#43A8FF, #0F83E8);\n  box-shadow:\n    0 1px 1px rgba(0, 0, 0, 0.2),\n    inset 0 0 0 1px rgba(0, 0, 0, 0.1);\n  color: white;\n  font-family: arial;\n  font-size: 12px;\n  line-height: 0;\n  margin: 0 3px;\n  padding: 0px 4px 1px;\n  text-shadow: 0 -1px rgba(0, 0, 0, 0.1);\n}\n\n.graphiql-container div.CodeMirror span.CodeMirror-matchingbracket {\n  color: #555;\n  text-decoration: underline;\n}\n\n.graphiql-container div.CodeMirror span.CodeMirror-nonmatchingbracket {\n  color: #f00;\n}\n\n/* Comment */\n.cm-comment {\n  color: #999;\n}\n\n/* Punctuation */\n.cm-punctuation {\n  color: #555;\n}\n\n/* Keyword */\n.cm-keyword {\n  color: #B11A04;\n}\n\n/* OperationName, FragmentName */\n.cm-def {\n  color: #D2054E;\n}\n\n/* FieldName */\n.cm-property {\n  color: #1F61A0;\n}\n\n/* FieldAlias */\n.cm-qualifier {\n  color: #1C92A9;\n}\n\n/* ArgumentName and ObjectFieldName */\n.cm-attribute {\n  color: #8B2BB9;\n}\n\n/* Number */\n.cm-number {\n  color: #2882F9;\n}\n\n/* String */\n.cm-string {\n  color: #D64292;\n}\n\n/* Boolean */\n.cm-builtin {\n  color: #D47509;\n}\n\n/* EnumValue */\n.cm-string-2 {\n  color: #0B7FC7;\n}\n\n/* Variable */\n.cm-variable {\n  color: #397D13;\n}\n\n/* Directive */\n.cm-meta {\n  color: #B33086;\n}\n\n/* Type */\n.cm-atom {\n  color: #CA9800;\n}\n/* BASICS */\n\n.CodeMirror {\n  /* Set height, width, borders, and global font properties here */\n  font-family: monospace;\n  height: 300px;\n  color: black;\n}\n\n/* PADDING */\n\n.CodeMirror-lines {\n  padding: 4px 0; /* Vertical padding around content */\n}\n.CodeMirror pre {\n  padding: 0 4px; /* Horizontal padding of content */\n}\n\n.CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {\n  background-color: white; /* The little square between H and V scrollbars */\n}\n\n/* GUTTER */\n\n.CodeMirror-gutters {\n  border-right: 1px solid #ddd;\n  background-color: #f7f7f7;\n  white-space: nowrap;\n}\n.CodeMirror-linenumbers {}\n.CodeMirror-linenumber {\n  padding: 0 3px 0 5px;\n  min-width: 20px;\n  text-align: right;\n  color: #999;\n  white-space: nowrap;\n}\n\n.CodeMirror-guttermarker { color: black; }\n.CodeMirror-guttermarker-subtle { color: #999; }\n\n/* CURSOR */\n\n.CodeMirror div.CodeMirror-cursor {\n  border-left: 1px solid black;\n}\n/* Shown when moving in bi-directional text */\n.CodeMirror div.CodeMirror-secondarycursor {\n  border-left: 1px solid silver;\n}\n.CodeMirror.cm-fat-cursor div.CodeMirror-cursor {\n  width: auto;\n  border: 0;\n  background: #7e7;\n}\n.CodeMirror.cm-fat-cursor div.CodeMirror-cursors {\n  z-index: 1;\n}\n\n.cm-animate-fat-cursor {\n  width: auto;\n  border: 0;\n  -webkit-animation: blink 1.06s steps(1) infinite;\n  -moz-animation: blink 1.06s steps(1) infinite;\n  -ms-animation: blink 1.06s steps(1) infinite;\n  animation: blink 1.06s steps(1) infinite;\n}\n@-moz-keyframes blink {\n  0% { background: #7e7; }\n  50% { background: none; }\n  100% { background: #7e7; }\n}\n@-webkit-keyframes blink {\n  0% { background: #7e7; }\n  50% { background: none; }\n  100% { background: #7e7; }\n}\n@keyframes blink {\n  0% { background: #7e7; }\n  50% { background: none; }\n  100% { background: #7e7; }\n}\n\n/* Can style cursor different in overwrite (non-insert) mode */\ndiv.CodeMirror-overwrite div.CodeMirror-cursor {}\n\n.cm-tab { display: inline-block; text-decoration: inherit; }\n\n.CodeMirror-ruler {\n  border-left: 1px solid #ccc;\n  position: absolute;\n}\n\n/* DEFAULT THEME */\n\n.cm-s-default .cm-keyword {color: #708;}\n.cm-s-default .cm-atom {color: #219;}\n.cm-s-default .cm-number {color: #164;}\n.cm-s-default .cm-def {color: #00f;}\n.cm-s-default .cm-variable,\n.cm-s-default .cm-punctuation,\n.cm-s-default .cm-property,\n.cm-s-default .cm-operator {}\n.cm-s-default .cm-variable-2 {color: #05a;}\n.cm-s-default .cm-variable-3 {color: #085;}\n.cm-s-default .cm-comment {color: #a50;}\n.cm-s-default .cm-string {color: #a11;}\n.cm-s-default .cm-string-2 {color: #f50;}\n.cm-s-default .cm-meta {color: #555;}\n.cm-s-default .cm-qualifier {color: #555;}\n.cm-s-default .cm-builtin {color: #30a;}\n.cm-s-default .cm-bracket {color: #997;}\n.cm-s-default .cm-tag {color: #170;}\n.cm-s-default .cm-attribute {color: #00c;}\n.cm-s-default .cm-header {color: blue;}\n.cm-s-default .cm-quote {color: #090;}\n.cm-s-default .cm-hr {color: #999;}\n.cm-s-default .cm-link {color: #00c;}\n\n.cm-negative {color: #d44;}\n.cm-positive {color: #292;}\n.cm-header, .cm-strong {font-weight: bold;}\n.cm-em {font-style: italic;}\n.cm-link {text-decoration: underline;}\n.cm-strikethrough {text-decoration: line-through;}\n\n.cm-s-default .cm-error {color: #f00;}\n.cm-invalidchar {color: #f00;}\n\n.CodeMirror-composing { border-bottom: 2px solid; }\n\n/* Default styles for common addons */\n\ndiv.CodeMirror span.CodeMirror-matchingbracket {color: #0f0;}\ndiv.CodeMirror span.CodeMirror-nonmatchingbracket {color: #f22;}\n.CodeMirror-matchingtag { background: rgba(255, 150, 0, .3); }\n.CodeMirror-activeline-background {background: #e8f2ff;}\n\n/* STOP */\n\n/* The rest of this file contains styles related to the mechanics of\n   the editor. You probably shouldn't touch them. */\n\n.CodeMirror {\n  position: relative;\n  overflow: hidden;\n  background: white;\n}\n\n.CodeMirror-scroll {\n  overflow: scroll !important; /* Things will break if this is overridden */\n  /* 30px is the magic margin used to hide the element's real scrollbars */\n  /* See overflow: hidden in .CodeMirror */\n  margin-bottom: -30px; margin-right: -30px;\n  padding-bottom: 30px;\n  height: 100%;\n  outline: none; /* Prevent dragging from highlighting the element */\n  position: relative;\n}\n.CodeMirror-sizer {\n  position: relative;\n  border-right: 30px solid transparent;\n}\n\n/* The fake, visible scrollbars. Used to force redraw during scrolling\n   before actual scrolling happens, thus preventing shaking and\n   flickering artifacts. */\n.CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {\n  position: absolute;\n  z-index: 6;\n  display: none;\n}\n.CodeMirror-vscrollbar {\n  right: 0; top: 0;\n  overflow-x: hidden;\n  overflow-y: scroll;\n}\n.CodeMirror-hscrollbar {\n  bottom: 0; left: 0;\n  overflow-y: hidden;\n  overflow-x: scroll;\n}\n.CodeMirror-scrollbar-filler {\n  right: 0; bottom: 0;\n}\n.CodeMirror-gutter-filler {\n  left: 0; bottom: 0;\n}\n\n.CodeMirror-gutters {\n  position: absolute; left: 0; top: 0;\n  min-height: 100%;\n  z-index: 3;\n}\n.CodeMirror-gutter {\n  white-space: normal;\n  height: 100%;\n  display: inline-block;\n  vertical-align: top;\n  margin-bottom: -30px;\n  /* Hack to make IE7 behave */\n  *zoom:1;\n  *display:inline;\n}\n.CodeMirror-gutter-wrapper {\n  position: absolute;\n  z-index: 4;\n  background: none !important;\n  border: none !important;\n}\n.CodeMirror-gutter-background {\n  position: absolute;\n  top: 0; bottom: 0;\n  z-index: 4;\n}\n.CodeMirror-gutter-elt {\n  position: absolute;\n  cursor: default;\n  z-index: 4;\n}\n.CodeMirror-gutter-wrapper {\n  -webkit-user-select: none;\n  -moz-user-select: none;\n  -ms-user-select: none;\n  user-select: none;\n}\n\n.CodeMirror-lines {\n  cursor: text;\n  min-height: 1px; /* prevents collapsing before first draw */\n}\n.CodeMirror pre {\n  /* Reset some styles that the rest of the page might have set */\n  -moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0;\n  border-width: 0;\n  background: transparent;\n  font-family: inherit;\n  font-size: inherit;\n  margin: 0;\n  white-space: pre;\n  word-wrap: normal;\n  line-height: inherit;\n  color: inherit;\n  z-index: 2;\n  position: relative;\n  overflow: visible;\n  -webkit-tap-highlight-color: transparent;\n  -webkit-font-variant-ligatures: none;\n  font-variant-ligatures: none;\n}\n.CodeMirror-wrap pre {\n  word-wrap: break-word;\n  white-space: pre-wrap;\n  word-break: normal;\n}\n\n.CodeMirror-linebackground {\n  position: absolute;\n  left: 0; right: 0; top: 0; bottom: 0;\n  z-index: 0;\n}\n\n.CodeMirror-linewidget {\n  position: relative;\n  z-index: 2;\n  overflow: auto;\n}\n\n.CodeMirror-widget {}\n\n.CodeMirror-code {\n  outline: none;\n}\n\n/* Force content-box sizing for the elements where we expect it */\n.CodeMirror-scroll,\n.CodeMirror-sizer,\n.CodeMirror-gutter,\n.CodeMirror-gutters,\n.CodeMirror-linenumber {\n  -moz-box-sizing: content-box;\n  box-sizing: content-box;\n}\n\n.CodeMirror-measure {\n  position: absolute;\n  width: 100%;\n  height: 0;\n  overflow: hidden;\n  visibility: hidden;\n}\n\n.CodeMirror-cursor { position: absolute; }\n.CodeMirror-measure pre { position: static; }\n\ndiv.CodeMirror-cursors {\n  visibility: hidden;\n  position: relative;\n  z-index: 3;\n}\ndiv.CodeMirror-dragcursors {\n  visibility: visible;\n}\n\n.CodeMirror-focused div.CodeMirror-cursors {\n  visibility: visible;\n}\n\n.CodeMirror-selected { background: #d9d9d9; }\n.CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; }\n.CodeMirror-crosshair { cursor: crosshair; }\n.CodeMirror-line::selection, .CodeMirror-line > span::selection, .CodeMirror-line > span > span::selection { background: #d7d4f0; }\n.CodeMirror-line::-moz-selection, .CodeMirror-line > span::-moz-selection, .CodeMirror-line > span > span::-moz-selection { background: #d7d4f0; }\n\n.cm-searching {\n  background: #ffa;\n  background: rgba(255, 255, 0, .4);\n}\n\n/* IE7 hack to prevent it from returning funny offsetTops on the spans */\n.CodeMirror span { *vertical-align: text-bottom; }\n\n/* Used to force a border model for a node */\n.cm-force-border { padding-right: .1px; }\n\n@media print {\n  /* Hide the cursor when printing */\n  .CodeMirror div.CodeMirror-cursors {\n    visibility: hidden;\n  }\n}\n\n/* See issue #2901 */\n.cm-tab-wrap-hack:after { content: ''; }\n\n/* Help users use markselection to safely style text background */\nspan.CodeMirror-selectedtext { background: none; }\n\n.CodeMirror-dialog {\n  position: absolute;\n  left: 0; right: 0;\n  background: inherit;\n  z-index: 15;\n  padding: .1em .8em;\n  overflow: hidden;\n  color: inherit;\n}\n\n.CodeMirror-dialog-top {\n  border-bottom: 1px solid #eee;\n  top: 0;\n}\n\n.CodeMirror-dialog-bottom {\n  border-top: 1px solid #eee;\n  bottom: 0;\n}\n\n.CodeMirror-dialog input {\n  border: 1px solid #d3d6db;\n  outline: none;\n  background: transparent;\n  width: 20em;\n  color: inherit;\n  font-family: monospace;\n}\n\n.CodeMirror-dialog button {\n  font-size: 70%;\n}\n.graphiql-container .doc-explorer {\n  background: white;\n}\n\n.graphiql-container .doc-explorer-title-bar {\n  cursor: default;\n  display: -webkit-flex;\n  display: -ms-flexbox;\n  display: flex;\n  height: 34px;\n  line-height: 14px;\n  padding: 8px 8px 5px;\n  position: relative;\n  -webkit-user-select: none;\n          user-select: none;\n}\n\n.graphiql-container .doc-explorer-title {\n  padding: 10px 0 10px 10px;\n  font-weight: bold;\n  text-align: center;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  overflow-x: hidden;\n  -webkit-flex: 1;\n      -ms-flex: 1;\n          flex: 1;\n}\n\n.graphiql-container .doc-explorer-back {\n  color: #3B5998;\n  cursor: pointer;\n  margin: -7px 0 -6px -8px;\n  overflow-x: hidden;\n  padding: 17px 12px 16px 16px;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n}\n\n.graphiql-container .doc-explorer-back:before {\n  border-left: 2px solid #3B5998;\n  border-top: 2px solid #3B5998;\n  content: '';\n  display: inline-block;\n  height: 9px;\n  margin: 0 3px -1px 0;\n  position: relative;\n  width: 9px;\n  -webkit-transform: rotate(-45deg);\n      -ms-transform: rotate(-45deg);\n          transform: rotate(-45deg);\n}\n\n.graphiql-container .doc-explorer-rhs {\n  position: relative;\n}\n\n.graphiql-container .doc-explorer-contents {\n  background-color: #ffffff;\n  border-top: 1px solid #d6d6d6;\n  bottom: 0;\n  left: 0;\n  min-width: 300px;\n  overflow-y: auto;\n  padding: 20px 15px;\n  position: absolute;\n  right: 0;\n  top: 47px;\n}\n\n.graphiql-container .doc-type-description p:first-child ,\n.graphiql-container .doc-type-description blockquote:first-child {\n  margin-top: 0;\n}\n\n.graphiql-container .doc-explorer-contents a {\n  cursor: pointer;\n  text-decoration: none;\n}\n\n.graphiql-container .doc-explorer-contents a:hover {\n  text-decoration: underline;\n}\n\n.graphiql-container .doc-value-description {\n  padding: 4px 0 8px 12px;\n}\n\n.graphiql-container .doc-category {\n  margin: 20px 0;\n}\n\n.graphiql-container .doc-category-title {\n  border-bottom: 1px solid #e0e0e0;\n  color: #777;\n  cursor: default;\n  font-size: 14px;\n  font-variant: small-caps;\n  font-weight: bold;\n  letter-spacing: 1px;\n  margin: 0 -15px 10px 0;\n  padding: 10px 0;\n  -webkit-user-select: none;\n      -ms-user-select: none;\n          user-select: none;\n}\n\n.graphiql-container .doc-category-item {\n  margin: 12px 0;\n  color: #555;\n}\n\n.graphiql-container .keyword {\n  color: #B11A04;\n}\n\n.graphiql-container .type-name {\n  color: #CA9800;\n}\n\n.graphiql-container .field-name {\n  color: #1F61A0;\n}\n\n.graphiql-container .value-name {\n  color: #0B7FC7;\n}\n\n.graphiql-container .arg-name {\n  color: #8B2BB9;\n}\n\n.graphiql-container .arg:after {\n  content: ', ';\n}\n\n.graphiql-container .arg:last-child:after {\n  content: '';\n}\n\n.graphiql-container .doc-alert-text {\n  color: #F00F00;\n  font-family: 'Consolas', 'Inconsolata', 'Droid Sans Mono', 'Monaco', monospace;\n  font-size: 13px;\n}\n\n.graphiql-container .search-box-outer {\n  border: 1px solid #d3d6db;\n  box-sizing: border-box;\n  display: inline-block;\n  font-size: 12px;\n  height: 24px;\n  margin-bottom: 12px;\n  padding: 3px 8px 5px;\n  vertical-align: middle;\n  width: 100%;\n}\n\n.graphiql-container .search-box-input {\n  border: 0;\n  font-size: 12px;\n  margin: 0;\n  outline: 0;\n  padding: 0;\n  width: 100%;\n}\n.CodeMirror-foldmarker {\n  color: blue;\n  text-shadow: #b9f 1px 1px 2px, #b9f -1px -1px 2px, #b9f 1px -1px 2px, #b9f -1px 1px 2px;\n  font-family: arial;\n  line-height: .3;\n  cursor: pointer;\n}\n.CodeMirror-foldgutter {\n  width: .7em;\n}\n.CodeMirror-foldgutter-open,\n.CodeMirror-foldgutter-folded {\n  cursor: pointer;\n}\n.CodeMirror-foldgutter-open:after {\n  content: \"\\25BE\";\n}\n.CodeMirror-foldgutter-folded:after {\n  content: \"\\25B8\";\n}\n/* The lint marker gutter */\n.CodeMirror-lint-markers {\n  width: 16px;\n}\n\n.CodeMirror-lint-tooltip {\n  background-color: infobackground;\n  border: 1px solid black;\n  border-radius: 4px 4px 4px 4px;\n  color: infotext;\n  font-family: monospace;\n  font-size: 10pt;\n  overflow: hidden;\n  padding: 2px 5px;\n  position: fixed;\n  white-space: pre;\n  white-space: pre-wrap;\n  z-index: 100;\n  max-width: 600px;\n  opacity: 0;\n  transition: opacity .4s;\n  -moz-transition: opacity .4s;\n  -webkit-transition: opacity .4s;\n  -o-transition: opacity .4s;\n  -ms-transition: opacity .4s;\n}\n\n.CodeMirror-lint-mark-error, .CodeMirror-lint-mark-warning {\n  background-position: left bottom;\n  background-repeat: repeat-x;\n}\n\n.CodeMirror-lint-mark-error {\n  background-image:\n  url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAADCAYAAAC09K7GAAAAAXNSR0IArs4c6QAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB9sJDw4cOCW1/KIAAAAZdEVYdENvbW1lbnQAQ3JlYXRlZCB3aXRoIEdJTVBXgQ4XAAAAHElEQVQI12NggIL/DAz/GdA5/xkY/qPKMDAwAADLZwf5rvm+LQAAAABJRU5ErkJggg==\")\n  ;\n}\n\n.CodeMirror-lint-mark-warning {\n  background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAADCAYAAAC09K7GAAAAAXNSR0IArs4c6QAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB9sJFhQXEbhTg7YAAAAZdEVYdENvbW1lbnQAQ3JlYXRlZCB3aXRoIEdJTVBXgQ4XAAAAMklEQVQI12NkgIIvJ3QXMjAwdDN+OaEbysDA4MPAwNDNwMCwiOHLCd1zX07o6kBVGQEAKBANtobskNMAAAAASUVORK5CYII=\");\n}\n\n.CodeMirror-lint-marker-error, .CodeMirror-lint-marker-warning {\n  background-position: center center;\n  background-repeat: no-repeat;\n  cursor: pointer;\n  display: inline-block;\n  height: 16px;\n  width: 16px;\n  vertical-align: middle;\n  position: relative;\n}\n\n.CodeMirror-lint-message-error, .CodeMirror-lint-message-warning {\n  padding-left: 18px;\n  background-position: top left;\n  background-repeat: no-repeat;\n}\n\n.CodeMirror-lint-marker-error, .CodeMirror-lint-message-error {\n  background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAAHlBMVEW7AAC7AACxAAC7AAC7AAAAAAC4AAC5AAD///+7AAAUdclpAAAABnRSTlMXnORSiwCK0ZKSAAAATUlEQVR42mWPOQ7AQAgDuQLx/z8csYRmPRIFIwRGnosRrpamvkKi0FTIiMASR3hhKW+hAN6/tIWhu9PDWiTGNEkTtIOucA5Oyr9ckPgAWm0GPBog6v4AAAAASUVORK5CYII=\");\n}\n\n.CodeMirror-lint-marker-warning, .CodeMirror-lint-message-warning {\n  background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAANlBMVEX/uwDvrwD/uwD/uwD/uwD/uwD/uwD/uwD/uwD6twD/uwAAAADurwD2tQD7uAD+ugAAAAD/uwDhmeTRAAAADHRSTlMJ8mN1EYcbmiixgACm7WbuAAAAVklEQVR42n3PUQqAIBBFUU1LLc3u/jdbOJoW1P08DA9Gba8+YWJ6gNJoNYIBzAA2chBth5kLmG9YUoG0NHAUwFXwO9LuBQL1giCQb8gC9Oro2vp5rncCIY8L8uEx5ZkAAAAASUVORK5CYII=\");\n}\n\n.CodeMirror-lint-marker-multiple {\n  background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAcAAAAHCAMAAADzjKfhAAAACVBMVEUAAAAAAAC/v7914kyHAAAAAXRSTlMAQObYZgAAACNJREFUeNo1ioEJAAAIwmz/H90iFFSGJgFMe3gaLZ0od+9/AQZ0ADosbYraAAAAAElFTkSuQmCC\");\n  background-repeat: no-repeat;\n  background-position: right bottom;\n  width: 100%; height: 100%;\n}\n.graphiql-container .spinner-container {\n  position: absolute;\n  top: 50%;\n  height: 36px;\n  width: 36px;\n  left: 50%;\n  transform: translate(-50%, -50%);\n  z-index: 10;\n}\n\n.graphiql-container .spinner {\n  vertical-align: middle;\n  display: inline-block;\n  height: 24px;\n  width: 24px;\n  position: absolute;\n  -webkit-animation: rotation .6s infinite linear;\n  -moz-animation: rotation .6s infinite linear;\n  -o-animation: rotation .6s infinite linear;\n  animation: rotation .6s infinite linear;\n  border-left: 6px solid rgba(150, 150, 150, .15);\n  border-right: 6px solid rgba(150, 150, 150, .15);\n  border-bottom: 6px solid rgba(150, 150, 150, .15);\n  border-top: 6px solid rgba(150, 150, 150, .8);\n  border-radius: 100%;\n}\n\n@-webkit-keyframes rotation {\n  from { -webkit-transform: rotate(0deg); }\n  to { -webkit-transform: rotate(359deg); }\n}\n\n@-moz-keyframes rotation {\n  from { -moz-transform: rotate(0deg); }\n  to { -moz-transform: rotate(359deg); }\n}\n\n@-o-keyframes rotation {\n  from { -o-transform: rotate(0deg); }\n  to { -o-transform: rotate(359deg); }\n}\n\n@keyframes rotation {\n  from { transform: rotate(0deg); }\n  to { transform: rotate(359deg); }\n}\n.CodeMirror-hints {\n  background: white;\n  -webkit-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.45);\n     -moz-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.45);\n          box-shadow: 0 1px 3px rgba(0, 0, 0, 0.45);\n  font-family: 'Consolas', 'Inconsolata', 'Droid Sans Mono', 'Monaco', monospace;\n  font-size: 13px;\n  list-style: none;\n  margin: 0;\n  margin-left: -6px;\n  max-height: 14.5em;\n  overflow-y: auto;\n  overflow: hidden;\n  padding: 0;\n  position: absolute;\n  z-index: 10;\n}\n\n.CodeMirror-hints-wrapper {\n  background: white;\n  -webkit-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.45);\n     -moz-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.45);\n          box-shadow: 0 1px 3px rgba(0, 0, 0, 0.45);\n  margin-left: -6px;\n  position: absolute;\n  z-index: 10;\n}\n\n.CodeMirror-hints-wrapper .CodeMirror-hints {\n  -webkit-box-shadow: none;\n   -moz-box-shadow: none;\n        box-shadow: none;\n  position: relative;\n  margin-left: 0;\n  z-index: 0;\n}\n\n.CodeMirror-hint {\n  border-top: solid 1px #f7f7f7;\n  color: #141823;\n  cursor: pointer;\n  margin: 0;\n  max-width: 300px;\n  overflow: hidden;\n  padding: 2px 6px;\n  white-space: pre;\n}\n\nli.CodeMirror-hint-active {\n  background-color: #08f;\n  border-top-color: white;\n  color: white;\n}\n\n.CodeMirror-hint-information {\n  border-top: solid 1px #c0c0c0;\n  max-width: 300px;\n  padding: 4px 6px;\n  position: relative;\n  z-index: 1;\n}\n\n.CodeMirror-hint-information:first-child {\n  border-bottom: solid 1px #c0c0c0;\n  border-top: none;\n  margin-bottom: -1px;\n}\n", ""]);
+
+	// exports
+
+
+/***/ },
+/* 312 */
+/***/ function(module, exports) {
+
+	/*
+		MIT License http://www.opensource.org/licenses/mit-license.php
+		Author Tobias Koppers @sokra
+	*/
+	// css base code, injected by the css-loader
+	module.exports = function() {
+		var list = [];
+
+		// return the list of modules as css string
+		list.toString = function toString() {
+			var result = [];
+			for(var i = 0; i < this.length; i++) {
+				var item = this[i];
+				if(item[2]) {
+					result.push("@media " + item[2] + "{" + item[1] + "}");
+				} else {
+					result.push(item[1]);
+				}
+			}
+			return result.join("");
+		};
+
+		// import a list of modules into the list
+		list.i = function(modules, mediaQuery) {
+			if(typeof modules === "string")
+				modules = [[null, modules, ""]];
+			var alreadyImportedModules = {};
+			for(var i = 0; i < this.length; i++) {
+				var id = this[i][0];
+				if(typeof id === "number")
+					alreadyImportedModules[id] = true;
+			}
+			for(i = 0; i < modules.length; i++) {
+				var item = modules[i];
+				// skip already imported module
+				// this implementation is not 100% perfect for weird media query combinations
+				//  when a module is imported multiple times with different media queries.
+				//  I hope this will never occur (Hey this way we have smaller bundles)
+				if(typeof item[0] !== "number" || !alreadyImportedModules[item[0]]) {
+					if(mediaQuery && !item[2]) {
+						item[2] = mediaQuery;
+					} else if(mediaQuery) {
+						item[2] = "(" + item[2] + ") and (" + mediaQuery + ")";
+					}
+					list.push(item);
+				}
+			}
+		};
+		return list;
+	};
+
+
+/***/ },
+/* 313 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/*
+		MIT License http://www.opensource.org/licenses/mit-license.php
+		Author Tobias Koppers @sokra
+	*/
+	var stylesInDom = {},
+		memoize = function(fn) {
+			var memo;
+			return function () {
+				if (typeof memo === "undefined") memo = fn.apply(this, arguments);
+				return memo;
+			};
+		},
+		isOldIE = memoize(function() {
+			return /msie [6-9]\b/.test(window.navigator.userAgent.toLowerCase());
+		}),
+		getHeadElement = memoize(function () {
+			return document.head || document.getElementsByTagName("head")[0];
+		}),
+		singletonElement = null,
+		singletonCounter = 0,
+		styleElementsInsertedAtTop = [];
+
+	module.exports = function(list, options) {
+		if(false) {
+			if(typeof document !== "object") throw new Error("The style-loader cannot be used in a non-browser environment");
+		}
+
+		options = options || {};
+		// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
+		// tags it will allow on a page
+		if (typeof options.singleton === "undefined") options.singleton = isOldIE();
+
+		// By default, add <style> tags to the bottom of <head>.
+		if (typeof options.insertAt === "undefined") options.insertAt = "bottom";
+
+		var styles = listToStyles(list);
+		addStylesToDom(styles, options);
+
+		return function update(newList) {
+			var mayRemove = [];
+			for(var i = 0; i < styles.length; i++) {
+				var item = styles[i];
+				var domStyle = stylesInDom[item.id];
+				domStyle.refs--;
+				mayRemove.push(domStyle);
+			}
+			if(newList) {
+				var newStyles = listToStyles(newList);
+				addStylesToDom(newStyles, options);
+			}
+			for(var i = 0; i < mayRemove.length; i++) {
+				var domStyle = mayRemove[i];
+				if(domStyle.refs === 0) {
+					for(var j = 0; j < domStyle.parts.length; j++)
+						domStyle.parts[j]();
+					delete stylesInDom[domStyle.id];
+				}
+			}
+		};
+	}
+
+	function addStylesToDom(styles, options) {
+		for(var i = 0; i < styles.length; i++) {
+			var item = styles[i];
+			var domStyle = stylesInDom[item.id];
+			if(domStyle) {
+				domStyle.refs++;
+				for(var j = 0; j < domStyle.parts.length; j++) {
+					domStyle.parts[j](item.parts[j]);
+				}
+				for(; j < item.parts.length; j++) {
+					domStyle.parts.push(addStyle(item.parts[j], options));
+				}
+			} else {
+				var parts = [];
+				for(var j = 0; j < item.parts.length; j++) {
+					parts.push(addStyle(item.parts[j], options));
+				}
+				stylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};
+			}
+		}
+	}
+
+	function listToStyles(list) {
+		var styles = [];
+		var newStyles = {};
+		for(var i = 0; i < list.length; i++) {
+			var item = list[i];
+			var id = item[0];
+			var css = item[1];
+			var media = item[2];
+			var sourceMap = item[3];
+			var part = {css: css, media: media, sourceMap: sourceMap};
+			if(!newStyles[id])
+				styles.push(newStyles[id] = {id: id, parts: [part]});
+			else
+				newStyles[id].parts.push(part);
+		}
+		return styles;
+	}
+
+	function insertStyleElement(options, styleElement) {
+		var head = getHeadElement();
+		var lastStyleElementInsertedAtTop = styleElementsInsertedAtTop[styleElementsInsertedAtTop.length - 1];
+		if (options.insertAt === "top") {
+			if(!lastStyleElementInsertedAtTop) {
+				head.insertBefore(styleElement, head.firstChild);
+			} else if(lastStyleElementInsertedAtTop.nextSibling) {
+				head.insertBefore(styleElement, lastStyleElementInsertedAtTop.nextSibling);
+			} else {
+				head.appendChild(styleElement);
+			}
+			styleElementsInsertedAtTop.push(styleElement);
+		} else if (options.insertAt === "bottom") {
+			head.appendChild(styleElement);
+		} else {
+			throw new Error("Invalid value for parameter 'insertAt'. Must be 'top' or 'bottom'.");
+		}
+	}
+
+	function removeStyleElement(styleElement) {
+		styleElement.parentNode.removeChild(styleElement);
+		var idx = styleElementsInsertedAtTop.indexOf(styleElement);
+		if(idx >= 0) {
+			styleElementsInsertedAtTop.splice(idx, 1);
+		}
+	}
+
+	function createStyleElement(options) {
+		var styleElement = document.createElement("style");
+		styleElement.type = "text/css";
+		insertStyleElement(options, styleElement);
+		return styleElement;
+	}
+
+	function createLinkElement(options) {
+		var linkElement = document.createElement("link");
+		linkElement.rel = "stylesheet";
+		insertStyleElement(options, linkElement);
+		return linkElement;
+	}
+
+	function addStyle(obj, options) {
+		var styleElement, update, remove;
+
+		if (options.singleton) {
+			var styleIndex = singletonCounter++;
+			styleElement = singletonElement || (singletonElement = createStyleElement(options));
+			update = applyToSingletonTag.bind(null, styleElement, styleIndex, false);
+			remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true);
+		} else if(obj.sourceMap &&
+			typeof URL === "function" &&
+			typeof URL.createObjectURL === "function" &&
+			typeof URL.revokeObjectURL === "function" &&
+			typeof Blob === "function" &&
+			typeof btoa === "function") {
+			styleElement = createLinkElement(options);
+			update = updateLink.bind(null, styleElement);
+			remove = function() {
+				removeStyleElement(styleElement);
+				if(styleElement.href)
+					URL.revokeObjectURL(styleElement.href);
+			};
+		} else {
+			styleElement = createStyleElement(options);
+			update = applyToTag.bind(null, styleElement);
+			remove = function() {
+				removeStyleElement(styleElement);
+			};
+		}
+
+		update(obj);
+
+		return function updateStyle(newObj) {
+			if(newObj) {
+				if(newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap)
+					return;
+				update(obj = newObj);
+			} else {
+				remove();
+			}
+		};
+	}
+
+	var replaceText = (function () {
+		var textStore = [];
+
+		return function (index, replacement) {
+			textStore[index] = replacement;
+			return textStore.filter(Boolean).join('\n');
+		};
+	})();
+
+	function applyToSingletonTag(styleElement, index, remove, obj) {
+		var css = remove ? "" : obj.css;
+
+		if (styleElement.styleSheet) {
+			styleElement.styleSheet.cssText = replaceText(index, css);
+		} else {
+			var cssNode = document.createTextNode(css);
+			var childNodes = styleElement.childNodes;
+			if (childNodes[index]) styleElement.removeChild(childNodes[index]);
+			if (childNodes.length) {
+				styleElement.insertBefore(cssNode, childNodes[index]);
+			} else {
+				styleElement.appendChild(cssNode);
+			}
+		}
+	}
+
+	function applyToTag(styleElement, obj) {
+		var css = obj.css;
+		var media = obj.media;
+
+		if(media) {
+			styleElement.setAttribute("media", media)
+		}
+
+		if(styleElement.styleSheet) {
+			styleElement.styleSheet.cssText = css;
+		} else {
+			while(styleElement.firstChild) {
+				styleElement.removeChild(styleElement.firstChild);
+			}
+			styleElement.appendChild(document.createTextNode(css));
+		}
+	}
+
+	function updateLink(linkElement, obj) {
+		var css = obj.css;
+		var sourceMap = obj.sourceMap;
+
+		if(sourceMap) {
+			// http://stackoverflow.com/a/26603875
+			css += "\n/*# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + " */";
+		}
+
+		var blob = new Blob([css], { type: "text/css" });
+
+		var oldSrc = linkElement.href;
+
+		linkElement.href = URL.createObjectURL(blob);
+
+		if(oldSrc)
+			URL.revokeObjectURL(oldSrc);
+	}
+
+
+/***/ }
+/******/ ]);
\ No newline at end of file
diff --git a/phpunit.xml b/phpunit.xml
index 3c874054f..de3b0b486 100644
--- a/phpunit.xml
+++ b/phpunit.xml
@@ -8,6 +8,7 @@
     processIsolation="false"
     stopOnFailure="false"
     syntaxCheck="false"
+    colors="true">
     >
     <testsuites>
         <testsuite>
diff --git a/src/FieldCreator.php b/src/FieldCreator.php
index c0aaa6f87..0d7c5f3f0 100644
--- a/src/FieldCreator.php
+++ b/src/FieldCreator.php
@@ -82,7 +82,7 @@ public function getAttributes()
             $attributes['type'] = $type;
         }
 
-        $resolver = $this->getResolver();
+        $resolver = $this->getResolver();        
         if (isset($resolver)) {
             $attributes['resolve'] = $resolver;
         }
diff --git a/src/Manager.php b/src/Manager.php
index 32c49b836..8855bf207 100644
--- a/src/Manager.php
+++ b/src/Manager.php
@@ -3,8 +3,6 @@
 namespace SilverStripe\GraphQL;
 
 use Doctrine\Instantiator\Exception\InvalidArgumentException;
-use GraphQL\Executor\ExecutionResult;
-use GraphQL\Language\SourceLocation;
 use GraphQL\Schema;
 use GraphQL\GraphQL;
 use SilverStripe\Core\Injector\Injector;
@@ -12,15 +10,10 @@
 use GraphQL\Type\Definition\ObjectType;
 use GraphQL\Error;
 use GraphQL\Type\Definition\Type;
-use SilverStripe\ORM\ValidationException;
 use SilverStripe\Security\Member;
+use SilverStripe\GraphQL\Scaffolding\ScaffoldingProvider;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
 
-/**
- * Manager is the master container for a graphql endpoint, and contains
- * all queries, mutations, and types.
- *
- * Instantiate with {@see Manager::createFromConfig()} with a config array.
- */
 class Manager
 {
     use Injectable;
@@ -52,12 +45,42 @@ class Manager
 
     /**
      * @param array $config An array with optional 'types' and 'queries' keys
+     *
      * @return Manager
      */
     public static function createFromConfig($config)
     {
         /** @var Manager $manager */
-        $manager = Injector::inst()->create(Manager::class);
+        $manager = Injector::inst()->create(self::class);
+
+        if (isset($config['scaffolding'])) {
+            $scaffolder = GraphQLScaffolder::createFromConfig($config['scaffolding']);
+        } else {
+            $scaffolder = new GraphQLScaffolder();
+        }
+
+        if (isset($config['scaffolding_providers'])) {
+            foreach ($config['scaffolding_providers'] as $provider) {
+                if (!class_exists($provider)) {
+                    throw new InvalidArgumentException(sprintf(
+                        'Scaffolding provider %s does not exist.',
+                        $provider
+                    ));
+                }
+
+                $provider = Injector::inst()->create($provider);
+
+                if (!$provider instanceof ScaffoldingProvider) {
+                    throw new InvalidArgumentException(sprintf(
+                        'All scaffolding providers must implement the %s interface',
+                        ScaffoldingProvider::class
+                    ));
+                }
+                $scaffolder = $provider->provideGraphQLScaffolding($scaffolder);
+            }
+        }
+
+        $scaffolder->addToManager($manager);
 
         // Types (incl. Interfaces and InputTypes)
         if ($config && array_key_exists('types', $config)) {
@@ -65,7 +88,7 @@ public static function createFromConfig($config)
                 $typeCreator = Injector::inst()->create($typeCreatorClass, $manager);
                 if (!($typeCreator instanceof TypeCreator)) {
                     throw new InvalidArgumentException(sprintf(
-                        'The type named "%s" needs to be a class extending ' . TypeCreator::class,
+                        'The type named "%s" needs to be a class extending '.TypeCreator::class,
                         $name
                     ));
                 }
@@ -81,7 +104,7 @@ public static function createFromConfig($config)
                 $queryCreator = Injector::inst()->create($queryCreatorClass, $manager);
                 if (!($queryCreator instanceof QueryCreator)) {
                     throw new InvalidArgumentException(sprintf(
-                        'The type named "%s" needs to be a class extending ' . QueryCreator::class,
+                        'The type named "%s" needs to be a class extending '.QueryCreator::class,
                         $name
                     ));
                 }
@@ -97,7 +120,7 @@ public static function createFromConfig($config)
                 $mutationCreator = Injector::inst()->create($mutationCreatorClass, $manager);
                 if (!($mutationCreator instanceof MutationCreator)) {
                     throw new InvalidArgumentException(sprintf(
-                        'The mutation named "%s" needs to be a class extending ' . MutationCreator::class,
+                        'The mutation named "%s" needs to be a class extending '.MutationCreator::class,
                         $name
                     ));
                 }
@@ -111,8 +134,6 @@ public static function createFromConfig($config)
     }
 
     /**
-     * Build the main Schema instance that represents the final schema for this endpoint
-     *
      * @return Schema
      */
     public function schema()
@@ -136,15 +157,15 @@ public function schema()
     }
 
     /**
-     * Execute an arbitrary operation (mutation / query) on this schema
+     * @param string $query
+     * @param array  $params
+     * @param null   $schema
      *
-     * @param string $query Raw query
-     * @param array $params List of arguments given for this operation
      * @return array
      */
-    public function query($query, $params = [])
+    public function query($query, $params = [], $schema = null)
     {
-        $executionResult = $this->queryAndReturnResult($query, $params);
+        $executionResult = $this->queryAndReturnResult($query, $params, $schema);
 
         if (!empty($executionResult->errors)) {
             return [
@@ -160,12 +181,14 @@ public function query($query, $params = [])
 
     /**
      * @param string $query
-     * @param array $params
-     * @return ExecutionResult
+     * @param array  $params
+     * @param null   $schema
+     *
+     * @return array
      */
-    public function queryAndReturnResult($query, $params = [])
+    public function queryAndReturnResult($query, $params = [], $schema = null)
     {
-        $schema = $this->schema();
+        $schema = $this->schema($schema);
         $context = $this->getContext();
         $result = GraphQL::executeAndReturnResult($schema, $query, null, $context, $params);
 
@@ -173,25 +196,21 @@ public function queryAndReturnResult($query, $params = [])
     }
 
     /**
-     * Register a new type
-     *
-     * @param Type $type
-     * @param string $name An optional identifier for this type (defaults to 'name'
-     * attribute in type definition). Needs to be unique in schema.
+     * @param Type   $type
+     * @param string $name An optional identifier for this type (defaults to 'name' attribute in type definition).
+     *                     Needs to be unique in schema
      */
     public function addType(Type $type, $name = '')
     {
         if (!$name) {
-            $name = (string)$type;
+            $name = (string) $type;
         }
-
         $this->types[$name] = $type;
     }
 
     /**
-     * Return a type definition by name
-     *
      * @param string $name
+     *
      * @return Type
      */
     public function getType($name)
@@ -204,10 +223,8 @@ public function getType($name)
     }
 
     /**
-     * Register a new Query
-     *
-     * @param array $query
-     * @param string $name Identifier for this query (unique in schema)
+     * @param array  $query
+     * @param string $name  Identifier for this query (unique in schema)
      */
     public function addQuery($query, $name)
     {
@@ -215,9 +232,8 @@ public function addQuery($query, $name)
     }
 
     /**
-     * Get a query by name
-     *
      * @param string $name
+     *
      * @return array
      */
     public function getQuery($name)
@@ -226,10 +242,8 @@ public function getQuery($name)
     }
 
     /**
-     * Register a new mutation
-     *
-     * @param array $mutation
-     * @param string $name Identifier for this mutation (unique in schema)
+     * @param array  $mutation
+     * @param string $name     Identifier for this mutation (unique in schema)
      */
     public function addMutation($mutation, $name)
     {
@@ -237,9 +251,8 @@ public function addMutation($mutation, $name)
     }
 
     /**
-     * Get a mutation by name
-     *
      * @param string $name
+     *
      * @return array
      */
     public function getMutation($name)
@@ -250,25 +263,26 @@ public function getMutation($name)
     /**
      * More verbose error display defaults.
      *
-     * @param Error $exception
+     * @param Error $e
+     *
      * @return array
      */
-    public static function formatError(Error $exception)
+    public static function formatError(Error $e)
     {
         $error = [
-            'message' => $exception->getMessage(),
+            'message' => $e->getMessage(),
         ];
 
-        $locations = $exception->getLocations();
+        $locations = $e->getLocations();
         if (!empty($locations)) {
-            $error['locations'] = array_map(function (SourceLocation $loc) {
+            $error['locations'] = array_map(function ($loc) {
                 return $loc->toArray();
             }, $locations);
         }
 
-        $previous = $exception->getPrevious();
-        if ($previous && $previous instanceof ValidationException) {
-            $error['validation'] = $previous->getResult()->getMessages();
+        $previous = $e->getPrevious();
+        if ($previous && $previous instanceof ValidationError) {
+            $error['validation'] = $previous->getValidatorMessages();
         }
 
         return $error;
@@ -297,8 +311,6 @@ public function getMember()
     }
 
     /**
-     * Get global context to pass to $context for all queries
-     *
      * @return array
      */
     protected function getContext()
diff --git a/src/Scaffolding/Creators/DataObjectTypeCreator.php b/src/Scaffolding/Creators/DataObjectTypeCreator.php
new file mode 100644
index 000000000..6f03a83b5
--- /dev/null
+++ b/src/Scaffolding/Creators/DataObjectTypeCreator.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Creators;
+
+use SilverStripe\GraphQL\TypeCreator;
+use SilverStripe\GraphQL\Manager;
+use SilverStripe\ORM\DataObjectInterface;
+use GraphQL\Type\Definition\ResolveInfo;
+
+/**
+ * Creates a GraphQL type for a DataObject
+ * @package SilverStripe\GraphQL\Scaffolding\Creators
+ * @author Uncle Cheese <unclecheese@leftandmain.com>
+ */
+class DataObjectTypeCreator extends TypeCreator
+{
+
+    /**
+     * @var string
+     */
+    protected $typeName;
+
+
+    /**
+     * @var array
+     */
+    protected $fieldsMap;
+
+
+    /**
+     * DataObjectTypeCreator constructor.
+     * @param Manager $manager
+     * @param $typeName
+     * @param $fields
+     */
+    public function __construct(Manager $manager, $typeName, $fields)
+    {
+        $this->typeName = $typeName;
+        $this->fieldsMap = $fields;
+
+        parent::__construct($manager);
+    }
+
+
+    /**
+     * @return array
+     */
+    public function attributes()
+    {
+        return [
+            'name' => $this->typeName
+        ];
+    }
+
+
+    /**
+     * @return array
+     */
+    public function fields()
+    {
+        return $this->fieldsMap;
+    }
+
+
+    /**
+     * @param DataObjectInterface $obj
+     * @param array $args
+     * @param $context
+     * @param ResolveInfo $info
+     * @return mixed
+     */
+    public function resolveField(DataObjectInterface $obj, array $args, $context, ResolveInfo $info)
+    {
+        return $obj->obj($info->fieldName);
+    }
+}
\ No newline at end of file
diff --git a/src/Scaffolding/Creators/MutationOperationCreator.php b/src/Scaffolding/Creators/MutationOperationCreator.php
new file mode 100644
index 000000000..d895f1be5
--- /dev/null
+++ b/src/Scaffolding/Creators/MutationOperationCreator.php
@@ -0,0 +1,26 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Creators;
+
+use SilverStripe\GraphQL\MutationCreator;
+
+/**
+ * Creates a GraphQL mutation field
+ * @package SilverStripe\GraphQL\Scaffolding\Operations
+ */
+class MutationOperationCreator extends MutationCreator
+{
+    use OperationCreatorTrait;
+
+    /**
+     * @return \Closure
+     */
+    public function type()
+    {
+        return function () {
+            return $this->manager->getType($this->typeName);
+        };
+    }
+
+
+}
\ No newline at end of file
diff --git a/src/Scaffolding/Creators/OperationCreatorTrait.php b/src/Scaffolding/Creators/OperationCreatorTrait.php
new file mode 100644
index 000000000..cb94c1160
--- /dev/null
+++ b/src/Scaffolding/Creators/OperationCreatorTrait.php
@@ -0,0 +1,96 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Creators;
+
+use SilverStripe\GraphQL\Scaffolding\ResolverInterface;
+use SilverStripe\GraphQL\Manager;
+
+/**
+ * Injects Operation creator features into mutations and queries, which are different inheritance chains
+ * @package SilverStripe\GraphQL\Scaffolding\Operations
+ */
+trait OperationCreatorTrait
+{
+    /**
+     * @var string
+     */
+    protected $typeName;
+
+    /**
+     * @var \Closure|SilverStripe\GraphQL\ResolverInterface
+     */
+    protected $resolver;
+
+    /**
+     * @var string
+     */
+    protected $operationName;
+
+    /**
+     * @var array
+     */
+    protected $argsMap = [];
+
+    /**
+     * OperationCreatorTrait constructor.
+     * @param Manager $manager
+     * @param $operationName
+     * @param $typeName
+     * @param null $resolver
+     * @param array $argsMap
+     */
+    public function __construct(Manager $manager, $operationName, $typeName, $resolver = null, $argsMap = [])
+    {
+        $this->typeName = $typeName;
+        $this->resolver = $resolver;
+        $this->operationName = $operationName;
+        $this->argsMap = $argsMap;
+
+        parent::__construct($manager);
+    }
+
+    /**
+     * @return array
+     */
+    public function attributes()
+    {
+        return [
+            'name' => $this->operationName
+        ];
+    }
+
+    /**
+     * @return array
+     */
+    public function args()
+    {
+        return $this->argsMap;
+    }
+
+    /**
+     * Overload the getResolver() method to be aware of the ResolverInterface option
+     * @return mixed
+     */
+    protected function getResolver()
+    {
+        $resolver = $this->resolver;
+
+        return function () use ($resolver) {
+            $args = func_get_args();
+            if (is_callable($resolver)) {
+                return call_user_func_array($resolver, $args);
+            } else {
+                if ($resolver instanceof ResolverInterface) {
+                    return call_user_func_array([$resolver, 'resolve'], $args);
+                } else {
+                    throw new \Exception(sprintf(
+                        '%s resolver must be a closure or implement %s',
+                        __CLASS__,
+                        ResolverInterface::class
+                    ));
+                }
+            }
+        };
+    }
+
+}
\ No newline at end of file
diff --git a/src/Scaffolding/Creators/QueryOperationCreator.php b/src/Scaffolding/Creators/QueryOperationCreator.php
new file mode 100644
index 000000000..1bc2ffe9e
--- /dev/null
+++ b/src/Scaffolding/Creators/QueryOperationCreator.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Creators;
+
+use SilverStripe\GraphQL\Manager;
+use SilverStripe\GraphQL\QueryCreator;
+use GraphQL\Type\Definition\Type;
+
+/**
+ * Creates a GraphQL query field
+ * @package SilverStripe\GraphQL\Scaffolding\Operations
+ */
+class QueryOperationCreator extends QueryCreator
+{
+
+    use OperationCreatorTrait;
+
+    /**
+     * @return \Closure
+     */
+    public function type()
+    {
+        return function () {
+            return Type::listOf($this->manager->getType(
+                $this->typeName
+            ));
+        };
+    }
+
+}
diff --git a/src/Scaffolding/DataObjectTypeTrait.php b/src/Scaffolding/DataObjectTypeTrait.php
new file mode 100644
index 000000000..7a0f8c411
--- /dev/null
+++ b/src/Scaffolding/DataObjectTypeTrait.php
@@ -0,0 +1,88 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding;
+
+use SilverStripe\Core\Injector\Injector;
+use SilverStripe\Core\Config\Config;
+
+/**
+ * Offers a few helper methods for classes that are DataObject subclass bound.
+ *
+ * @package SilverStripe\GraphQL\Scaffolding
+ */
+trait DataObjectTypeTrait
+{
+    /**
+     * @var string
+     */
+    protected $dataObjectName;
+
+    /**
+     * @var string
+     */
+    protected $dataObjectTypeName;
+
+    /**
+     * @var DataObject
+     */
+    protected $dataObjectInstance;
+
+    /**
+     * @return string
+     */
+    public function getDataObjectName()
+    {
+        return $this->dataObjectName;
+    }
+
+    /**
+     * @return string
+     */
+    public function typeName()
+    {
+        /* Type names must be unique and predictable. Cannot allow customisation. */
+        //return $this->dataObjectTypeName ?: $this->getDataObjectInstance()->singular_name();
+
+        return $this->typeNameForDataObject($this->dataObjectName);
+    }
+
+    /**
+     * @return mixed
+     */
+    public function getDataObjectInstance()
+    {
+        if ($this->dataObjectInstance) {
+            return $this->dataObjectInstance;
+        }
+
+        return $this->dataObjectInstance = Injector::inst()->get($this->dataObjectName);
+    }
+
+    /**
+     * Sets the DataObject name
+     * @param string $name
+     * @return  $this
+     */
+    public function setDataObjectName($name)
+    {
+        $this->dataObjectName = $name;
+
+        return $this;
+    }
+
+    /**
+     * Given a DataObject subclass name, transform it into a sanitised (and implicitly unique) type
+     * name suitable for the GraphQL schema
+     * 
+     * @param $class
+     * @return mixed
+     */
+    protected function typeNameForDataObject($class)
+    {
+        $typeName = Config::inst()->get($class, 'table_name', Config::UNINHERITED) ?:
+            Injector::inst()->get($class)->singular_name();
+
+        return preg_replace('/[^A-Za-z0-9_]/', '_', $typeName);
+    }
+
+}
\ No newline at end of file
diff --git a/src/Scaffolding/OperationList.php b/src/Scaffolding/OperationList.php
new file mode 100644
index 000000000..cadff2ee1
--- /dev/null
+++ b/src/Scaffolding/OperationList.php
@@ -0,0 +1,82 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding;
+
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\OperationScaffolder;
+use SilverStripe\ORM\ArrayList;
+use Doctrine\Instantiator\Exception\InvalidArgumentException;
+
+/**
+ * An array list designed to work with OperationScaffolders
+ * @package SilverStripe\GraphQL\Scaffolding
+ */
+class OperationList extends ArrayList
+{
+    /**
+     * OperationList constructor.
+     * @param array $items
+     */
+    public function __construct($items = [])
+    {
+        foreach ($items as $item) {
+            if (!$item instanceof OperationScaffold) {
+                throw new InvalidArgumentException(
+                    '%s only accepts instances of %s',
+                    __CLASS__,
+                    OperationScaffold::class
+                );
+            }
+        }
+
+        parent::__construct($items);
+    }
+
+    /**
+     * @param array|object $item
+     */
+    public function push($item)
+    {
+        if (!$item instanceof OperationScaffolder) {
+            throw new InvalidArgumentException(sprintf(
+                '%s only accepts instances of %s',
+                __CLASS__,
+                OperationScaffolder::class
+            ));
+        }
+
+        parent::push($item);
+    }
+
+    /**
+     * @param $name
+     * @return bool
+     */
+    public function findByName($name)
+    {
+        foreach ($this->items as $key => $value) {
+            if ($name === $value->getName()) {
+                return $value;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * @param $name
+     */
+    public function removeByName($name)
+    {
+        $renumberKeys = false;
+        foreach ($this->items as $key => $value) {
+            if ($name === $value->getName()) {
+                $renumberKeys = true;
+                unset($this->items[$key]);
+            }
+        }
+
+        if ($renumberKeys) {
+            $this->items = array_values($this->items);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Scaffolding/ResolverInterface.php b/src/Scaffolding/ResolverInterface.php
new file mode 100644
index 000000000..a3fab7f2a
--- /dev/null
+++ b/src/Scaffolding/ResolverInterface.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding;
+
+/**
+ * Applied to classes that resolve queries or mutations
+ * 
+ * @package SilverStripe\GraphQL\Scaffolding\Resolvers
+ */
+interface ResolverInterface
+{
+    /**
+     * @param DataObjectInterface $object
+     * @param array $args
+     * @param $context
+     * @param $info
+     * @return mixed
+     */
+    public function resolve($object, $args, $context, $info);
+
+}
\ No newline at end of file
diff --git a/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php b/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php
new file mode 100644
index 000000000..8cf4f337a
--- /dev/null
+++ b/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php
@@ -0,0 +1,93 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
+
+use SilverStripe\GraphQL\Scaffolding\DataObjectTypeTrait;
+use GraphQL\Type\Definition\InputObjectType;
+use GraphQL\Type\Definition\Type;
+use SilverStripe\Core\Injector\Injector;
+use SilverStripe\GraphQL\Scaffolding\Util\TypeParser;
+use SilverStripe\GraphQL\Manager;
+
+/**
+ * A generic "create" operation for a DataObject
+ * @package SilverStripe\GraphQL\Scaffolding\Scaffolders
+ */
+class CreateOperationScaffolder extends MutationScaffolder
+{
+
+    use DataObjectTypeTrait;
+
+    /**
+     * CreateOperationScaffolder constructor.
+     * @param null $dataObjectName
+     */
+    public function __construct($dataObjectName)
+    {
+        $this->dataObjectName = $dataObjectName;
+
+        parent::__construct(
+            'create' . ucfirst($this->typeName()),
+            $this->typeName()
+        );
+
+        $args = [];
+        $instance = $this->getDataObjectInstance();
+
+        // Setup default input args.. Placeholder!
+        foreach ($instance->db() as $dbFieldName => $dbFieldType) {
+            $result = $instance->obj($dbFieldName);
+            $typeName = $result->config()->graphql_type;
+            $args[$dbFieldName] = $typeName;
+        }
+        unset($args['ID']);
+
+        $this->args = $args;
+
+        // Todo: this is totally half baked
+        $this->setResolver(function ($object, array $args, $context, $info) {
+            if (singleton($this->dataObjectName)->canCreate()) {
+                $newObject = Injector::inst()->createWithArgs(
+                    $this->dataObjectName,
+                    $args
+                );
+                $newObject->write();
+
+                return $newObject;
+            } else {
+                // somehow deal with permission errors here
+            }
+        });
+
+    }
+
+    /**
+     * @return array
+     */
+    protected function createArgs()
+    {
+        return [
+            'Input' => [
+                'type' => Type::nonNull($this->generateInputType())
+            ]
+        ];
+    }
+
+    /**
+     * @return InputObjectType
+     */
+    protected function generateInputType()
+    {
+        $fields = [];
+        foreach ($this->args as $fieldName => $typeStr) {
+            $arr = (new TypeParser($typeStr))->toArray();
+            $arr['name'] = $fieldName;
+            $fields[] = $arr;
+        }
+        return new InputObjectType([
+            'name' => $this->typeName() . 'CreateInputType',
+            'fields' => $fields
+        ]);
+
+    }
+}
\ No newline at end of file
diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
new file mode 100644
index 000000000..5149af83e
--- /dev/null
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -0,0 +1,338 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
+
+use Doctrine\Instantiator\Exception\InvalidArgumentException;
+use SilverStripe\ORM\DataObject;
+use SilverStripe\ORM\ArrayList;
+use SilverStripe\ORM\DataObjectInterface;
+use SilverStripe\ORM\FieldType\DBField;
+use SilverStripe\GraphQL\Manager;
+use GraphQL\Type\Definition\Type;
+use SilverStripe\GraphQL\Scaffolding\OperationList;
+use SilverStripe\GraphQL\Scaffolding\Util\TypeParser;
+use SilverStripe\GraphQL\Scaffolding\Creators\DataObjectTypeCreator;
+use SilverStripe\GraphQL\Scaffolding\DataObjectTypeTrait;
+use SilverStripe\Core\Config\Config;
+/**
+ * Scaffolds a DataObjectTypeCreator
+ * @package SilverStripe\GraphQL\Scaffolding
+ */
+class DataObjectScaffolder implements ManagerMutatorInterface, ScaffolderInterface
+{
+    use DataObjectTypeTrait;
+
+    /**
+     * @var OperationList
+     */
+    protected $queries;
+
+    /**
+     * @var  OperationList
+     */
+    protected $mutations;
+
+    /**
+     * @var array
+     */
+    protected $fields;
+
+    /**
+     * DataObjectScaffold constructor.
+     * @param $dataObjectName
+     */
+    public function __construct($dataObjectName)
+    {
+        if (!class_exists($dataObjectName)) {
+            throw new InvalidArgumentException(sprintf(
+                'DataObjectScaffold instantiated with non-existent classname "%s"',
+                $dataObjectName
+            ));
+        }
+
+        if (!is_subclass_of($dataObjectName, DataObject::class)) {
+            throw new InvalidArgumentException(sprintf(
+                'DataObjectScaffold must instantiate with a classname that is a subclass of %s',
+                DataObject::class
+            ));
+        }
+
+        $this->queries = OperationList::create([]);
+        $this->mutations = OperationList::create([]);
+        $this->fields = ArrayList::create([]);
+
+        $this->dataObjectName = $dataObjectName;
+    }
+
+    /**
+     * Find or make a query
+     * @param $name
+     * @param null $resolver
+     * @return bool|QueryScaffolder
+     */
+    public function query($name, $resolver = null)
+    {
+        $query = $this->queries->findByName($name);
+
+        if ($query) {
+            return $query;
+        }
+
+        if ($scaffoldClass = self::getOperationScaffoldForName($name)) {
+            $operationScaffold = new $scaffoldClass($this->dataObjectName);
+        } else {
+            $operationScaffold = new QueryScaffolder(
+                $name,
+                $this->typeName(),
+                $resolver
+            );
+        }
+
+        $this->queries->push($operationScaffold);
+
+        return $operationScaffold;
+    }
+
+
+    /**
+     * Find or make a mutation
+     * @param $name
+     * @param null $resolver
+     * @return bool|MutationScaffolder
+     */
+    public function mutation($name, $resolver = null)
+    {
+        $mutation = $this->mutations->findByName($name);
+
+        if ($mutation) {
+            return $mutation;
+        }
+
+        if ($scaffoldClass = self::getOperationScaffoldForName($name)) {
+            $operationScaffold = new $scaffoldClass($this->dataObjectName);
+        } else {
+            $operationScaffold = new MutationScaffolder(
+                $name,
+                $this->typeName(),
+                $resolver
+            );
+        }
+
+        $this->mutations->push($operationScaffold);
+
+        return $operationScaffold;
+    }
+
+    /**
+     * Removes a mutation
+     * @param $name
+     * @return $this
+     */
+    public function removeMutation($name)
+    {
+        $this->mutations->removeByName($name);
+
+        return $this;
+    }
+
+
+    /**
+     * Removes a query
+     * @param $name
+     * @return $this
+     */
+    public function removeQuery($name)
+    {
+        $this->queries->removeByName($name);
+
+        return $this;
+    }
+
+    /**
+     * Adds visible fields.
+     * @param array $fields
+     */
+    public function addFields(array $fields)
+    {
+        // Remove duplicates
+        $this->fields = ArrayList::create(array_unique(array_merge(
+            $this->fields->toArray(),
+            $fields
+        )));
+
+        return $this;
+    }
+
+    /**
+     * @param $field
+     * @return mixed
+     */
+    public function addField($field)
+    {
+        return $this->addFields((array)$field);
+    }
+
+    /**
+     * @param $field
+     * @return $this
+     */
+    public function removeField($field)
+    {
+        $this->fields->remove($field);
+
+        return $this;
+    }
+
+    /**
+     * @param array $fields
+     * @return $this
+     */
+    public function removeFields(array $fields)
+    {
+        foreach ($fields as $field) {
+            $this->removeField($field);
+        }
+
+        return $this;
+    }
+
+    /**
+     * @return array
+     */
+    public function getQueries()
+    {
+        return $this->queries;
+    }
+
+    /**
+     * @return array
+     */
+    public function getMutations()
+    {
+        return $this->mutations;
+    }
+
+    /**
+     * @return array
+     */
+    public function getFields()
+    {
+        return $this->fields;
+    }
+
+
+    /**
+     * Puts all of the configuration into a type creator
+     * @return DataObjectTypeCreator
+     */
+    public function getCreator(Manager $manager)
+    {
+        $fieldMap = [];
+        $instance = $this->getDataObjectInstance();
+        $extraDataObjects = $this->getExtraDataObjects();
+        $fields = array_unique($this->fields->toArray());
+
+        if (empty($fields)) {
+        	$fields = Config::inst()->get(self::class, 'default_fields');        	
+        }
+
+        foreach ($fields as $fieldName) {
+            $result = $instance->obj($fieldName);
+            if ($result instanceof DBField) {
+                $typeName = $result->config()->graphql_type;
+                $fieldMap[$fieldName] = (new TypeParser($typeName))->toArray();
+            }
+        }
+
+        foreach ($extraDataObjects as $fieldName => $className) {
+            $result = $instance->obj($fieldName);
+            $typeName = $this->typeNameForDataObject($className);
+
+            if ($result instanceof DataList || $result instanceof ArrayList) {
+                $fieldMap[$fieldName] = [
+                    'type' => function () use ($manager, $typeName) {
+                        return Type::listOf($manager->getType($typeName));
+                    }
+                ];
+            } else {
+                $fieldMap[$fieldName] = [
+                    'type' => function () use ($manager, $typeName) {
+                        return $manager->getType($typeName);
+                    }
+                ];
+            }
+        }
+
+        return new DataObjectTypeCreator($manager, $this->typeName(), $fieldMap);
+    }
+
+
+    /**
+     * Gets any DataObjects that are implicitly required by this type definition, e.g. has_one, has_many
+     * @return array
+     */
+    public function getExtraDataObjects()
+    {
+        $types = [];
+        $instance = $this->getDataObjectInstance();
+        $fields = $this->fields->toArray();
+
+        foreach ($fields as $fieldName) {
+            $result = $instance->obj($fieldName);
+            if ($result instanceof DataList || $result instanceof ArrayList) {
+                $types[$fieldName] = $result->dataClass();
+            } else {
+                if ($result instanceof DataObjectInterface) {
+                    $types[$fieldName] = get_class($result);
+                }
+            }
+        }
+
+        return $types;
+    }
+
+
+    /**
+     * Adds the type to the Manager
+     * @param Manager $manager
+     */
+    public function addToManager(Manager $manager)
+    {
+        $creator = $this->getCreator($manager);
+
+        if (!$manager->getType($this->typeName())) {
+            $manager->addType($creator->toType(), $this->typeName());
+        }
+
+        foreach ($this->queries as $op) {
+            $op->addToManager($manager);
+        }
+
+        foreach ($this->mutations as $op) {
+            $op->addToManager($manager);
+        }
+
+    }
+
+
+    /**
+     * @param $name
+     * @return null
+     */
+    protected static function getOperationScaffoldForName($name)
+    {
+        switch ($name) {
+            case GraphQLScaffolder::CREATE:
+                return CreateOperationScaffolder::class;
+            case GraphQLScaffolder::READ:
+                return ReadOperationScaffolder::class;
+            case GraphQLScaffolder::UPDATE:
+                return UpdateOperationScaffolder::class;
+            case GraphQLScaffolder::DELETE:
+                return DeleteOperationScaffolder::class;
+        }
+
+        return null;
+    }
+
+}
\ No newline at end of file
diff --git a/src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php b/src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php
new file mode 100644
index 000000000..b17bff0d0
--- /dev/null
+++ b/src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php
@@ -0,0 +1,50 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
+
+use SilverStripe\GraphQL\Scaffolding\DataObjectTypeTrait;
+use SilverStripe\GraphQL\Scaffolding\Resolvers\Delete;
+use SilverStripe\ORM\DataList;
+
+/**
+ * A generic delete operation
+ * @package SilverStripe\GraphQL\Scaffolding\Scaffolders
+ */
+class DeleteOperationScaffolder extends MutationScaffolder
+{
+
+    use DataObjectTypeTrait;
+
+    /**
+     * DeleteOperationScaffolder constructor.
+     * @param null $dataObjectName
+     */
+    public function __construct($dataObjectName)
+    {
+        $this->dataObjectName = $dataObjectName;
+        $this->args = [
+            'ID' => 'ID!'
+        ];
+
+        parent::__construct(
+            'delete' . ucfirst($this->typeName()),
+            $this->typeName()
+        );
+
+        $this->setResolver(function ($object, array $args, $context, $info) {
+            if (singleton($this->dataObjectName)->canDelete()) {
+                $obj = DataList::create($this->dataObjectName)
+                    ->byID($args['ID']);
+
+                if ($obj) {
+                    $obj->delete();
+                }
+
+                return $obj;
+            } else {
+                // permission error
+            }
+        });
+
+    }
+}
\ No newline at end of file
diff --git a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
new file mode 100644
index 000000000..c6aced463
--- /dev/null
+++ b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
@@ -0,0 +1,160 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
+
+use SilverStripe\Core\Injector\Injector;
+use Doctrine\Instantiator\Exception\InvalidArgumentException;
+use SilverStripe\GraphQL\Manager;
+use SilverStripe\GraphQL\Scaffolding\Creators\MutationOperationCreator;
+use SilverStripe\GraphQL\Scaffolding\Creators\QueryOperationCreator;
+
+/**
+ * The entry point for a GraphQL scaffolding definition. Holds DataObject type definitions,
+ * and their nested Mutation/Query definitions.
+ *
+ * @package SilverStripe\GraphQL\Scaffolding
+ */
+class GraphQLScaffolder implements ManagerMutatorInterface
+{
+
+    const CREATE = 1;
+
+    const READ = 2;
+
+    const UPDATE = 3;
+
+    const DELETE = 4;
+
+    /**
+     * @var array
+     */
+    protected $scaffolds = [];
+
+    /**
+     * Create from an array, e.g. derived from YAML
+     *
+     * @param $config
+     * @return mixed
+     * @throws InvalidArgumentException
+     */
+    public static function createFromConfig($config)
+    {
+        $scaffolder = Injector::inst()->create(GraphQLScaffolder::class);
+        foreach ($config as $dataObjectName => $settings) {
+            if (empty($settings['fields']) || !is_array($settings['fields'])) {
+                throw new \Exception(
+                    "No array of fields defined for $dataObjectName"
+                );
+            }
+
+            $scaffolder->dataObject($dataObjectName)
+                ->addFields($settings['fields']);
+
+            if (isset($settings['operations'])) {
+                $ops = [];
+                if ($settings['operations'] === 'all') {
+                    $ops = [self::CREATE, self::READ, self::UPDATE, self::DELETE];
+                } else {
+                    if (is_array($settings['operations'])) {
+                        foreach ($settings['operations'] as $op) {
+                            $constStr = sprintf(
+                                '%s::%s',
+                                GraphQLScaffolder::class,
+                                strtoupper($op)
+                            );
+                            if (defined($constStr)) {
+                                $ops[] = constant($constStr);
+                            } else {
+                                throw new \Exception(
+                                    "Invalid operation: $op"
+                                );
+                            }
+                        }
+                    } else {
+                        throw new \Exception(
+                            "Operations field must be an array of operations or 'all'"
+                        );
+                    }
+                }
+                foreach ($ops as $op) {
+                    $method = ($op === GraphQLScaffolder::READ) ? 'query' : 'mutation';
+                    $scaffolder->dataObject($dataObjectName)
+                        ->$method($op);
+                }
+            }
+            $queryMap = [
+                'queries' => 'query',
+                'mutations' => 'mutation'
+            ];
+
+            foreach ($queryMap as $group => $method) {
+                if (isset($settings[$group]) && is_array($settings[$group])) {
+                    foreach ($settings[$group] as $fieldName => $fieldSettings) {
+                        if (empty($fieldSettings['resolver'])) {
+                            throw new \Exception(
+                                "All queries and mutations must have a 'resolver' attribute"
+                            );
+                        }
+                        $args = isset($fieldSettings['args']) ? (array)$fieldSettings['args'] : [];
+                        $scaffolder->dataObject($dataObjectName)
+                            ->$method($fieldName)
+                            ->setResolver($fieldSettings['resolver'])
+                            ->addArgs($args);
+                    }
+                }
+            }
+        }
+
+        return $scaffolder;
+    }
+
+    /**
+     * Finds or makes a DataObject definition
+     *
+     * @param DataObjectScaffold $scaffold
+     * @throws InvalidArgumentException
+     */
+    public function dataObject($name, $typeName = null)
+    {
+        foreach ($this->scaffolds as $scaffold) {
+            if ($scaffold->getDataObjectName() == $name) {
+                return $scaffold;
+            }
+        }
+
+        $scaffold = new DataObjectScaffolder($name, $typeName);
+        $this->scaffolds[] = $scaffold;
+
+        return $scaffold;
+    }
+
+
+    /**
+     * Adds every DataObject and its dependencies to the Manager
+     * @param Manager $manager
+     */
+    public function addToManager(Manager $manager)
+    {
+        // Gather all new types that were implicitly added through
+        // addFields(), e.g. member->addFields(['Groups'])
+        $extraDataObjects = [];
+        foreach ($this->scaffolds as $scaffold) {
+            $types = $scaffold->getExtraDataObjects();
+            foreach ($types as $fieldName => $className) {
+                $extraDataObjects[] = $className;
+            }
+        }
+
+        $extraDataObjects = array_unique($extraDataObjects);
+
+        // Ensure that all these types exist in the scaffolder
+        foreach ($extraDataObjects as $className) {
+            $this->dataObject($className);
+        }
+
+        // Add all DataObjects to the manager
+        foreach ($this->scaffolds as $scaffold) {
+            $scaffold->addToManager($manager);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Scaffolding/Scaffolders/ManagerMutatorInterface.php b/src/Scaffolding/Scaffolders/ManagerMutatorInterface.php
new file mode 100644
index 000000000..8e2187b5c
--- /dev/null
+++ b/src/Scaffolding/Scaffolders/ManagerMutatorInterface.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
+
+use SilverStripe\GraphQL\Manager;
+
+/**
+ * Defines a class that updates the Manager
+ * @package SilverStripe\GraphQL\Scaffolding
+ */
+interface ManagerMutatorInterface
+{
+    /**
+     * @param Manager $manager
+     * @return mixed
+     */
+    public function addToManager(Manager $manager);
+}
\ No newline at end of file
diff --git a/src/Scaffolding/Scaffolders/MutationScaffolder.php b/src/Scaffolding/Scaffolders/MutationScaffolder.php
new file mode 100644
index 000000000..0191d79d3
--- /dev/null
+++ b/src/Scaffolding/Scaffolders/MutationScaffolder.php
@@ -0,0 +1,42 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
+
+use SilverStripe\GraphQL\Manager;
+use SilverStripe\GraphQL\Scaffolding\Creators\MutationOperationCreator;
+
+/**
+ * Scaffolds a GraphQL mutation field
+ * @package SilverStripe\GraphQL\Scaffolding\Scaffolders
+ */
+class MutationScaffolder extends OperationScaffolder implements ManagerMutatorInterface, ScaffolderInterface
+{
+
+    /**
+     * @param Manager $manager
+     */
+    public function addToManager(Manager $manager)
+    {
+        $operationType = $this->getCreator($manager);
+        $manager->addMutation(
+            $operationType->toArray(),
+            $this->getName()
+        );
+    }
+
+    /**
+     * @param Manager $manager
+     * @return MutationOperationCreator
+     */
+    public function getCreator(Manager $manager)
+    {
+        return new MutationOperationCreator(
+            $manager,
+            $this->operationName,
+            $this->typeName,
+            $this->resolver,
+            $this->createArgs()
+        );
+    }
+
+}
\ No newline at end of file
diff --git a/src/Scaffolding/Scaffolders/OperationScaffolder.php b/src/Scaffolding/Scaffolders/OperationScaffolder.php
new file mode 100644
index 000000000..f8a68cfac
--- /dev/null
+++ b/src/Scaffolding/Scaffolders/OperationScaffolder.php
@@ -0,0 +1,137 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
+
+use Doctrine\Instantiator\Exception\InvalidArgumentException;
+use SilverStripe\GraphQL\Scaffolding\Util\ArgsParser;
+use SilverStripe\GraphQL\Scaffolding\ResolverInterface;
+use SilverStripe\Core\Injector\Injector;
+
+/**
+ * Trait Operation
+ * @package SilverStripe\GraphQL\Scaffolding\Operations
+ */
+abstract class OperationScaffolder
+{
+    /**
+     * @var string
+     */
+    protected $typeName;
+
+    /**
+     * @var string
+     */
+    protected $operationName;
+
+
+    /**
+     * @var \Closure | SilverStripe\GraphQL\Scaffolding\ResolverInterface
+     */
+    protected $resolver;
+
+    /**
+     * @var array
+     */
+    protected $args = [];
+
+
+    /**
+     * @param array $config
+     * @return OperationScaffolder
+     * @throws InvalidArgumentException
+     */
+    public static function createFromConfig($typeName, $config)
+    {
+        if (!isset($config['name'])) {
+            throw new InvalidArgumentException(sprintf(
+                '%s::%s() config array must have a key for "name"',
+                __CLASS__,
+                __FUNCTION__
+            ));
+        }
+
+        $operation = new static($config['name'], $typeName);
+
+        if (isset($config['resolver'])) {
+            $operation->setResolver($config['resolver']);
+        }
+
+        return $operation;
+    }
+
+
+    /**
+     * OperationScaffolder constructor.
+     * @param null $operationName
+     * @param  null $resolver Resolver|\Closure
+     */
+    public function __construct($operationName, $typeName, $resolver = null)
+    {
+        $this->operationName = $operationName;
+        $this->typeName = $typeName;
+
+        if ($resolver) {
+            $this->setResolver($resolver);
+        }
+    }
+
+
+    /**
+     * Adds arguments to the mutation. e.g.
+     * [
+     *    'Email' => 'String!', // required
+     *    'Limit' => 'Int=10', // optional, default value of 10
+     *    'Featured' => 'Boolean'
+     * ]
+     * @param array $args
+     * @return $this
+     */
+    public function addArgs($args = [])
+    {
+        $this->args = array_merge($this->args, $args);
+
+        return $this;
+    }
+
+    /**
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->operationName;
+    }
+
+    /**
+     * @param $resolver
+     * @return $this
+     * @throws InvalidArgumentException
+     */
+    public function setResolver($resolver)
+    {
+        if (is_callable($resolver) || $resolver instanceof ResolverInterface) {
+            $this->resolver = $resolver;
+        } else {
+            if (is_subclass_of($resolver, ResolverInterface::class)) {
+                $this->resolver = Injector::inst()->create($resolver);
+            } else {
+                throw new InvalidArgumentException(sprintf(
+                    "%s::setResolver() accepts closures, instances of %s or names of resolver subclasses.",
+                    __CLASS__,
+                    ResolverInterface::class
+                ));
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Parses the args to proper graphql-php spec
+     * @return array
+     */
+    protected function createArgs()
+    {
+        return (new ArgsParser($this->args))->toArray();
+    }
+
+}
\ No newline at end of file
diff --git a/src/Scaffolding/Scaffolders/QueryScaffolder.php b/src/Scaffolding/Scaffolders/QueryScaffolder.php
new file mode 100644
index 000000000..a045b1741
--- /dev/null
+++ b/src/Scaffolding/Scaffolders/QueryScaffolder.php
@@ -0,0 +1,42 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
+
+use SilverStripe\GraphQL\Manager;
+use SilverStripe\GraphQL\Scaffolding\Creators\QueryOperationCreator;
+
+/**
+ * Scaffolds a GraphQL query field
+ * @package SilverStripe\GraphQL\Scaffolding\Scaffolders
+ */
+class QueryScaffolder extends OperationScaffolder implements ManagerMutatorInterface, ScaffolderInterface
+{
+
+    /**
+     * @param Manager $manager
+     */
+    public function addToManager(Manager $manager)
+    {
+        $operationType = $this->getCreator($manager);
+        $manager->addQuery(
+            $operationType->toArray(),
+            $this->getName()
+        );
+    }
+
+    /**
+     * @param Manager $manager
+     * @return QueryOperationCreator
+     */
+    public function getCreator(Manager $manager)
+    {
+        return new QueryOperationCreator(
+            $manager,
+            $this->operationName,
+            $this->typeName,
+            $this->resolver,
+            $this->createArgs()
+        );
+    }
+}
+
diff --git a/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php b/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php
new file mode 100644
index 000000000..31d6d88d2
--- /dev/null
+++ b/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php
@@ -0,0 +1,54 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
+
+use SilverStripe\GraphQL\Scaffolding\DataObjectTypeTrait;
+use SilverStripe\GraphQL\Scaffolding\Resolvers\Read;
+use SilverStripe\ORM\DataList;
+
+/**
+ * Scaffolds a generic read operation for DataObjects
+ * @package SilverStripe\GraphQL\Scaffolding\Scaffolders
+ */
+class ReadOperationScaffolder extends QueryScaffolder
+{
+
+    use DataObjectTypeTrait;
+
+    /**
+     * ReadOperationScaffolder constructor.
+     * @param null $dataObjectName
+     */
+    public function __construct($dataObjectName)
+    {
+        $this->dataObjectName = $dataObjectName;
+
+        // default args of some sort
+        $this->args = [
+            'Limit' => 'Int=20',
+            'Sort' => 'String'
+        ];
+
+        $typeName = $this->getDataObjectInstance()->plural_name();
+        $typeName = str_replace(' ', '', $typeName);
+        $typeName = ucfirst($typeName);
+        $operationName = 'read' . $typeName;
+
+        parent::__construct($operationName, $this->typeName());
+
+        $this->setResolver(function ($object, array $args, $context, $info) {
+            if (singleton($this->dataObjectName)->canView()) {
+                $list = DataList::create($this->dataObjectName);
+                $list = $list->limit($args['Limit']);
+                if (isset($args['Sort'])) {
+                    $list = $list->sort($args['Sort']);
+                }
+
+                // filterByCallback(canView()) ??
+
+                return $list;
+            }
+        });
+
+    }
+}
\ No newline at end of file
diff --git a/src/Scaffolding/Scaffolders/ScaffolderInterface.php b/src/Scaffolding/Scaffolders/ScaffolderInterface.php
new file mode 100644
index 000000000..c75c1f65c
--- /dev/null
+++ b/src/Scaffolding/Scaffolders/ScaffolderInterface.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
+
+use SilverStripe\GraphQL\Manager;
+
+/**
+ * Defines a class that transforms into a type or field creator
+ * @package SilverStripe\GraphQL\Scaffolding\Scaffolders
+ */
+interface ScaffolderInterface
+{
+    /**
+     * @param Manager $manager
+     * @return mixed
+     */
+    public function getCreator(Manager $manager);
+}
\ No newline at end of file
diff --git a/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php b/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php
new file mode 100644
index 000000000..1ff1703e4
--- /dev/null
+++ b/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php
@@ -0,0 +1,102 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
+
+use SilverStripe\GraphQL\Scaffolding\DataObjectTypeTrait;
+use SilverStripe\GraphQL\Scaffolding\Resolvers\Update;
+use GraphQL\Type\Definition\InputObjectType;
+use SilverStripe\Core\Injector\Injector;
+use SilverStripe\GraphQL\Scaffolding\Util\TypeParser;
+use SilverStripe\ORM\DataList;
+use SilverStripe\GraphQL\Manager;
+use GraphQL\Type\Definition\Type;
+
+/**
+ * Scaffolds a generic update operation for DataObjects
+ * @package SilverStripe\GraphQL\Scaffolding\Scaffolders
+ */
+class UpdateOperationScaffolder extends MutationScaffolder
+{
+
+    use DataObjectTypeTrait;
+
+    /**
+     * UpdateOperationScaffolder constructor.
+     * @param null $dataObjectName
+     */
+    public function __construct($dataObjectName)
+    {
+        $this->dataObjectName = $dataObjectName;
+
+        parent::__construct(
+            'update' . ucfirst($this->typeName()),
+            $this->typeName()
+        );
+
+        $args = [];
+        $instance = $this->getDataObjectInstance();
+
+        // Setup default input args.. Placeholder!
+        foreach ($instance->db() as $dbFieldName => $dbFieldType) {
+            $result = $instance->obj($dbFieldName);
+            $typeName = $result->config()->graphql_type;
+            $args[$dbFieldName] = $typeName;
+        }
+
+        $this->args = $args;
+
+        // Todo: this is totally half baked
+        $this->setResolver(function ($object, array $args, $context, $info) {
+            if (singleton($this->dataObjectName)->canEdit()) {
+                $obj = DataList::create($this->dataObjectName)
+                    ->byID($args['ID']);
+
+                if ($obj) {
+                    $obj->update($args['Input']);
+                    $obj->write();
+                }
+
+                return $obj;
+            } else {
+                // permission error
+            }
+        });
+
+    }
+
+
+    /**
+     * Use a generated Input type, and require an ID
+     * @return array
+     */
+    protected function createArgs()
+    {
+        return [
+            'ID' => (new TypeParser('ID!'))->toArray(),
+            'Input' => [
+                'type' => Type::nonNull($this->generateInputType())
+            ]
+        ];
+    }
+
+    /**
+     * Based on the args provided, create an Input type to add to the Manager
+     * @return InputObjectType
+     */
+    protected function generateInputType()
+    {
+        $fields = [];
+        $args = $this->args;
+        unset($args['ID']);
+
+        foreach ($args as $fieldName => $typeStr) {
+            $arr = (new TypeParser($typeStr))->toArray();
+            $arr['name'] = $fieldName;
+            $fields[] = $arr;
+        }
+        return new InputObjectType([
+            'name' => $this->typeName() . 'UpdateInputType',
+            'fields' => $fields
+        ]);
+    }
+}
\ No newline at end of file
diff --git a/src/Scaffolding/ScaffoldingProvider.php b/src/Scaffolding/ScaffoldingProvider.php
new file mode 100644
index 000000000..d0dd96f80
--- /dev/null
+++ b/src/Scaffolding/ScaffoldingProvider.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding;
+
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
+
+/**
+ * Use on classes that update the GraphQL scaffolder
+ * @package SilverStripe\GraphQL\Scaffolding
+ */
+interface ScaffoldingProvider
+{
+    /**
+     * @return mixed
+     */
+    public function provideGraphQLScaffolding(GraphQLScaffolder $scaffolder);
+}
\ No newline at end of file
diff --git a/src/Scaffolding/Util/ArgsParser.php b/src/Scaffolding/Util/ArgsParser.php
new file mode 100644
index 000000000..fa2f3459a
--- /dev/null
+++ b/src/Scaffolding/Util/ArgsParser.php
@@ -0,0 +1,56 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Util;
+
+use Doctrine\Instantiator\Exception\InvalidArgumentException;
+use GraphQL\Type\Definition\Type;
+
+/**
+ * Parses an array of args into the proper graphql-php spec, using first-class type objects in lieu of strings
+ * @package SilverStripe\GraphQL\Scaffolding\Util
+ */
+class ArgsParser
+{
+
+    /**
+     * @var array
+     */
+    protected $args = [];
+
+    /**
+     * ArgsParser constructor.
+     * @param array $args
+     */
+    public function __construct(array $args)
+    {
+        $this->args = $args;
+    }
+
+    /**
+     * Gets the array of args suitable for a field creator
+     * @return array
+     */
+    public function toArray()
+    {
+        $args = [];
+        foreach ($this->args as $argName => $type) {
+            if (is_string($type)) {
+                $args[$argName] = (new TypeParser($type))->toArray();
+            } else {
+                if ($type instanceof Type) {
+                    $args[$argName] = ['type' => $type];
+                } else {
+                    if (is_array($type)) {
+                        $args[$argName] = $type;
+                    } else {
+                        throw new InvalidArgumentException(
+                            "Invalid argument type provided for $argName"
+                        );
+                    }
+                }
+            }
+        }
+
+        return $args;
+    }
+}
\ No newline at end of file
diff --git a/src/Scaffolding/Util/TypeParser.php b/src/Scaffolding/Util/TypeParser.php
new file mode 100644
index 000000000..51547d851
--- /dev/null
+++ b/src/Scaffolding/Util/TypeParser.php
@@ -0,0 +1,118 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Util;
+
+use GraphQL\Type\Definition\Type;
+use Doctrine\Instantiator\Exception\InvalidArgumentException;
+
+/**
+ * Parses a type, e.g. String!=20 into an array defining the arg type
+ * @package SilverStripe\GraphQL\Scaffolding\Util
+ */
+class TypeParser
+{
+
+    /**
+     * @var strign
+     */
+    protected $rawArg;
+
+    /**
+     * @var string
+     */
+    protected $argType;
+
+    /**
+     * @var bool
+     */
+    protected $required = false;
+
+    /**
+     * @var null
+     */
+    protected $defaultValue = null;
+
+    /**
+     * TypeParser constructor.
+     * @param $rawArg
+     */
+    public function __construct($rawArg)
+    {
+        if (!preg_match('/^([A-Za-z]+)(!?)(\s*=\s*(.*))?/', $rawArg, $matches)) {
+            throw new InvalidArgumentException(
+                "Invalid argument: $rawArg"
+            );
+        }
+
+        $this->rawArg = $rawArg;
+        $this->argType = $matches[1];
+        $this->required = isset($matches[2]) && $matches[2] == '!';
+        if (isset($matches[4])) {
+            $this->defaultValue = $matches[4];
+        }
+
+    }
+
+    /**
+     * @return bool
+     */
+    public function isRequired()
+    {
+        return $this->required;
+    }
+
+    /**
+     * @return mixed
+     */
+    public function getArgTypeName()
+    {
+        return $this->argType;
+    }
+
+    /**
+     * @return null
+     */
+    public function getDefaultValue()
+    {
+        return $this->defaultValue;
+    }
+
+    /**
+     * @return array
+     */
+    public function toArray()
+    {
+        $type = null;
+        switch ($this->argType) {
+            case Type::ID:
+                $type = Type::id();
+                break;
+            case Type::STRING:
+                $type = Type::string();
+                break;
+            case Type::BOOLEAN:
+                $type = Type::boolean();
+                break;
+            case Type::INT:
+                $type = Type::int();
+                break;
+            case Type::FLOAT:
+                $type = Type::float();
+                break;
+
+        }
+
+        if ($this->required) {
+            $type = Type::nonNull($type);
+        }
+
+        if (!$type) {
+            throw new InvalidArgumentException("Invalid GraphQL type: $this->argType");
+        }
+
+        return [
+            'type' => $type,
+            'defaultValue' => $this->defaultValue
+        ];
+    }
+}
\ No newline at end of file
diff --git a/tests/Fake/DataObjectFake.php b/tests/Fake/DataObjectFake.php
index b5db2e0a3..cd55b99ae 100644
--- a/tests/Fake/DataObjectFake.php
+++ b/tests/Fake/DataObjectFake.php
@@ -8,7 +8,16 @@
 class DataObjectFake extends DataObject implements TestOnly
 {
     private static $db = [
-        'MyField' => 'Varchar'
+        'MyField' => 'Varchar',
+        'MyInt' => 'Int'
+    ];
+
+    private static $has_one = [
+    	'Author' => 'SilverStripe\Security\Member'
+    ];
+
+    private static $many_many = [
+    	'Files' => 'SilverStripe\Assets\File'
     ];
 
     public $customSetterFieldResult;
diff --git a/tests/Fake/FakeResolver.php b/tests/Fake/FakeResolver.php
new file mode 100644
index 000000000..f0c7477fc
--- /dev/null
+++ b/tests/Fake/FakeResolver.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace SilverStripe\GraphQL\Tests\Fake;
+
+use SilverStripe\GraphQL\Scaffolding\ResolverInterface;
+
+class FakeResolver implements ResolverInterface
+{
+    public function resolve($object, $args, $context, $info)
+    {
+    	return 'resolved';
+    }
+
+}
\ No newline at end of file
diff --git a/tests/ScaffoldingTest.php b/tests/ScaffoldingTest.php
new file mode 100644
index 000000000..e8ff9dd24
--- /dev/null
+++ b/tests/ScaffoldingTest.php
@@ -0,0 +1,731 @@
+<?php
+
+namespace SilverStripe\GraphQL;
+
+use SilverStripe\Dev\SapphireTest;
+use GraphQL\Type\Definition\Type;
+use GraphQL\Type\Definition\NonNull;
+use GraphQL\Type\Definition\InputObjectType;
+use SilverStripe\GraphQL\Scaffolding\Creators\DataObjectTypeCreator;
+use SilverStripe\GraphQL\Manager;
+use GraphQL\Type\Definition\ResolveInfo;
+use GraphQL\Type\Definition\ObjectType;
+use GraphQL\Type\Definition\ListOfType;
+use GraphQL\Type\Definition\StringType;
+use GraphQL\Type\Definition\IntType;
+use SilverStripe\GraphQL\Tests\Fake\DataObjectFake;
+use SilverStripe\GraphQL\Scaffolding\Creators\MutationOperationCreator;
+use SilverStripe\GraphQL\Scaffolding\Creators\QueryOperationCreator;
+use SilverStripe\GraphQL\Tests\Fake\FakeResolver;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\MutationScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\OperationScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\DataObjectScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\QueryScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\CreateOperationScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\UpdateOperationScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\DeleteOperationScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\ReadOperationScaffolder;
+use Doctrine\Instantiator\Exception\InvalidArgumentException;
+use SilverStripe\GraphQL\Scaffolding\OperationList;
+use SilverStripe\Core\Config\Config;
+use SilverStripe\Security\Member;
+use SilverStripe\Assets\File;
+use ReflectionClass;
+use SilverStripe\GraphQL\Scaffolding\Util\ArgsParser;
+use SilverStripe\GraphQL\Scaffolding\Util\TypeParser;
+
+class ScaffoldingTest extends SapphireTest
+{
+
+    public function testDataObjectTypeCreator()
+    {
+        $creator = new DataObjectTypeCreator(new Manager, 'test', ['Foo' => 'Bar']);
+
+        $this->assertEquals(['name' => 'test'], $creator->attributes());
+        $this->assertEquals(['Foo' => 'Bar'], $creator->fields());
+
+        $fake = new DataObjectFake([
+            'MyField' => 'test'
+        ]);
+        $info = new ResolveInfo(['fieldName' => 'MyField']);
+
+        $result = $creator->resolveField($fake, [], null, $info);
+
+        $this->assertInstanceOf('SilverStripe\ORM\FieldType\DBVarchar', $result);
+        $this->assertEquals('test', $result->getValue());
+    }
+
+    public function testMutationOperationCreator()
+    {
+        $managerMock = $this->getMockBuilder(Manager::class)
+            ->setMethods(['getType'])
+            ->getMock();
+        $managerMock
+            ->method('getType')
+            ->will($this->returnArgument(0));
+
+        $mutationCreator = new MutationOperationCreator($managerMock, 'testOperation', 'testType');
+        $result = $mutationCreator->type();
+
+        $this->assertInstanceOf('\Closure', $result);
+        $this->assertEquals('testType', $result());
+
+    }
+
+    public function testQueryOperationCreator()
+    {
+        $managerMock = $this->getMockBuilder(Manager::class)
+            ->setMethods(['getType'])
+            ->getMock();
+        $managerMock
+            ->method('getType')
+            ->willReturn(new ObjectType(['name' => 'test']));
+
+        $mutationCreator = new QueryOperationCreator($managerMock, 'testOperation', 'testType');
+        $result = $mutationCreator->type();
+
+        $this->assertInstanceOf('\Closure', $result);
+        $this->assertInstanceOf(ListOfType::class, $result());
+        $this->assertInstanceOf(ObjectType::class, $result()->getWrappedType());
+        $this->assertEquals('test', $result()->getWrappedType()->config['name']);
+
+    }
+
+    public function testOperationCreatorConstuctor()
+    {
+        $mutationCreator = $this->createOperationCreator();
+        $this->assertEquals(['name' => 'testOperation'], $mutationCreator->attributes());
+        $this->assertEquals(['foo' => 'bar'], $mutationCreator->args());
+
+        $this->assertInstanceOf('\Closure', $mutationCreator->toArray()['resolve']);
+    }
+
+    public function testOperationCreatorAcceptsClosureAsResolver()
+    {
+        // test resolvers
+        $mutationCreator = $this->createOperationCreator(function () {
+            return 'abc';
+        });
+        $field = $mutationCreator->toArray();
+        $this->assertEquals('abc', $field['resolve'](null, [], null, null));
+    }
+
+    public function testOperationCreatorAcceptsResolverInterfaceInstanceAsResolver()
+    {
+        $mutationCreator = $this->createOperationCreator(new FakeResolver());
+        $field = $mutationCreator->toArray();
+        $this->assertEquals('resolved', $field['resolve'](null, [], null, null));
+    }
+
+    public function testExceptionThrownOnBadResolver()
+    {
+        $this->setExpectedException(\Exception::class);
+        $mutationCreator = $this->createOperationCreator(FakeResolver::class);
+        $field = $mutationCreator->toArray();
+        $field['resolve'](null, [], null, null);
+    }
+
+    public function testMutationOperationScaffolderCore()
+    {
+        $scaffolder = new MutationScaffolder(
+            'testOperation',
+            'testType'
+        );
+
+        $this->assertEquals('testOperation', $scaffolder->getName());
+
+        $creator = $scaffolder->getCreator(new Manager());
+        $this->assertInstanceOf(MutationOperationCreator::class, $creator);
+        $this->assertEquals(['name' => 'testOperation'], $creator->attributes());
+    }
+
+    public function testQueryOperationScaffolderCore()
+    {
+        $scaffolder = new QueryScaffolder(
+            'testOperation',
+            'testType'
+        );
+
+        $this->assertEquals('testOperation', $scaffolder->getName());
+
+        $creator = $scaffolder->getCreator(new Manager());
+        $this->assertInstanceOf(QueryOperationCreator::class, $creator);
+        $this->assertEquals(['name' => 'testOperation'], $creator->attributes());
+    }
+
+    public function testOperationScaffolderCreator()
+    {
+        $scaffolder = new MutationScaffolder(
+            'testOperation',
+            'testType'
+        );
+
+        $scaffolder->addArgs(['foo' => 'String']);
+        $creator = $scaffolder->getCreator(new Manager());
+        // only test the keys to isolate testing of ArgsParser
+        $this->assertEquals(['foo'], array_keys($creator->args()));
+        $scaffolder->addArgs(['qux' => 'Int']);
+        $creator = $scaffolder->getCreator(new Manager());
+        $this->assertEquals(['foo', 'qux'], array_keys($creator->args()));
+
+        $scaffolder->setResolver(function () {
+        });
+    }
+
+    public function testOperationScaffolderRejectsInvalidResolvers()
+    {
+        $this->setExpectedException(InvalidArgumentException::class);
+        $scaffolder = new MutationScaffolder(
+            'testOperation',
+            'testType',
+            'notAValidResover'
+        );
+    }
+
+    public function testOperationScaffolderAcceptsValidResolvers()
+    {
+        $m = new Manager();
+        $resolver = $this->getMockBuilder(FakeResolver::class)
+            ->setMethods(['resolve'])
+            ->getMock();
+        $resolver->expects($this->once())
+            ->method('resolve');
+
+
+        $scaffolder = new MutationScaffolder(
+            'testOperation',
+            'testType',
+            $resolver
+        );
+
+        $resolveMethod = $scaffolder->getCreator($m)->toArray()['resolve'];
+        $resolveMethod(null, null, null, null);
+
+        $scaffolder = new MutationScaffolder(
+            'testOperation',
+            'testType',
+            function () {
+            }
+        );
+
+        $this->assertInstanceOf('\Closure', $scaffolder->getCreator($m)->toArray()['resolve']);
+    }
+
+
+    public function testOperationScaffolderCreateFromConfig()
+    {
+        $exception = null;
+        $mockManager = $this->getMockBuilder(Manager::class)
+            ->setMethods(['getType'])
+            ->getMock();
+        $mockManager
+            ->expects($this->once())
+            ->method('getType')
+            ->willReturn('abc');
+
+        try {
+            MutationScaffolder::createFromConfig('test', []);
+        } catch (\Exception $e) {
+            $exception = $e;
+        }
+        $this->assertInstanceOf('\Exception', $e);
+
+        try {
+            MutationScaffolder::createFromConfig('test', [
+                'name' => 'testOperation',
+                'resolver' => 'not a resolver'
+            ]);
+        } catch (\Exception $e) {
+            $exception = $e;
+        }
+
+        $this->assertInstanceOf('\Exception', $e);
+
+        $result = MutationScaffolder::createFromConfig('test', [
+            'name' => 'testOperation',
+            'resolver' => FakeResolver::class
+        ]);
+
+        $this->assertInstanceOf(MutationScaffolder::class, $result);
+
+        $creator = $result->getCreator($mockManager);
+        $typeCreator = $creator->type();
+        $type = $typeCreator();
+        $this->assertEquals('abc', $type);
+    }
+
+    public function testDataObjectScaffolderConstructor()
+    {
+        $this->setExpectedException(InvalidArgumentException::class);
+        $scaffolder = new DataObjectScaffolder('Not\A\Real\Thing');
+    }
+
+    public function testDataObjectScaffolderQueriesAndMutations()
+    {
+        $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
+
+        $this->assertInstanceOf(OperationList::class, $scaffolder->getQueries());
+        $this->assertInstanceOf(OperationList::class, $scaffolder->getMutations());
+
+        $query = $scaffolder->query('test');
+
+        $this->assertInstanceOf(QueryScaffolder::class, $query);
+        $this->assertEquals('test', $query->getName());
+
+        $mutation = $scaffolder->mutation('test');
+
+        $this->assertInstanceOf(MutationScaffolder::class, $mutation);
+        $this->assertEquals('test', $mutation->getName());
+
+        $query2 = $scaffolder->query('test');
+        $this->assertEquals(1, $scaffolder->getQueries()->count());
+
+        $mutation2 = $scaffolder->mutation('test');
+        $this->assertEquals(1, $scaffolder->getMutations()->count());
+
+        $this->assertSame($query, $query2);
+        $this->assertSame($mutation, $mutation2);
+
+        $query3 = $scaffolder->query('abc');
+        $mutation3 = $scaffolder->mutation('abc');
+
+        $this->assertEquals(2, $scaffolder->getQueries()->count());
+        $this->assertEquals(2, $scaffolder->getMutations()->count());
+
+        $scaffolder->removeQuery('test');
+        $scaffolder->removeMutation('test');
+
+        $this->assertEquals(1, $scaffolder->getQueries()->count());
+        $this->assertEquals(1, $scaffolder->getMutations()->count());
+
+    }
+
+
+    public function testDataObjectScaffolderThrowsIfNotDataObject()
+    {
+        $this->setExpectedException(InvalidArgumentException::class);
+        $scaffolder = new DataObjectScaffolder(Config::class);
+    }
+
+    public function testStockOperations()
+    {
+        // Create
+        $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
+        $scaffolder->mutation(GraphQLScaffolder::CREATE);
+        $this->assertInstanceOf(CreateOperationScaffolder::class, $scaffolder->getMutations()->first());
+
+        // Read
+        $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
+        $scaffolder->query(GraphQLScaffolder::READ);
+        $this->assertInstanceOf(ReadOperationScaffolder::class, $scaffolder->getQueries()->first());
+
+        // Update
+        $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
+        $scaffolder->mutation(GraphQLScaffolder::UPDATE);
+        $this->assertInstanceOf(UpdateOperationScaffolder::class, $scaffolder->getMutations()->first());
+
+        // Delete
+        $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
+        $scaffolder->mutation(GraphQLScaffolder::DELETE);
+        $this->assertInstanceOf(DeleteOperationScaffolder::class, $scaffolder->getMutations()->first());
+
+
+    }
+
+    public function testDataObjectScaffolderFields()
+    {
+        $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
+        $scaffolder->addFields(['One', 'Two']);
+
+        $this->assertEquals(['One', 'Two'], $scaffolder->getFields()->toArray());
+
+        $scaffolder->addFields(['One', 'Two', 'Three']);
+
+        $this->assertCount(3, $scaffolder->getFields());
+        $this->assertEquals(['One', 'Two', 'Three'], $scaffolder->getFields()->toArray());
+
+        $scaffolder->removeField('Nothing');
+        $this->assertCount(3, $scaffolder->getFields());
+        $scaffolder->removeField('One');
+        $this->assertCount(2, $scaffolder->getFields());
+
+        $scaffolder->removeFields(['Two', 'Three']);
+        $this->assertCount(0, $scaffolder->getFields());
+    }
+
+    public function testDataObjectScaffolderUsesDefaultFields()
+    {
+    	Config::inst()->update(DataObjectScaffolder::class, 'default_fields', ['ID' => 'ID']);
+    	$scaffolder = new DataObjectScaffolder(DataObjectFake::class);
+    	$creator = $scaffolder->getCreator(new Manager());
+    	
+    	$this->assertEquals(
+    		['ID'],
+    		array_keys($creator->fields())
+    	);
+    }
+
+    public function testDataObjectTrait()
+    {
+        Config::inst()->update(DataObjectFake::class, 'table_name', 'Some\Namespaced\Table');
+        $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
+        $inst = $scaffolder->getDataObjectInstance();
+        $this->assertInstanceOf(DataObjectFake::class, $inst);
+
+        $this->assertEquals('Some_Namespaced_Table', $scaffolder->typeName());
+
+        $scaffolder->setDataObjectName('test');
+        $this->assertEquals('test', $scaffolder->getDataObjectName());
+    }
+
+    public function testDataObjectScaffolderCreator()
+    {
+        $scaffolder = (new DataObjectScaffolder(DataObjectFake::class))
+            ->addFields(['MyField', 'NonExistentField', 'Author', 'Files']);
+
+        $extraDataObjects = $scaffolder->getExtraDataObjects();
+        $this->assertArrayHasKey('Author', $extraDataObjects);
+        $this->assertArrayHasKey('Files', $extraDataObjects);
+
+        $this->assertEquals($extraDataObjects['Author'], 'SilverStripe\Security\Member');
+        $this->assertEquals($extraDataObjects['Files'], 'SilverStripe\Assets\File');
+
+        $creator = $scaffolder->getCreator(new Manager());
+
+        $this->assertEquals($scaffolder->typeName(), $creator->attributes()['name']);
+        $fields = array_keys($creator->fields());
+        $this->assertEquals(['MyField', 'NonExistentField', 'Author', 'Files'], $fields);
+    }
+
+
+    public function testDataObjectScaffolderAddToManager()
+    {
+        $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
+        $scaffolder->addFields(['MyField', 'NonExistentField', 'Author', 'Files']);
+        $scaffolder->mutation('myMutation', new FakeResolver());
+        $scaffolder->query('myQuery', new FakeResolver());
+
+        $managerMock = $this->getMockBuilder(Manager::class)
+            ->setMethods(['getType', 'addType', 'addQuery', 'addMutation'])
+            ->getMock();
+        $managerMock->expects($this->once())
+            ->method('addType')
+            ->with($scaffolder->typeName());
+        $managerMock->expects($this->once())
+            ->method('addMutation')
+            ->with(
+                $this->callback(function ($subject) {
+                    return (
+                        is_array($subject) && $subject['name'] == 'myMutation'
+                    );
+                }),
+                $this->equalTo('myMutation')
+            );
+
+        $managerMock->expects($this->once())
+            ->method('addQuery')
+            ->with(
+                $this->callback(function ($subject) {
+                    return (
+                        is_array($subject) && $subject['name'] == 'myQuery'
+                    );
+                }),
+                $this->equalTo('myQuery')
+            );
+
+        $scaffolder->addToManager($managerMock);
+    }
+
+    public function testGraphQLScaffolderAddToManager()
+    {
+        $resolver = new FakeResolver();
+        $scaffolder = new GraphQLScaffolder();
+        $scaffolder->dataObject(DataObjectFake::class)
+            ->addFields(['MyField', 'MyInt', 'Author', 'Files'])
+            ->mutation('testMutation', $resolver)
+            ->addArgs(['Test' => 'String']);
+        $scaffolder->dataObject(DataObjectFake::class)
+            ->query('testQuery', $resolver)
+            ->addArgs(['Test' => 'String']);
+        $scaffolder->dataObject(Member::class)
+            ->addFields(['Surname']);
+        $scaffolder->dataObject(File::class)
+            ->addFields(['Filename']);
+        $managerMock = $this->getMockBuilder(Manager::class)
+            ->setMethods(['addType', 'addQuery', 'addMutation'])
+            ->getMock();
+
+        $doTypeName = $scaffolder->dataObject(DataObjectFake::class)->typeName();
+        $memberTypeName = $scaffolder->dataObject(Member::class)->typeName();
+        $fileTypeName = $scaffolder->dataObject(File::class)->typeName();
+
+        $createFieldCheckCallback = function ($fields, $typeName) {
+            return function ($subject) use ($fields, $typeName) {
+                if ($subject instanceof ObjectType) {
+                    $fieldFunc = $subject->config['fields'];
+                    $typeFields = $fieldFunc();
+                    return (
+                        ($subject->config['name'] == $typeName) &&
+                        (array_keys($typeFields) == $fields)
+                    );
+                }
+
+                return false;
+            };
+        };
+
+        $managerMock->expects($this->exactly(3))
+            ->method('addType')
+            ->withConsecutive(
+                [
+                    $this->callback($createFieldCheckCallback(
+                        ['MyField', 'MyInt', 'Author', 'Files'],
+                        $doTypeName
+                    )),
+                    $doTypeName
+                ],
+                [
+                    $this->callback($createFieldCheckCallback(['Surname'], $memberTypeName)),
+                    $memberTypeName
+                ],
+                [
+                    $this->callback($createFieldCheckCallback(['Filename'], $fileTypeName)),
+                    $fileTypeName
+                ]
+
+            );
+
+        $managerMock->expects($this->once())
+            ->method('addQuery')
+            ->with($this->callback(function ($subject) {
+                return is_array($subject) &&
+                $subject['name'] == 'testQuery' &&
+                array_keys($subject['args']) == ['Test'];
+            }));
+
+        $managerMock->expects($this->once())
+            ->method('addMutation')
+            ->with($this->callback(function ($subject) {
+                return is_array($subject) &&
+                $subject['name'] == 'testMutation' &&
+                array_keys($subject['args']) == ['Test'];
+            }));
+
+        $scaffolder->addToManager($managerMock);
+    }
+
+    public function testGraphQLScaffolderCreateFromConfig()
+    {
+        $scaffolder = GraphQLScaffolder::createFromConfig([
+            DataObjectFake::class => [
+                'fields' => [
+                    'MyField',
+                    'MyInt',
+                    'Author',
+                    'Files'
+                ],
+                'operations' => ['CREATE', 'READ', 'UPDATE', 'DELETE']
+            ],
+
+            Member::class => [
+                'fields' => ['Surname'],
+                'operations' => 'all',
+                'queries' => [
+                    'myQuery' => [
+                        'args' => [
+                            'Test' => 'String'
+                        ],
+                        'resolver' => FakeResolver::class
+                    ]
+                ]
+            ],
+
+            File::class => [
+                'fields' => ['Surname'],
+                'mutations' => [
+                    'myMutation' => [
+                        'args' => [
+                            'Test' => 'String'
+                        ],
+                        'resolver' => FakeResolver::class
+                    ]
+                ]
+            ]
+        ]);
+
+        $reflection = new ReflectionClass($scaffolder);
+        $property = $reflection->getProperty('scaffolds');
+        $property->setAccessible(true);
+        $scaffolds = $property->getValue($scaffolder);
+
+        $dataObjectClasses = [
+            DataObjectFake::class => true,
+            Member::class => true,
+            File::class => true
+        ];
+
+        foreach ($scaffolds as $scaffold) {
+            $name = $scaffold->getDataObjectName();
+            $typeName = ucfirst($scaffold->typeName());
+            $pluralTypeName = $scaffold->getDataObjectInstance()->plural_name();
+            $pluralTypeName = str_replace(' ', '', $pluralTypeName);
+            $pluralTypeName = ucfirst($pluralTypeName);
+
+            $this->assertArrayHasKey($name, $dataObjectClasses);
+            unset($dataObjectClasses[$name]);
+            
+            if (in_array($name, [DataObjectFake::class, Member::class])) {
+                $this->assertInstanceOf(
+                    CreateOperationScaffolder::class,
+                    $scaffold->getMutations()->findByName('create' . $typeName)
+                );
+                $this->assertInstanceOf(
+                    UpdateOperationScaffolder::class,
+                    $scaffold->getMutations()->findByName('update' . $typeName)
+                );
+                $this->assertInstanceOf(
+                    DeleteOperationScaffolder::class,
+                    $scaffold->getMutations()->findByName('delete' . $typeName)
+                );
+                $this->assertInstanceOf(
+                    ReadOperationScaffolder::class,
+                    $scaffold->getQueries()->findByName('read' . $pluralTypeName)
+                );
+                if ($name == Member::class) {
+                    $op = $scaffold->getQueries()->findByName('myQuery');
+                    $this->assertInstanceOf(
+                        QueryScaffolder::class,
+                        $op
+                    );
+                    $this->assertArrayHasKey('Test', $op->getCreator(new Manager())->args());
+                }
+
+            } else {
+                if ($name == File::class) {
+                    $op = $scaffold->getMutations()->findByName('myMutation');
+                    $this->assertInstanceOf(
+                        MutationScaffolder::class,
+                        $op
+                    );
+                    $this->assertArrayHasKey('Test', $op->getCreator(new Manager())->args());
+                }
+            }
+        }
+    }
+
+    public function testInputTypesAreCreated()
+    {
+        $create = (new CreateOperationScaffolder(DataObjectFake::class))
+            ->addArgs(['Test' => 'String']);
+        $creator = $create->getCreator(new Manager());
+
+        $this->assertArrayHasKey('Input', $creator->args());
+        $type = $creator->args()['Input']['type'];
+        $this->assertInstanceOf(NonNull::class, $type);
+        $this->assertInstanceOf(InputObjectType::class, $type->getWrappedType());
+
+        $create = (new UpdateOperationScaffolder(DataObjectFake::class))
+            ->addArgs(['Test' => 'String']);
+        $creator = $create->getCreator(new Manager());
+
+        $this->assertArrayHasKey('Input', $creator->args());
+        $this->assertArrayHasKey('ID', $creator->args());
+        $type = $creator->args()['Input']['type'];
+        $this->assertInstanceOf(NonNull::class, $type);
+        $this->assertInstanceOf(InputObjectType::class, $type->getWrappedType());
+    }
+
+    public function testTypeParser()
+    {
+        $parser = new TypeParser('String!=Test');
+        $this->assertTrue($parser->isRequired());
+        $this->assertEquals('String', $parser->getArgTypeName());
+        $this->assertEquals('Test', $parser->getDefaultValue());
+
+        $parser = new TypeParser('String! = Test');
+        $this->assertTrue($parser->isRequired());
+        $this->assertEquals('String', $parser->getArgTypeName());
+        $this->assertEquals('Test', $parser->getDefaultValue());
+
+        $parser = new TypeParser('Int!');
+        $this->assertTrue($parser->isRequired());
+        $this->assertEquals('Int', $parser->getArgTypeName());
+        $this->assertNull($parser->getDefaultValue());
+
+        $parser = new TypeParser('Boolean');
+        $this->assertFalse($parser->isRequired());
+        $this->assertEquals('Boolean', $parser->getArgTypeName());
+        $this->assertNull($parser->getDefaultValue());
+
+        $parser = new TypeParser('String!=Test');
+        $arr = $parser->toArray();
+        $this->assertInstanceOf(NonNull::class, $arr['type']);
+        $this->assertInstanceOf(StringType::class, $arr['type']->getWrappedType());
+        $this->assertEquals('Test', $arr['defaultValue']);
+
+        $this->setExpectedException(InvalidArgumentException::class);
+        $parser = new TypeParser('  ... Nothing');
+
+        $this->setExpectedException(InvalidArgumentException::class);
+        $parser = (new TypeParser('Nothing'))->toArray();
+    }
+
+    public function testArgsParser()
+    {
+        $parsers = [
+            new ArgsParser([
+                'Test' => 'String'
+            ]),
+            new ArgsParser([
+                'Test' => Type::string()
+            ]),
+            new ArgsParser([
+                'Test' => ['type' => Type::string()]
+            ])
+        ];
+
+        foreach ($parsers as $parser) {
+            $arr = $parser->toArray();
+            $this->assertArrayHasKey('Test', $arr);
+            $this->assertArrayHasKey('type', $arr['Test']);
+            $this->assertInstanceOf(StringType::class, $arr['Test']['type']);
+        }
+    }
+
+
+    public function testOperationList()
+    {
+        $list = new OperationList();
+
+        $list->push(new MutationScaffolder('myMutation1', 'test1'));
+        $list->push(new MutationScaffolder('myMutation2', 'test2'));
+
+        $this->assertInstanceOf(
+            MutationScaffolder::class,
+            $list->findByName('myMutation1')
+        );
+        $this->assertFalse($list->findByName('myMutation3'));
+
+        $list->removeByName('myMutation2');
+        $this->assertEquals(1, $list->count());
+
+        $list->removeByName('nothing');
+        $this->assertEquals(1, $list->count());
+
+        $this->setExpectedException(InvalidArgumentException::class);
+        $list->push(new OperationList());
+    }
+
+    protected function createOperationCreator($resolver = null)
+    {
+        return new MutationOperationCreator(
+            new Manager(),
+            'testOperation',
+            'testType',
+            $resolver,
+            ['foo' => 'bar']
+        );
+    }
+
+}

From ab441752b32e10467b9c9f71982ad30864ef01dd Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 15 Dec 2016 14:15:38 +1300
Subject: [PATCH 02/66] Fix phpunit.xml syntax

---
 phpunit.xml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/phpunit.xml b/phpunit.xml
index de3b0b486..3c874054f 100644
--- a/phpunit.xml
+++ b/phpunit.xml
@@ -8,7 +8,6 @@
     processIsolation="false"
     stopOnFailure="false"
     syntaxCheck="false"
-    colors="true">
     >
     <testsuites>
         <testsuite>

From 3b73495bf7dd85930cf7e614d66415c9bb26e272 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 15 Dec 2016 14:15:56 +1300
Subject: [PATCH 03/66] README updates for scaffolding docs

---
 README.md | 146 ++++++++++++++++++++++++++++++++----------------------
 1 file changed, 87 insertions(+), 59 deletions(-)

diff --git a/README.md b/README.md
index f8669440c..06162aa5c 100644
--- a/README.md
+++ b/README.md
@@ -494,7 +494,12 @@ property of the created member.
 
 ## Scaffolding DataObjects into the Schema
 
-Making a DataObject accessible through the GraphQL API involves quite a bit of boilerplate. In the above example, we can see that creating endpoints for a query and a mutation requires creating three new classes, along with an update to the configuration, and we haven't even dealt with data relations yet. For applications that require a lot of business logic and specific functionality, an architecture like this affords the developer a lot of control, but for developers who just want to make a given model accessible through GraphQL with some basic Create, Read, Update, and Delete operations, scaffolding them can save a lot of time and reduce the clutter in your project.
+Making a DataObject accessible through the GraphQL API involves quite a bit of boilerplate. In the above example, we can 
+see that creating endpoints for a query and a mutation requires creating three new classes, along with an update to the 
+configuration, and we haven't even dealt with data relations yet. For applications that require a lot of business logic 
+and specific functionality, an architecture like this affords the developer a lot of control, but for developers who 
+just want to make a given model accessible through GraphQL with some basic create, cead, update, and delete operations, 
+scaffolding them can save a lot of time and reduce the clutter in your project.
 
 Scaffolding DataObjects can be achieved in two non-exclusive ways:
 
@@ -527,9 +532,26 @@ class Post extends DataObject {
 }
 ```
 
+### Scaffolding DataObjects through the Config layer
+
+Many of the declarations you make through procedural code can be done via YAML. If you don't have any logic in your 
+scaffolding, using YAML is a simple approach to adding scaffolding.
+
+We'll need to define a `scaffolding` node in the `SilverStripe\GraphQL.schema` setting.
+
+```yaml
+SilverStripe\GraphQL:
+  schema:
+    scaffolding:
+      ## scaffolding will go here
+
+```
+
 ### Scaffolding DataObjects through procedural code
 
-The GraphQL `Manager` class will bootstrap itself with any scaffolders that are registered in its config. These scaffolders must implement the `ScaffoldingProvider` interface. A logical place to add this code may be in your DataObject, but it could be anywhere.
+Alternatively, for more complex requirements, you can create the scaffolding with code. The GraphQL `Manager` class will 
+bootstrap itself with any scaffolders that are registered in its config. These scaffolders must implement the 
+`ScaffoldingProvider` interface. A logical place to add this code may be in your DataObject, but it could be anywhere.
 
 As a `ScaffoldingProvider`, the class must now offer the `provideGraphQLScaffolding()` method.
 
@@ -556,60 +578,19 @@ SilverStripe\GraphQL:
       - My\Project\Post
 ```
 
-### Scaffolding DataObjects through the Config layer
-
-Many of the declarations you make through procedural code can be done via YAML. If you don't have any logic in your scaffolding, using the YAML approach may make more sense.
-
-We'll need to define a `scaffolding` node in the `SilverStripe\GraphQL.schema` setting.
-
-```yaml
-SilverStripe\GraphQL:
-  schema:
-    scaffolding:
-      ## scaffolding goes here
-
-```
 
 ### Exposing a DataObject to GraphQL
 
-Let's now expose the `Post` type. We'll choose the fields we want to offer, along with a simple query and mutation.
-
-**Code**:
-```php
-class Post extends DataObject implements ScaffoldingProvider {
-	//...
-    public function provideGraphQLScaffolding(GraphQLScaffolder $scaffolder)
-    {
-    	$scaffolder->dataObject(Post::class)
-    		->addFields(['ID','Title','Content'])
-    		->query('readPosts', function() {
-    			return Post::get()->limit(10);
-    		});
-    	$scaffolder->dataObject(Post::class)
-    		->mutation('updatePostTitle')
-    		->addArgs([
-    			'ID' => 'ID!',
-    			'NewTitle' => 'String!'
-    		])
-    		->setResolver(function($obj, $args) {
-    			$post = Post::get()->byID($args['ID']);
-    			$post->Title = $args['NewTitle'];
-    			$post->write();
-
-    			return $post;
-    		});
-
-    	return $scaffolder;
-	}
-}
-```
+Let's now expose the `Post` type. We'll choose the fields we want to offer, along with a simple query and mutation. To
+resolve queries and mutations, we'll need to specify the name of a resolver class. This class
+must implement the `SilverStripe\GraphQL\Scaffolding\ResolverInterface`. (More on this below).
 
 **YAML**:
 ```
 SilverStripe\GraphQL:
   schema:
     scaffolding_providers:
-      - MyFamily\Model\Post
+      - My\Project\Post
     scaffolding:
       My\Project\Post:
         fields: [ID, Title, Content]
@@ -642,9 +623,48 @@ mutation UpdatePostTitle($ID: ID!, $NewTitle: String!) {
 }
 ```
 
+**Code**:
+```php
+namespace My\Project;
+
+class Post extends DataObject implements ScaffoldingProvider {
+	//...
+    public function provideGraphQLScaffolding(GraphQLScaffolder $scaffolder)
+    {
+    	$scaffolder->dataObject(Post::class)
+    		->addFields(['ID','Title','Content'])
+    		->query('readPosts', function() {
+    			if(Injector::inst()->get('Post')->canView()) {
+    				return Post::get()->limit(10);
+    			}
+    		});
+    	$scaffolder->dataObject(Post::class)
+    		->mutation('updatePostTitle')
+    		->addArgs([
+    			'ID' => 'ID!',
+    			'NewTitle' => 'String!'
+    		])
+    		->setResolver(function($obj, $args) {
+    			$post = Post::get()->byID($args['ID']);
+    			if($post->canEdit()) {
+	    			$post->Title = $args['NewTitle'];
+	    			$post->write();
+    			}
+
+    			return $post;
+    		});
+
+    	return $scaffolder;
+	}
+}
+```
+
+
 #### Using a custom resolver
 
-The simplest way to add a resolver is via an anonymous function, passed as the optional second parameter to `mutation()` or `query()`, or via the `setResolver()` method. Resolvers may also exist in class definitions that implement the `ResolverInterface`.
+The simplest way to add a resolver is via an anonymous function, passed as the optional second parameter to `mutation()` 
+or `query()`, or via the `setResolver()` method. Resolvers may also exist in class definitions that implement the 
+`ResolverInterface`.
 
 **When using the YAML approach, custom resolver classes are compulsory**, since you can't define closures in YAML.
 
@@ -697,7 +717,9 @@ SilverStripe\GraphQL:
         fields: [ID, Title, Content, Author, Files]
 ```
 
-Relations are treated just like fields, and the new types are automatically detected, and added to the schema. By default, these new types offer only `ID` as an exposed field (a configuration setting), so we'll probably want to customise that a bit. 
+Relations are treated just like fields, and the new types are automatically detected, and added to the schema. By 
+default, these new types offer only `ID` as an exposed field (a configuration setting), so we'll probably want to 
+customise that a bit. 
 
 **Code**:
 ```php
@@ -705,11 +727,11 @@ Relations are treated just like fields, and the new types are automatically dete
 		->addFields(['ID','Title','Content','Author','Files'])
 		//...
 	$scaffolder->dataObject(Member::class)
-		->addFields(['Name','Email','Groups']); // creates new type "Group"
+		->addFields(['ID','Name','Email','Groups']); // creates new type "Group"
 	$scaffolder->dataObject(File::class)
-		->addFields(['Filename']);
+		->addFields(['ID','Filename']);
 	$scaffolder->dataObject(Group::class)
-		->addFields(['Title']);
+		->addFields(['ID','Title']);
 ```
 
 **YAML**:
@@ -724,17 +746,20 @@ SilverStripe\GraphQL:
         mutations:
           # ...        
       SilverStripe\Security\Member:
-        fields: [Name, Email, Groups]
+        fields: [ID, Name, Email, Groups]
       SilverStripe\Assets\File:
-        fields: [Filename]
+        fields: [ID, Filename]
       SilverStripe\Security\Group:
-        fields: [Title]
+        fields: [ID, Title]
 
 ```
 
-None of these new types have queries or mutations associated with them, but we can now access them as data related to our `Post` object.
+None of these new types have queries or mutations associated with them, but we can now access them as data related to 
+our `Post` object.
 
-Notice that we're able to use the computational method 'Name', which resolves to 'getName()' on the Member object. Fields are not necessarily one-to-one with `$db`. They are simply any public method on the DataObject that returns a `DataList`, `DataObject`, or `DBField`.
+Notice that we're able to use the computated value 'Name', which resolves to 'getName()' on the Member object. 
+Fields are not necessarily one-to-one with `$db`. They are simply any public method on the DataObject that returns a 
+`DataList`, `DataObject`, or `DBField`.
 
 ```
 query {
@@ -756,9 +781,12 @@ query {
 
 ### Ready-made CRUD operations
 
-Even with the fluency of scaffolding, many of these operations may look the same, and the resolver functions may start to get repetitive with each simple read, create, edit, delete operation we offer. For basic CRUD definitions, you can use the operations that come bundled with the scaffolder and save a lot configuration effort.
+Even with the fluency of scaffolding, many of these operations may look the same, and the resolver functions may start 
+to get repetitive with each simple read, create, edit, delete operation we offer. For basic CRUD definitions, you can 
+use the operations that come bundled with the scaffolder and save a lot configuration effort.
 
-These ready-made operations will automatically generate input types and add them to your schema. They offer very basic functionality that checks for permission and performs a simple CRUD operation on your DataObject.
+These ready-made operations will automatically generate input types and add them to your schema. They offer very basic 
+functionality that checks for permission and performs a simple CRUD operation on your DataObject.
 
 
 **Code:**

From 81e080992aabf783e6e680ef8e09e94e0b98b9be Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 15 Dec 2016 14:18:19 +1300
Subject: [PATCH 04/66] Remove @package declarations

---
 src/Scaffolding/Creators/DataObjectTypeCreator.php        | 2 --
 src/Scaffolding/Creators/MutationOperationCreator.php     | 1 -
 src/Scaffolding/Creators/OperationCreatorTrait.php        | 1 -
 src/Scaffolding/Creators/QueryOperationCreator.php        | 1 -
 src/Scaffolding/DataObjectTypeTrait.php                   | 2 --
 src/Scaffolding/OperationList.php                         | 1 -
 src/Scaffolding/ResolverInterface.php                     | 2 --
 src/Scaffolding/Scaffolders/CreateOperationScaffolder.php | 1 -
 src/Scaffolding/Scaffolders/DataObjectScaffolder.php      | 2 +-
 src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php | 1 -
 src/Scaffolding/Scaffolders/GraphQLScaffolder.php         | 2 --
 src/Scaffolding/Scaffolders/ManagerMutatorInterface.php   | 1 -
 src/Scaffolding/Scaffolders/OperationScaffolder.php       | 4 ++--
 src/Scaffolding/Scaffolders/QueryScaffolder.php           | 1 -
 src/Scaffolding/Scaffolders/ReadOperationScaffolder.php   | 1 -
 src/Scaffolding/Scaffolders/ScaffolderInterface.php       | 1 -
 src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php | 1 -
 src/Scaffolding/ScaffoldingProvider.php                   | 1 -
 src/Scaffolding/Util/ArgsParser.php                       | 1 -
 src/Scaffolding/Util/TypeParser.php                       | 1 -
 20 files changed, 3 insertions(+), 25 deletions(-)

diff --git a/src/Scaffolding/Creators/DataObjectTypeCreator.php b/src/Scaffolding/Creators/DataObjectTypeCreator.php
index 6f03a83b5..93dbbbc58 100644
--- a/src/Scaffolding/Creators/DataObjectTypeCreator.php
+++ b/src/Scaffolding/Creators/DataObjectTypeCreator.php
@@ -9,8 +9,6 @@
 
 /**
  * Creates a GraphQL type for a DataObject
- * @package SilverStripe\GraphQL\Scaffolding\Creators
- * @author Uncle Cheese <unclecheese@leftandmain.com>
  */
 class DataObjectTypeCreator extends TypeCreator
 {
diff --git a/src/Scaffolding/Creators/MutationOperationCreator.php b/src/Scaffolding/Creators/MutationOperationCreator.php
index d895f1be5..bcd54a5a0 100644
--- a/src/Scaffolding/Creators/MutationOperationCreator.php
+++ b/src/Scaffolding/Creators/MutationOperationCreator.php
@@ -6,7 +6,6 @@
 
 /**
  * Creates a GraphQL mutation field
- * @package SilverStripe\GraphQL\Scaffolding\Operations
  */
 class MutationOperationCreator extends MutationCreator
 {
diff --git a/src/Scaffolding/Creators/OperationCreatorTrait.php b/src/Scaffolding/Creators/OperationCreatorTrait.php
index cb94c1160..edd518c72 100644
--- a/src/Scaffolding/Creators/OperationCreatorTrait.php
+++ b/src/Scaffolding/Creators/OperationCreatorTrait.php
@@ -7,7 +7,6 @@
 
 /**
  * Injects Operation creator features into mutations and queries, which are different inheritance chains
- * @package SilverStripe\GraphQL\Scaffolding\Operations
  */
 trait OperationCreatorTrait
 {
diff --git a/src/Scaffolding/Creators/QueryOperationCreator.php b/src/Scaffolding/Creators/QueryOperationCreator.php
index 1bc2ffe9e..9413604a8 100644
--- a/src/Scaffolding/Creators/QueryOperationCreator.php
+++ b/src/Scaffolding/Creators/QueryOperationCreator.php
@@ -8,7 +8,6 @@
 
 /**
  * Creates a GraphQL query field
- * @package SilverStripe\GraphQL\Scaffolding\Operations
  */
 class QueryOperationCreator extends QueryCreator
 {
diff --git a/src/Scaffolding/DataObjectTypeTrait.php b/src/Scaffolding/DataObjectTypeTrait.php
index 7a0f8c411..a1c97a907 100644
--- a/src/Scaffolding/DataObjectTypeTrait.php
+++ b/src/Scaffolding/DataObjectTypeTrait.php
@@ -7,8 +7,6 @@
 
 /**
  * Offers a few helper methods for classes that are DataObject subclass bound.
- *
- * @package SilverStripe\GraphQL\Scaffolding
  */
 trait DataObjectTypeTrait
 {
diff --git a/src/Scaffolding/OperationList.php b/src/Scaffolding/OperationList.php
index cadff2ee1..0eb02bd06 100644
--- a/src/Scaffolding/OperationList.php
+++ b/src/Scaffolding/OperationList.php
@@ -8,7 +8,6 @@
 
 /**
  * An array list designed to work with OperationScaffolders
- * @package SilverStripe\GraphQL\Scaffolding
  */
 class OperationList extends ArrayList
 {
diff --git a/src/Scaffolding/ResolverInterface.php b/src/Scaffolding/ResolverInterface.php
index a3fab7f2a..32136b5f6 100644
--- a/src/Scaffolding/ResolverInterface.php
+++ b/src/Scaffolding/ResolverInterface.php
@@ -4,8 +4,6 @@
 
 /**
  * Applied to classes that resolve queries or mutations
- * 
- * @package SilverStripe\GraphQL\Scaffolding\Resolvers
  */
 interface ResolverInterface
 {
diff --git a/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php b/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php
index 8cf4f337a..a843c879b 100644
--- a/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php
@@ -11,7 +11,6 @@
 
 /**
  * A generic "create" operation for a DataObject
- * @package SilverStripe\GraphQL\Scaffolding\Scaffolders
  */
 class CreateOperationScaffolder extends MutationScaffolder
 {
diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
index 5149af83e..c48d796c5 100644
--- a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -14,9 +14,9 @@
 use SilverStripe\GraphQL\Scaffolding\Creators\DataObjectTypeCreator;
 use SilverStripe\GraphQL\Scaffolding\DataObjectTypeTrait;
 use SilverStripe\Core\Config\Config;
+
 /**
  * Scaffolds a DataObjectTypeCreator
- * @package SilverStripe\GraphQL\Scaffolding
  */
 class DataObjectScaffolder implements ManagerMutatorInterface, ScaffolderInterface
 {
diff --git a/src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php b/src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php
index b17bff0d0..05bffc835 100644
--- a/src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php
@@ -8,7 +8,6 @@
 
 /**
  * A generic delete operation
- * @package SilverStripe\GraphQL\Scaffolding\Scaffolders
  */
 class DeleteOperationScaffolder extends MutationScaffolder
 {
diff --git a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
index c6aced463..9036986a2 100644
--- a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
+++ b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
@@ -11,8 +11,6 @@
 /**
  * The entry point for a GraphQL scaffolding definition. Holds DataObject type definitions,
  * and their nested Mutation/Query definitions.
- *
- * @package SilverStripe\GraphQL\Scaffolding
  */
 class GraphQLScaffolder implements ManagerMutatorInterface
 {
diff --git a/src/Scaffolding/Scaffolders/ManagerMutatorInterface.php b/src/Scaffolding/Scaffolders/ManagerMutatorInterface.php
index 8e2187b5c..6fb4d76d9 100644
--- a/src/Scaffolding/Scaffolders/ManagerMutatorInterface.php
+++ b/src/Scaffolding/Scaffolders/ManagerMutatorInterface.php
@@ -6,7 +6,6 @@
 
 /**
  * Defines a class that updates the Manager
- * @package SilverStripe\GraphQL\Scaffolding
  */
 interface ManagerMutatorInterface
 {
diff --git a/src/Scaffolding/Scaffolders/OperationScaffolder.php b/src/Scaffolding/Scaffolders/OperationScaffolder.php
index f8a68cfac..d3434badf 100644
--- a/src/Scaffolding/Scaffolders/OperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/OperationScaffolder.php
@@ -8,8 +8,8 @@
 use SilverStripe\Core\Injector\Injector;
 
 /**
- * Trait Operation
- * @package SilverStripe\GraphQL\Scaffolding\Operations
+ * Provides functionality common to both operation scaffolders. Cannot
+ * be a subclass due to their distinct inheritance chains
  */
 abstract class OperationScaffolder
 {
diff --git a/src/Scaffolding/Scaffolders/QueryScaffolder.php b/src/Scaffolding/Scaffolders/QueryScaffolder.php
index a045b1741..0f1cb6fbb 100644
--- a/src/Scaffolding/Scaffolders/QueryScaffolder.php
+++ b/src/Scaffolding/Scaffolders/QueryScaffolder.php
@@ -7,7 +7,6 @@
 
 /**
  * Scaffolds a GraphQL query field
- * @package SilverStripe\GraphQL\Scaffolding\Scaffolders
  */
 class QueryScaffolder extends OperationScaffolder implements ManagerMutatorInterface, ScaffolderInterface
 {
diff --git a/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php b/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php
index 31d6d88d2..a67aed4f4 100644
--- a/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php
@@ -8,7 +8,6 @@
 
 /**
  * Scaffolds a generic read operation for DataObjects
- * @package SilverStripe\GraphQL\Scaffolding\Scaffolders
  */
 class ReadOperationScaffolder extends QueryScaffolder
 {
diff --git a/src/Scaffolding/Scaffolders/ScaffolderInterface.php b/src/Scaffolding/Scaffolders/ScaffolderInterface.php
index c75c1f65c..937138169 100644
--- a/src/Scaffolding/Scaffolders/ScaffolderInterface.php
+++ b/src/Scaffolding/Scaffolders/ScaffolderInterface.php
@@ -6,7 +6,6 @@
 
 /**
  * Defines a class that transforms into a type or field creator
- * @package SilverStripe\GraphQL\Scaffolding\Scaffolders
  */
 interface ScaffolderInterface
 {
diff --git a/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php b/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php
index 1ff1703e4..705d3f02e 100644
--- a/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php
@@ -13,7 +13,6 @@
 
 /**
  * Scaffolds a generic update operation for DataObjects
- * @package SilverStripe\GraphQL\Scaffolding\Scaffolders
  */
 class UpdateOperationScaffolder extends MutationScaffolder
 {
diff --git a/src/Scaffolding/ScaffoldingProvider.php b/src/Scaffolding/ScaffoldingProvider.php
index d0dd96f80..1a4923b26 100644
--- a/src/Scaffolding/ScaffoldingProvider.php
+++ b/src/Scaffolding/ScaffoldingProvider.php
@@ -6,7 +6,6 @@
 
 /**
  * Use on classes that update the GraphQL scaffolder
- * @package SilverStripe\GraphQL\Scaffolding
  */
 interface ScaffoldingProvider
 {
diff --git a/src/Scaffolding/Util/ArgsParser.php b/src/Scaffolding/Util/ArgsParser.php
index fa2f3459a..afca6765e 100644
--- a/src/Scaffolding/Util/ArgsParser.php
+++ b/src/Scaffolding/Util/ArgsParser.php
@@ -7,7 +7,6 @@
 
 /**
  * Parses an array of args into the proper graphql-php spec, using first-class type objects in lieu of strings
- * @package SilverStripe\GraphQL\Scaffolding\Util
  */
 class ArgsParser
 {
diff --git a/src/Scaffolding/Util/TypeParser.php b/src/Scaffolding/Util/TypeParser.php
index 51547d851..c0dd98f2a 100644
--- a/src/Scaffolding/Util/TypeParser.php
+++ b/src/Scaffolding/Util/TypeParser.php
@@ -7,7 +7,6 @@
 
 /**
  * Parses a type, e.g. String!=20 into an array defining the arg type
- * @package SilverStripe\GraphQL\Scaffolding\Util
  */
 class TypeParser
 {

From 51c0781ef04d82266a78a5580b251cacb819563b Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 15 Dec 2016 14:21:51 +1300
Subject: [PATCH 05/66] Change $dataObjectName to $dataObjectClass

---
 src/Scaffolding/DataObjectTypeTrait.php         | 17 +++++++----------
 .../Scaffolders/CreateOperationScaffolder.php   |  6 +++---
 .../Scaffolders/DataObjectScaffolder.php        | 16 ++++++++--------
 .../Scaffolders/DeleteOperationScaffolder.php   |  9 +++------
 .../Scaffolders/GraphQLScaffolder.php           | 16 ++++++++--------
 .../Scaffolders/ReadOperationScaffolder.php     |  6 +++---
 .../Scaffolders/UpdateOperationScaffolder.php   |  6 +++---
 tests/ScaffoldingTest.php                       |  6 +++---
 8 files changed, 38 insertions(+), 44 deletions(-)

diff --git a/src/Scaffolding/DataObjectTypeTrait.php b/src/Scaffolding/DataObjectTypeTrait.php
index a1c97a907..af2700db1 100644
--- a/src/Scaffolding/DataObjectTypeTrait.php
+++ b/src/Scaffolding/DataObjectTypeTrait.php
@@ -13,7 +13,7 @@ trait DataObjectTypeTrait
     /**
      * @var string
      */
-    protected $dataObjectName;
+    protected $dataObjectClass;
 
     /**
      * @var string
@@ -28,9 +28,9 @@ trait DataObjectTypeTrait
     /**
      * @return string
      */
-    public function getDataObjectName()
+    public function getDataObjectClass()
     {
-        return $this->dataObjectName;
+        return $this->dataObjectClass;
     }
 
     /**
@@ -38,10 +38,7 @@ public function getDataObjectName()
      */
     public function typeName()
     {
-        /* Type names must be unique and predictable. Cannot allow customisation. */
-        //return $this->dataObjectTypeName ?: $this->getDataObjectInstance()->singular_name();
-
-        return $this->typeNameForDataObject($this->dataObjectName);
+        return $this->typeNameForDataObject($this->dataObjectClass);
     }
 
     /**
@@ -53,7 +50,7 @@ public function getDataObjectInstance()
             return $this->dataObjectInstance;
         }
 
-        return $this->dataObjectInstance = Injector::inst()->get($this->dataObjectName);
+        return $this->dataObjectInstance = Injector::inst()->get($this->dataObjectClass);
     }
 
     /**
@@ -61,9 +58,9 @@ public function getDataObjectInstance()
      * @param string $name
      * @return  $this
      */
-    public function setDataObjectName($name)
+    public function setDataObjectClass($class)
     {
-        $this->dataObjectName = $name;
+        $this->dataObjectClass = $class;
 
         return $this;
     }
diff --git a/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php b/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php
index a843c879b..cf219e235 100644
--- a/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php
@@ -19,11 +19,11 @@ class CreateOperationScaffolder extends MutationScaffolder
 
     /**
      * CreateOperationScaffolder constructor.
-     * @param null $dataObjectName
+     * @param string $dataObjectClass
      */
-    public function __construct($dataObjectName)
+    public function __construct($dataObjectClass)
     {
-        $this->dataObjectName = $dataObjectName;
+        $this->dataObjectClass = $dataObjectClass;
 
         parent::__construct(
             'create' . ucfirst($this->typeName()),
diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
index c48d796c5..4fe3ccbcc 100644
--- a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -39,18 +39,18 @@ class DataObjectScaffolder implements ManagerMutatorInterface, ScaffolderInterfa
 
     /**
      * DataObjectScaffold constructor.
-     * @param $dataObjectName
+     * @param string $dataObjectClass
      */
-    public function __construct($dataObjectName)
+    public function __construct($dataObjectClass)
     {
-        if (!class_exists($dataObjectName)) {
+        if (!class_exists($dataObjectClass)) {
             throw new InvalidArgumentException(sprintf(
                 'DataObjectScaffold instantiated with non-existent classname "%s"',
-                $dataObjectName
+                $dataObjectClass
             ));
         }
 
-        if (!is_subclass_of($dataObjectName, DataObject::class)) {
+        if (!is_subclass_of($dataObjectClass, DataObject::class)) {
             throw new InvalidArgumentException(sprintf(
                 'DataObjectScaffold must instantiate with a classname that is a subclass of %s',
                 DataObject::class
@@ -61,7 +61,7 @@ public function __construct($dataObjectName)
         $this->mutations = OperationList::create([]);
         $this->fields = ArrayList::create([]);
 
-        $this->dataObjectName = $dataObjectName;
+        $this->dataObjectClass = $dataObjectClass;
     }
 
     /**
@@ -79,7 +79,7 @@ public function query($name, $resolver = null)
         }
 
         if ($scaffoldClass = self::getOperationScaffoldForName($name)) {
-            $operationScaffold = new $scaffoldClass($this->dataObjectName);
+            $operationScaffold = new $scaffoldClass($this->dataObjectClass);
         } else {
             $operationScaffold = new QueryScaffolder(
                 $name,
@@ -109,7 +109,7 @@ public function mutation($name, $resolver = null)
         }
 
         if ($scaffoldClass = self::getOperationScaffoldForName($name)) {
-            $operationScaffold = new $scaffoldClass($this->dataObjectName);
+            $operationScaffold = new $scaffoldClass($this->dataObjectClass);
         } else {
             $operationScaffold = new MutationScaffolder(
                 $name,
diff --git a/src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php b/src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php
index 05bffc835..8c27435fe 100644
--- a/src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php
@@ -16,14 +16,11 @@ class DeleteOperationScaffolder extends MutationScaffolder
 
     /**
      * DeleteOperationScaffolder constructor.
-     * @param null $dataObjectName
+     * @param string $dataObjectClass
      */
-    public function __construct($dataObjectName)
+    public function __construct($dataObjectClass)
     {
-        $this->dataObjectName = $dataObjectName;
-        $this->args = [
-            'ID' => 'ID!'
-        ];
+        $this->dataObjectClass = $dataObjectClass;
 
         parent::__construct(
             'delete' . ucfirst($this->typeName()),
diff --git a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
index 9036986a2..9c4083c7c 100644
--- a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
+++ b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
@@ -38,14 +38,14 @@ class GraphQLScaffolder implements ManagerMutatorInterface
     public static function createFromConfig($config)
     {
         $scaffolder = Injector::inst()->create(GraphQLScaffolder::class);
-        foreach ($config as $dataObjectName => $settings) {
+        foreach ($config as $dataObjectClass => $settings) {
             if (empty($settings['fields']) || !is_array($settings['fields'])) {
                 throw new \Exception(
-                    "No array of fields defined for $dataObjectName"
+                    "No array of fields defined for $dataObjectClass"
                 );
             }
 
-            $scaffolder->dataObject($dataObjectName)
+            $scaffolder->dataObject($dataObjectClass)
                 ->addFields($settings['fields']);
 
             if (isset($settings['operations'])) {
@@ -76,7 +76,7 @@ public static function createFromConfig($config)
                 }
                 foreach ($ops as $op) {
                     $method = ($op === GraphQLScaffolder::READ) ? 'query' : 'mutation';
-                    $scaffolder->dataObject($dataObjectName)
+                    $scaffolder->dataObject($dataObjectClass)
                         ->$method($op);
                 }
             }
@@ -94,7 +94,7 @@ public static function createFromConfig($config)
                             );
                         }
                         $args = isset($fieldSettings['args']) ? (array)$fieldSettings['args'] : [];
-                        $scaffolder->dataObject($dataObjectName)
+                        $scaffolder->dataObject($dataObjectClass)
                             ->$method($fieldName)
                             ->setResolver($fieldSettings['resolver'])
                             ->addArgs($args);
@@ -112,15 +112,15 @@ public static function createFromConfig($config)
      * @param DataObjectScaffold $scaffold
      * @throws InvalidArgumentException
      */
-    public function dataObject($name, $typeName = null)
+    public function dataObject($class, $typeName = null)
     {
         foreach ($this->scaffolds as $scaffold) {
-            if ($scaffold->getDataObjectName() == $name) {
+            if ($scaffold->getDataObjectClass() == $class) {
                 return $scaffold;
             }
         }
 
-        $scaffold = new DataObjectScaffolder($name, $typeName);
+        $scaffold = new DataObjectScaffolder($class, $typeName);
         $this->scaffolds[] = $scaffold;
 
         return $scaffold;
diff --git a/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php b/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php
index a67aed4f4..c16e4b306 100644
--- a/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php
@@ -16,11 +16,11 @@ class ReadOperationScaffolder extends QueryScaffolder
 
     /**
      * ReadOperationScaffolder constructor.
-     * @param null $dataObjectName
+     * @param string $dataObjectClass
      */
-    public function __construct($dataObjectName)
+    public function __construct($dataObjectClass)
     {
-        $this->dataObjectName = $dataObjectName;
+        $this->dataObjectClass = $dataObjectClass;
 
         // default args of some sort
         $this->args = [
diff --git a/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php b/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php
index 705d3f02e..4799e402c 100644
--- a/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php
@@ -21,11 +21,11 @@ class UpdateOperationScaffolder extends MutationScaffolder
 
     /**
      * UpdateOperationScaffolder constructor.
-     * @param null $dataObjectName
+     * @param string $dataObjectClass
      */
-    public function __construct($dataObjectName)
+    public function __construct($dataObjectClass)
     {
-        $this->dataObjectName = $dataObjectName;
+        $this->dataObjectClass = $dataObjectClass;
 
         parent::__construct(
             'update' . ucfirst($this->typeName()),
diff --git a/tests/ScaffoldingTest.php b/tests/ScaffoldingTest.php
index e8ff9dd24..91c82286b 100644
--- a/tests/ScaffoldingTest.php
+++ b/tests/ScaffoldingTest.php
@@ -375,8 +375,8 @@ public function testDataObjectTrait()
 
         $this->assertEquals('Some_Namespaced_Table', $scaffolder->typeName());
 
-        $scaffolder->setDataObjectName('test');
-        $this->assertEquals('test', $scaffolder->getDataObjectName());
+        $scaffolder->setDataObjectClass('test');
+        $this->assertEquals('test', $scaffolder->getDataObjectClass());
     }
 
     public function testDataObjectScaffolderCreator()
@@ -566,7 +566,7 @@ public function testGraphQLScaffolderCreateFromConfig()
         ];
 
         foreach ($scaffolds as $scaffold) {
-            $name = $scaffold->getDataObjectName();
+            $name = $scaffold->getDataObjectClass();
             $typeName = ucfirst($scaffold->typeName());
             $pluralTypeName = $scaffold->getDataObjectInstance()->plural_name();
             $pluralTypeName = str_replace(' ', '', $pluralTypeName);

From a43d1432f6ef5ccc55169aff0eff861998b6e9b8 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 15 Dec 2016 14:22:37 +1300
Subject: [PATCH 06/66] Type hinting

---
 src/Scaffolding/Creators/DataObjectTypeCreator.php | 4 ++--
 src/Scaffolding/Creators/OperationCreatorTrait.php | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/Scaffolding/Creators/DataObjectTypeCreator.php b/src/Scaffolding/Creators/DataObjectTypeCreator.php
index 93dbbbc58..92503b6a2 100644
--- a/src/Scaffolding/Creators/DataObjectTypeCreator.php
+++ b/src/Scaffolding/Creators/DataObjectTypeCreator.php
@@ -28,8 +28,8 @@ class DataObjectTypeCreator extends TypeCreator
     /**
      * DataObjectTypeCreator constructor.
      * @param Manager $manager
-     * @param $typeName
-     * @param $fields
+     * @param string $typeName
+     * @param array $fields
      */
     public function __construct(Manager $manager, $typeName, $fields)
     {
diff --git a/src/Scaffolding/Creators/OperationCreatorTrait.php b/src/Scaffolding/Creators/OperationCreatorTrait.php
index edd518c72..015c95aaf 100644
--- a/src/Scaffolding/Creators/OperationCreatorTrait.php
+++ b/src/Scaffolding/Creators/OperationCreatorTrait.php
@@ -33,12 +33,12 @@ trait OperationCreatorTrait
     /**
      * OperationCreatorTrait constructor.
      * @param Manager $manager
-     * @param $operationName
-     * @param $typeName
-     * @param null $resolver
+     * @param string $operationName
+     * @param string $typeName
+     * @param SilverStripe\GraphQL\Scaffolding\ResolverInterface|\Closure $resolver
      * @param array $argsMap
      */
-    public function __construct(Manager $manager, $operationName, $typeName, $resolver = null, $argsMap = [])
+    public function __construct(Manager $manager, $operationName, $typeName, $resolver, $argsMap = [])
     {
         $this->typeName = $typeName;
         $this->resolver = $resolver;

From eaa4982f947920e8be77aec73066f486533234b3 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 15 Dec 2016 14:26:09 +1300
Subject: [PATCH 07/66] Updates to arg creation and resolver logic to all CRUD
 operations

---
 .../Scaffolders/CreateOperationScaffolder.php | 35 ++++++------
 .../Scaffolders/DeleteOperationScaffolder.php | 38 +++++++++----
 .../Scaffolders/ReadOperationScaffolder.php   | 18 +++---
 .../Scaffolders/UpdateOperationScaffolder.php | 55 ++++++++++---------
 4 files changed, 81 insertions(+), 65 deletions(-)

diff --git a/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php b/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php
index cf219e235..15dbc8f11 100644
--- a/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php
@@ -8,6 +8,7 @@
 use SilverStripe\Core\Injector\Injector;
 use SilverStripe\GraphQL\Scaffolding\Util\TypeParser;
 use SilverStripe\GraphQL\Manager;
+use Exception;
 
 /**
  * A generic "create" operation for a DataObject
@@ -30,31 +31,18 @@ public function __construct($dataObjectClass)
             $this->typeName()
         );
 
-        $args = [];
-        $instance = $this->getDataObjectInstance();
-
-        // Setup default input args.. Placeholder!
-        foreach ($instance->db() as $dbFieldName => $dbFieldType) {
-            $result = $instance->obj($dbFieldName);
-            $typeName = $result->config()->graphql_type;
-            $args[$dbFieldName] = $typeName;
-        }
-        unset($args['ID']);
-
-        $this->args = $args;
-
         // Todo: this is totally half baked
         $this->setResolver(function ($object, array $args, $context, $info) {
-            if (singleton($this->dataObjectName)->canCreate()) {
+            if (singleton($this->dataObjectClass)->canCreate()) {
                 $newObject = Injector::inst()->createWithArgs(
-                    $this->dataObjectName,
+                    $this->dataObjectClass,
                     $args
                 );
                 $newObject->write();
 
                 return $newObject;
             } else {
-                // somehow deal with permission errors here
+                throw new Exception("Cannot create {$this->dataObjectClass}");
             }
         });
 
@@ -78,11 +66,20 @@ protected function createArgs()
     protected function generateInputType()
     {
         $fields = [];
-        foreach ($this->args as $fieldName => $typeStr) {
-            $arr = (new TypeParser($typeStr))->toArray();
-            $arr['name'] = $fieldName;
+        $instance = $this->getDataObjectInstance();
+
+        // Setup default input args.. Placeholder!
+        $db = $instance->db();
+        unset($db['ID']);
+
+        foreach ($db as $dbFieldName => $dbFieldType) {
+            $result = $instance->obj($dbFieldName);
+            $typeName = $result->config()->graphql_type;
+            $arr = (new TypeParser($typeName))->toArray();
+            $arr['name'] = $dbFieldName;
             $fields[] = $arr;
         }
+
         return new InputObjectType([
             'name' => $this->typeName() . 'CreateInputType',
             'fields' => $fields
diff --git a/src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php b/src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php
index 8c27435fe..426a2d7de 100644
--- a/src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php
@@ -5,6 +5,9 @@
 use SilverStripe\GraphQL\Scaffolding\DataObjectTypeTrait;
 use SilverStripe\GraphQL\Scaffolding\Resolvers\Delete;
 use SilverStripe\ORM\DataList;
+use GraphQL\Type\Definition\Type;
+use GraphQL\Type\Definition\InputObjectType;
+use Exception;
 
 /**
  * A generic delete operation
@@ -28,19 +31,34 @@ public function __construct($dataObjectClass)
         );
 
         $this->setResolver(function ($object, array $args, $context, $info) {
-            if (singleton($this->dataObjectName)->canDelete()) {
-                $obj = DataList::create($this->dataObjectName)
-                    ->byID($args['ID']);
+            $results = DataList::create($this->dataObjectClass)
+                ->byIDs($args['IDs']);
 
-                if ($obj) {
-                    $obj->delete();
-                }
-
-                return $obj;
-            } else {
-                // permission error
+            foreach($results as $obj) {
+            	if($obj->canDelete()) {
+            		$obj->delete();
+            	} else {
+            		throw new Exception(sprintf(
+            			"Cannot delete %s with ID %s",
+            			$this->dataObjectClass,
+            			$obj->ID
+            		));
+            	}
             }
         });
 
     }
+
+    /**
+     * @return array
+     */
+    protected function createArgs()
+    {
+    	return [
+    		'IDs' => [
+    			'type' => Type::nonNull(Type::listOf(Type::id()))
+    		]
+    	];
+    }	
+
 }
\ No newline at end of file
diff --git a/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php b/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php
index c16e4b306..11e37981b 100644
--- a/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php
@@ -36,17 +36,15 @@ public function __construct($dataObjectClass)
         parent::__construct($operationName, $this->typeName());
 
         $this->setResolver(function ($object, array $args, $context, $info) {
-            if (singleton($this->dataObjectName)->canView()) {
-                $list = DataList::create($this->dataObjectName);
-                $list = $list->limit($args['Limit']);
-                if (isset($args['Sort'])) {
-                    $list = $list->sort($args['Sort']);
-                }
-
-                // filterByCallback(canView()) ??
-
-                return $list;
+            $list = DataList::create($this->dataObjectClass);
+            $list = $list->limit($args['Limit']);
+            if (isset($args['Sort'])) {
+                $list = $list->sort($args['Sort']);
             }
+
+            return $list->filterbyCallback(function ($item, $list) {
+            	return $item->canView();
+            });
         });
 
     }
diff --git a/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php b/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php
index 4799e402c..6efeef2c5 100644
--- a/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php
@@ -10,6 +10,7 @@
 use SilverStripe\ORM\DataList;
 use SilverStripe\GraphQL\Manager;
 use GraphQL\Type\Definition\Type;
+use Exception;
 
 /**
  * Scaffolds a generic update operation for DataObjects
@@ -32,32 +33,28 @@ public function __construct($dataObjectClass)
             $this->typeName()
         );
 
-        $args = [];
-        $instance = $this->getDataObjectInstance();
-
-        // Setup default input args.. Placeholder!
-        foreach ($instance->db() as $dbFieldName => $dbFieldType) {
-            $result = $instance->obj($dbFieldName);
-            $typeName = $result->config()->graphql_type;
-            $args[$dbFieldName] = $typeName;
-        }
-
-        $this->args = $args;
-
         // Todo: this is totally half baked
-        $this->setResolver(function ($object, array $args, $context, $info) {
-            if (singleton($this->dataObjectName)->canEdit()) {
-                $obj = DataList::create($this->dataObjectName)
-                    ->byID($args['ID']);
+        $this->setResolver(function ($object, array $args, $context, $info) {            
+            $obj = DataList::create($this->dataObjectClass)
+                ->byID($args['ID']);
+            if(!$obj) {
+            	throw new Exception(sprintf(
+            		"%s with ID %s not found",
+            		$this->dataObjectClass,
+            		$args['ID']
+            	));
+            }
 
-                if ($obj) {
-                    $obj->update($args['Input']);
-                    $obj->write();
-                }
+            if ($obj->canEdit()) {
+                $obj->update($args['Input']);
+                $obj->write();
 
                 return $obj;
             } else {
-                // permission error
+                throw new Exception(sprintf(
+                	"Cannot edit this %s",
+                	$this->dataObjectClass
+                ));
             }
         });
 
@@ -85,14 +82,20 @@ protected function createArgs()
     protected function generateInputType()
     {
         $fields = [];
-        $args = $this->args;
-        unset($args['ID']);
+        $instance = $this->getDataObjectInstance();
 
-        foreach ($args as $fieldName => $typeStr) {
-            $arr = (new TypeParser($typeStr))->toArray();
-            $arr['name'] = $fieldName;
+        // Setup default input args.. Placeholder!
+        $db = $instance->db();
+        unset($db['ID']);
+        
+        foreach ($db as $dbFieldName => $dbFieldType) {
+            $result = $instance->obj($dbFieldName);
+            $typeName = $result->config()->graphql_type;
+            $arr = (new TypeParser($typeName))->toArray();
+            $arr['name'] = $dbFieldName;
             $fields[] = $arr;
         }
+
         return new InputObjectType([
             'name' => $this->typeName() . 'UpdateInputType',
             'fields' => $fields

From 68306e7d0cd14395ffacfc14524da9ac21388f30 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 15 Dec 2016 14:26:51 +1300
Subject: [PATCH 08/66] Add type detection to DataObject getters that are not
 casted

---
 src/Scaffolding/Scaffolders/DataObjectScaffolder.php | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
index 4fe3ccbcc..2750feda3 100644
--- a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -241,6 +241,14 @@ public function getCreator(Manager $manager)
             if ($result instanceof DBField) {
                 $typeName = $result->config()->graphql_type;
                 $fieldMap[$fieldName] = (new TypeParser($typeName))->toArray();
+            } else if(is_bool($result)) {
+            	$fieldMap[$fieldName] = ['type' => Type::boolean()];
+            } else if(is_int($result)) {
+            	$fieldMap[$fieldName] = ['type' => Type::int()];
+            } else if(is_float($result)) {
+            	$fieldMap[$fieldName] = ['type' => Type::float()];
+            } else {
+            	$fieldMap[$fieldName] = ['type' => Type::string()];
             }
         }
 

From 2c6379aa895c313b20a4b104e30fa67556a7bdbc Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 15 Dec 2016 14:27:03 +1300
Subject: [PATCH 09/66] Remove @package declaration

---
 src/Scaffolding/Scaffolders/MutationScaffolder.php | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Scaffolding/Scaffolders/MutationScaffolder.php b/src/Scaffolding/Scaffolders/MutationScaffolder.php
index 0191d79d3..ea8a0dce3 100644
--- a/src/Scaffolding/Scaffolders/MutationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/MutationScaffolder.php
@@ -7,7 +7,6 @@
 
 /**
  * Scaffolds a GraphQL mutation field
- * @package SilverStripe\GraphQL\Scaffolding\Scaffolders
  */
 class MutationScaffolder extends OperationScaffolder implements ManagerMutatorInterface, ScaffolderInterface
 {

From 5d061e7c83b5709a074200399d69c6843e9ab3de Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 15 Dec 2016 14:27:19 +1300
Subject: [PATCH 10/66] Use new required resolver argument

---
 tests/ScaffoldingTest.php | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/ScaffoldingTest.php b/tests/ScaffoldingTest.php
index 91c82286b..0058078ff 100644
--- a/tests/ScaffoldingTest.php
+++ b/tests/ScaffoldingTest.php
@@ -65,7 +65,7 @@ public function testMutationOperationCreator()
             ->method('getType')
             ->will($this->returnArgument(0));
 
-        $mutationCreator = new MutationOperationCreator($managerMock, 'testOperation', 'testType');
+        $mutationCreator = new MutationOperationCreator($managerMock, 'testOperation', 'testType', 'testResolver');
         $result = $mutationCreator->type();
 
         $this->assertInstanceOf('\Closure', $result);
@@ -82,7 +82,7 @@ public function testQueryOperationCreator()
             ->method('getType')
             ->willReturn(new ObjectType(['name' => 'test']));
 
-        $mutationCreator = new QueryOperationCreator($managerMock, 'testOperation', 'testType');
+        $mutationCreator = new QueryOperationCreator($managerMock, 'testOperation', 'testType','testResolver');
         $result = $mutationCreator->type();
 
         $this->assertInstanceOf('\Closure', $result);

From ddb07811c0ad55772f716151889b2033001210a7 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 15 Dec 2016 21:14:30 +1300
Subject: [PATCH 11/66] More informative exception message

---
 src/Scaffolding/Scaffolders/GraphQLScaffolder.php | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
index 9c4083c7c..2a8e52f2e 100644
--- a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
+++ b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
@@ -64,7 +64,7 @@ public static function createFromConfig($config)
                                 $ops[] = constant($constStr);
                             } else {
                                 throw new \Exception(
-                                    "Invalid operation: $op"
+                                    "Invalid operation: $op on $dataobjectClass"
                                 );
                             }
                         }

From 349cb1795a3828ff44f7b51a2838017ba0f9b76f Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Fri, 16 Dec 2016 22:42:53 +1300
Subject: [PATCH 12/66] New hasType() method for Manager

---
 src/Manager.php                                      | 10 ++++++++++
 src/Scaffolding/Scaffolders/DataObjectScaffolder.php |  2 +-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/Manager.php b/src/Manager.php
index 8855bf207..176509454 100644
--- a/src/Manager.php
+++ b/src/Manager.php
@@ -222,6 +222,16 @@ public function getType($name)
         }
     }
 
+    /**
+     * @param  string  $name
+     * 
+     * @return boolean
+     */
+    public function hasType($name)
+    {
+    	return isset($this->types[$name]);
+    }
+
     /**
      * @param array  $query
      * @param string $name  Identifier for this query (unique in schema)
diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
index 2750feda3..59a794d3b 100644
--- a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -308,7 +308,7 @@ public function addToManager(Manager $manager)
     {
         $creator = $this->getCreator($manager);
 
-        if (!$manager->getType($this->typeName())) {
+        if (!$manager->hasType($this->typeName())) {
             $manager->addType($creator->toType(), $this->typeName());
         }
 

From eb1ed99d3f089ad8ef915edf61f2d090d2642a6e Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Sun, 18 Dec 2016 21:28:02 +1300
Subject: [PATCH 13/66] Provide pagination in scaffolded queries

---
 .../Creators/OperationCreatorTrait.php        |  31 +--
 .../PaginatedQueryOperationCreator.php        |  61 +++++
 .../Creators/PolymorphicResolverTrait.php     |  35 +++
 .../Scaffolders/CreateOperationScaffolder.php |   8 +-
 .../Scaffolders/GraphQLScaffolder.php         |   5 +-
 .../Scaffolders/QueryScaffolder.php           |  58 +++++
 .../Scaffolders/ReadOperationScaffolder.php   |  16 +-
 .../Scaffolders/UpdateOperationScaffolder.php |   8 +-
 tests/ScaffoldingTest.php                     | 223 +++++++++++-------
 9 files changed, 313 insertions(+), 132 deletions(-)
 create mode 100644 src/Scaffolding/Creators/PaginatedQueryOperationCreator.php
 create mode 100644 src/Scaffolding/Creators/PolymorphicResolverTrait.php

diff --git a/src/Scaffolding/Creators/OperationCreatorTrait.php b/src/Scaffolding/Creators/OperationCreatorTrait.php
index 015c95aaf..9bf87e35a 100644
--- a/src/Scaffolding/Creators/OperationCreatorTrait.php
+++ b/src/Scaffolding/Creators/OperationCreatorTrait.php
@@ -2,7 +2,6 @@
 
 namespace SilverStripe\GraphQL\Scaffolding\Creators;
 
-use SilverStripe\GraphQL\Scaffolding\ResolverInterface;
 use SilverStripe\GraphQL\Manager;
 
 /**
@@ -10,16 +9,13 @@
  */
 trait OperationCreatorTrait
 {
+    use PolymorphicResolverTrait;
+    
     /**
      * @var string
      */
     protected $typeName;
 
-    /**
-     * @var \Closure|SilverStripe\GraphQL\ResolverInterface
-     */
-    protected $resolver;
-
     /**
      * @var string
      */
@@ -67,29 +63,12 @@ public function args()
     }
 
     /**
-     * Overload the getResolver() method to be aware of the ResolverInterface option
+     * Overload the getResolver() method to be aware of the polymorphic resolvers
      * @return mixed
      */
-    protected function getResolver()
+    public function getResolver()
     {
-        $resolver = $this->resolver;
-
-        return function () use ($resolver) {
-            $args = func_get_args();
-            if (is_callable($resolver)) {
-                return call_user_func_array($resolver, $args);
-            } else {
-                if ($resolver instanceof ResolverInterface) {
-                    return call_user_func_array([$resolver, 'resolve'], $args);
-                } else {
-                    throw new \Exception(sprintf(
-                        '%s resolver must be a closure or implement %s',
-                        __CLASS__,
-                        ResolverInterface::class
-                    ));
-                }
-            }
-        };
+    	return $this->createResolverFunction();
     }
 
 }
\ No newline at end of file
diff --git a/src/Scaffolding/Creators/PaginatedQueryOperationCreator.php b/src/Scaffolding/Creators/PaginatedQueryOperationCreator.php
new file mode 100644
index 000000000..9d3a1e491
--- /dev/null
+++ b/src/Scaffolding/Creators/PaginatedQueryOperationCreator.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Creators;
+
+use SilverStripe\GraphQL\Pagination\PaginatedQueryCreator;
+use SilverStripe\GraphQL\Pagination\Connection;
+use SilverStripe\GraphQL\Manager;
+
+class PaginatedQueryOperationCreator extends PaginatedQueryCreator
+{
+
+	use PolymorphicResolverTrait;
+	
+	/**
+	 * @var string
+	 */
+	protected $operationName;
+
+	/**
+	 * @param Manager    $manager       
+	 * @param Connection $connection    
+	 * @param string     $operationName 
+	 * @param string     $typeName      
+	 * @param Callable|ResolverInterface     $resolver  
+	 */
+	public function __construct(Manager $manager, Connection $connection, $operationName, $typeName, $resolver)
+	{
+		$this->connection = $connection;
+		$this->resolver = $resolver;
+		$this->operationName = $operationName;
+
+		parent::__construct($manager);
+
+        $this->connection
+        	->setConnectionType(function() use ($typeName) {
+           		return $this->manager->getType($typeName);
+        	})
+        	->setConnectionResolver($this->createResolverFunction());
+	}
+
+	/**
+	 * @return array
+	 */
+	public function attributes()
+	{
+		return [
+			'name' => $this->operationName
+		];
+	}
+
+	/**
+	 * This method usually builds a new Connection interface, but since it is
+	 * assigned in the constructor of this class, it's overloaded as a simple accessor
+	 * 
+	 * @return SilverStripe\GraphQL\Pagination\Connection;
+	 */
+	public function connection()
+	{
+		return $this->connection;
+	}
+}
\ No newline at end of file
diff --git a/src/Scaffolding/Creators/PolymorphicResolverTrait.php b/src/Scaffolding/Creators/PolymorphicResolverTrait.php
new file mode 100644
index 000000000..f874c6799
--- /dev/null
+++ b/src/Scaffolding/Creators/PolymorphicResolverTrait.php
@@ -0,0 +1,35 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Creators;
+
+use SilverStripe\GraphQL\Scaffolding\ResolverInterface;
+
+trait PolymorphicResolverTrait
+{
+    /**
+     * @var \Closure|SilverStripe\GraphQL\ResolverInterface
+     */
+    protected $resolver;
+
+    protected function createResolverFunction()
+    {
+        $resolver = $this->resolver;
+
+        return function () use ($resolver) {
+            $args = func_get_args();
+            if (is_callable($resolver)) {
+                return call_user_func_array($resolver, $args);
+            } else {
+                if ($resolver instanceof ResolverInterface) {
+                    return call_user_func_array([$resolver, 'resolve'], $args);
+                } else {
+                    throw new \Exception(sprintf(
+                        '%s resolver must be a closure or implement %s',
+                        __CLASS__,
+                        ResolverInterface::class
+                    ));
+                }
+            }
+        };
+    }
+}
\ No newline at end of file
diff --git a/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php b/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php
index 15dbc8f11..4c3c4c2e8 100644
--- a/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php
@@ -6,6 +6,7 @@
 use GraphQL\Type\Definition\InputObjectType;
 use GraphQL\Type\Definition\Type;
 use SilverStripe\Core\Injector\Injector;
+use SilverStripe\Core\Config\Config;
 use SilverStripe\GraphQL\Scaffolding\Util\TypeParser;
 use SilverStripe\GraphQL\Manager;
 use Exception;
@@ -69,7 +70,12 @@ protected function generateInputType()
         $instance = $this->getDataObjectInstance();
 
         // Setup default input args.. Placeholder!
-        $db = $instance->db();
+		$db = (array) Config::inst()->get(
+			$this->dataObjectClass,
+			'db',
+			Config::INHERITED
+		);
+
         unset($db['ID']);
 
         foreach ($db as $dbFieldName => $dbFieldType) {
diff --git a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
index 2a8e52f2e..cbff65b27 100644
--- a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
+++ b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
@@ -94,10 +94,13 @@ public static function createFromConfig($config)
                             );
                         }
                         $args = isset($fieldSettings['args']) ? (array)$fieldSettings['args'] : [];
-                        $scaffolder->dataObject($dataObjectClass)
+                        $operation = $scaffolder->dataObject($dataObjectClass)
                             ->$method($fieldName)
                             ->setResolver($fieldSettings['resolver'])
                             ->addArgs($args);
+                        if($group === 'queries' && isset($fieldSettings['paginate'])) {
+                        	$operation->setUsePagination((boolean) $fieldSettings['paginate']);
+                        }
                     }
                 }
             }
diff --git a/src/Scaffolding/Scaffolders/QueryScaffolder.php b/src/Scaffolding/Scaffolders/QueryScaffolder.php
index 0f1cb6fbb..e0b628306 100644
--- a/src/Scaffolding/Scaffolders/QueryScaffolder.php
+++ b/src/Scaffolding/Scaffolders/QueryScaffolder.php
@@ -4,6 +4,8 @@
 
 use SilverStripe\GraphQL\Manager;
 use SilverStripe\GraphQL\Scaffolding\Creators\QueryOperationCreator;
+use SilverStripe\GraphQL\Scaffolding\Creators\PaginatedQueryOperationCreator;
+use SilverStripe\GraphQL\Pagination\Connection;
 
 /**
  * Scaffolds a GraphQL query field
@@ -11,6 +13,26 @@
 class QueryScaffolder extends OperationScaffolder implements ManagerMutatorInterface, ScaffolderInterface
 {
 
+	/**
+	 * @var boolean
+	 */
+	protected $usePagination = true;
+
+	/**
+	 * @var array
+	 */
+	protected $sortableFields = [];
+
+	/**
+	 * @param boolean $bool
+	 */
+	public function setUsePagination($bool)
+	{
+		$this->usePagination = (boolean) $bool;
+
+		return $this;
+	}
+
     /**
      * @param Manager $manager
      */
@@ -23,12 +45,48 @@ public function addToManager(Manager $manager)
         );
     }
 
+    /**
+     * @param array $fields
+     */
+    public function addSortableFields($fields)
+    {
+    	$this->sortableFields = array_unique(
+    		array_merge(
+    			$this->sortableFields,
+    			(array) $fields
+    		)
+    	);
+    	
+    	return $this;
+    }
+
+    /**
+     * Creates a Connection for pagination
+     * @return Connection
+     */
+    protected function createConnection()
+    {
+        return Connection::create($this->operationName)
+            ->setArgs($this->createArgs())
+            ->setSortableFields($this->sortableFields);
+    }
+
     /**
      * @param Manager $manager
      * @return QueryOperationCreator
      */
     public function getCreator(Manager $manager)
     {
+        if($this->usePagination) {
+        	return new PaginatedQueryOperationCreator(
+        		$manager,
+        		$this->createConnection(),
+        		$this->operationName,
+        		$this->typeName,
+        		$this->resolver
+        	);
+        }
+
         return new QueryOperationCreator(
             $manager,
             $this->operationName,
diff --git a/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php b/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php
index 11e37981b..c4db154ab 100644
--- a/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php
@@ -22,12 +22,6 @@ public function __construct($dataObjectClass)
     {
         $this->dataObjectClass = $dataObjectClass;
 
-        // default args of some sort
-        $this->args = [
-            'Limit' => 'Int=20',
-            'Sort' => 'String'
-        ];
-
         $typeName = $this->getDataObjectInstance()->plural_name();
         $typeName = str_replace(' ', '', $typeName);
         $typeName = ucfirst($typeName);
@@ -37,14 +31,8 @@ public function __construct($dataObjectClass)
 
         $this->setResolver(function ($object, array $args, $context, $info) {
             $list = DataList::create($this->dataObjectClass);
-            $list = $list->limit($args['Limit']);
-            if (isset($args['Sort'])) {
-                $list = $list->sort($args['Sort']);
-            }
-
-            return $list->filterbyCallback(function ($item, $list) {
-            	return $item->canView();
-            });
+            
+            return $list;
         });
 
     }
diff --git a/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php b/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php
index 6efeef2c5..23b305eb4 100644
--- a/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php
@@ -6,6 +6,7 @@
 use SilverStripe\GraphQL\Scaffolding\Resolvers\Update;
 use GraphQL\Type\Definition\InputObjectType;
 use SilverStripe\Core\Injector\Injector;
+use SilverStripe\Core\Config\Config;
 use SilverStripe\GraphQL\Scaffolding\Util\TypeParser;
 use SilverStripe\ORM\DataList;
 use SilverStripe\GraphQL\Manager;
@@ -85,7 +86,12 @@ protected function generateInputType()
         $instance = $this->getDataObjectInstance();
 
         // Setup default input args.. Placeholder!
-        $db = $instance->db();
+		$db = (array) Config::inst()->get(
+			$this->dataObjectClass,
+			'db',
+			Config::INHERITED
+		);
+
         unset($db['ID']);
         
         foreach ($db as $dbFieldName => $dbFieldType) {
diff --git a/tests/ScaffoldingTest.php b/tests/ScaffoldingTest.php
index 0058078ff..785da4537 100644
--- a/tests/ScaffoldingTest.php
+++ b/tests/ScaffoldingTest.php
@@ -16,6 +16,7 @@
 use SilverStripe\GraphQL\Tests\Fake\DataObjectFake;
 use SilverStripe\GraphQL\Scaffolding\Creators\MutationOperationCreator;
 use SilverStripe\GraphQL\Scaffolding\Creators\QueryOperationCreator;
+use SilverStripe\GraphQL\Scaffolding\Creators\PaginatedQueryOperationCreator;
 use SilverStripe\GraphQL\Tests\Fake\FakeResolver;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\MutationScaffolder;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\OperationScaffolder;
@@ -34,6 +35,7 @@
 use ReflectionClass;
 use SilverStripe\GraphQL\Scaffolding\Util\ArgsParser;
 use SilverStripe\GraphQL\Scaffolding\Util\TypeParser;
+use SilverStripe\GraphQL\Pagination\Connection;
 
 class ScaffoldingTest extends SapphireTest
 {
@@ -150,8 +152,13 @@ public function testQueryOperationScaffolderCore()
         $this->assertEquals('testOperation', $scaffolder->getName());
 
         $creator = $scaffolder->getCreator(new Manager());
-        $this->assertInstanceOf(QueryOperationCreator::class, $creator);
+        $this->assertInstanceOf(PaginatedQueryOperationCreator::class, $creator);
         $this->assertEquals(['name' => 'testOperation'], $creator->attributes());
+
+        $scaffolder->setUsePagination(false);
+        $creator = $scaffolder->getCreator(new Manager());
+        $this->assertInstanceOf(QueryOperationCreator::class, $creator);
+		$this->assertEquals(['name' => 'testOperation'], $creator->attributes());        
     }
 
     public function testOperationScaffolderCreator()
@@ -415,7 +422,7 @@ public function testDataObjectScaffolderAddToManager()
         $managerMock->expects($this->once())
             ->method('addMutation')
             ->with(
-                $this->callback(function ($subject) {
+                $this->callback(function ($subject) {                	
                     return (
                         is_array($subject) && $subject['name'] == 'myMutation'
                     );
@@ -426,7 +433,7 @@ public function testDataObjectScaffolderAddToManager()
         $managerMock->expects($this->once())
             ->method('addQuery')
             ->with(
-                $this->callback(function ($subject) {
+                $this->callback(function ($subject) {                
                     return (
                         is_array($subject) && $subject['name'] == 'myQuery'
                     );
@@ -448,6 +455,10 @@ public function testGraphQLScaffolderAddToManager()
         $scaffolder->dataObject(DataObjectFake::class)
             ->query('testQuery', $resolver)
             ->addArgs(['Test' => 'String']);
+        $scaffolder->dataObject(DataObjectFake::class)
+            ->query('testQueryUnpaginated', $resolver)
+            ->addArgs(['Test' => 'String'])
+            ->setUsePagination(false);
         $scaffolder->dataObject(Member::class)
             ->addFields(['Surname']);
         $scaffolder->dataObject(File::class)
@@ -496,13 +507,29 @@ public function testGraphQLScaffolderAddToManager()
 
             );
 
-        $managerMock->expects($this->once())
+        $managerMock->expects($this->exactly(2))
             ->method('addQuery')
-            ->with($this->callback(function ($subject) {
-                return is_array($subject) &&
-                $subject['name'] == 'testQuery' &&
-                array_keys($subject['args']) == ['Test'];
-            }));
+            ->withConsecutive(
+            	[
+            		$this->callback(function ($subject) {
+            			$connectionKeys = array_keys(Connection::create('dummy')->args());
+                		return (
+                			is_array($subject) &&
+                			$subject['name'] == 'testQuery' &&
+                			array_keys($subject['args']) == array_merge(['Test'], $connectionKeys)
+                		);
+            		})
+            	],
+            	[
+            		$this->callback(function ($subject) {
+                		return (
+                			is_array($subject) &&
+                			$subject['name'] == 'testQueryUnpaginated' &&
+                			array_keys($subject['args']) == ['Test']
+                		);
+            		})            	
+            	]
+            );
 
         $managerMock->expects($this->once())
             ->method('addMutation')
@@ -537,6 +564,12 @@ public function testGraphQLScaffolderCreateFromConfig()
                             'Test' => 'String'
                         ],
                         'resolver' => FakeResolver::class
+                    ],
+                    'myQueryUnpaginated' => [
+                    	'args' => [
+                    		'Test' => 'String'
+                    	],
+                    	'resolver' => FakeResolver::class
                     ]
                 ]
             ],
@@ -598,7 +631,19 @@ public function testGraphQLScaffolderCreateFromConfig()
                         QueryScaffolder::class,
                         $op
                     );
+                    $args = $op->getCreator(new Manager())->args();
+                    foreach(Connection::create('dummy')->args() as $a => $config) {
+                    	$this->assertArrayHasKey($a, $args);
+                    }
+                    $this->assertArrayHasKey('Test', $args);
+
+                    $op = $scaffold->getQueries()->findByName('myQueryUnpaginated');
+                    $this->assertInstanceOf(
+                        QueryScaffolder::class,
+                        $op
+                    );
                     $this->assertArrayHasKey('Test', $op->getCreator(new Manager())->args());
+
                 }
 
             } else {
@@ -636,86 +681,86 @@ public function testInputTypesAreCreated()
         $this->assertInstanceOf(InputObjectType::class, $type->getWrappedType());
     }
 
-    public function testTypeParser()
-    {
-        $parser = new TypeParser('String!=Test');
-        $this->assertTrue($parser->isRequired());
-        $this->assertEquals('String', $parser->getArgTypeName());
-        $this->assertEquals('Test', $parser->getDefaultValue());
-
-        $parser = new TypeParser('String! = Test');
-        $this->assertTrue($parser->isRequired());
-        $this->assertEquals('String', $parser->getArgTypeName());
-        $this->assertEquals('Test', $parser->getDefaultValue());
-
-        $parser = new TypeParser('Int!');
-        $this->assertTrue($parser->isRequired());
-        $this->assertEquals('Int', $parser->getArgTypeName());
-        $this->assertNull($parser->getDefaultValue());
-
-        $parser = new TypeParser('Boolean');
-        $this->assertFalse($parser->isRequired());
-        $this->assertEquals('Boolean', $parser->getArgTypeName());
-        $this->assertNull($parser->getDefaultValue());
-
-        $parser = new TypeParser('String!=Test');
-        $arr = $parser->toArray();
-        $this->assertInstanceOf(NonNull::class, $arr['type']);
-        $this->assertInstanceOf(StringType::class, $arr['type']->getWrappedType());
-        $this->assertEquals('Test', $arr['defaultValue']);
-
-        $this->setExpectedException(InvalidArgumentException::class);
-        $parser = new TypeParser('  ... Nothing');
-
-        $this->setExpectedException(InvalidArgumentException::class);
-        $parser = (new TypeParser('Nothing'))->toArray();
-    }
-
-    public function testArgsParser()
-    {
-        $parsers = [
-            new ArgsParser([
-                'Test' => 'String'
-            ]),
-            new ArgsParser([
-                'Test' => Type::string()
-            ]),
-            new ArgsParser([
-                'Test' => ['type' => Type::string()]
-            ])
-        ];
-
-        foreach ($parsers as $parser) {
-            $arr = $parser->toArray();
-            $this->assertArrayHasKey('Test', $arr);
-            $this->assertArrayHasKey('type', $arr['Test']);
-            $this->assertInstanceOf(StringType::class, $arr['Test']['type']);
-        }
-    }
-
-
-    public function testOperationList()
-    {
-        $list = new OperationList();
-
-        $list->push(new MutationScaffolder('myMutation1', 'test1'));
-        $list->push(new MutationScaffolder('myMutation2', 'test2'));
-
-        $this->assertInstanceOf(
-            MutationScaffolder::class,
-            $list->findByName('myMutation1')
-        );
-        $this->assertFalse($list->findByName('myMutation3'));
-
-        $list->removeByName('myMutation2');
-        $this->assertEquals(1, $list->count());
-
-        $list->removeByName('nothing');
-        $this->assertEquals(1, $list->count());
-
-        $this->setExpectedException(InvalidArgumentException::class);
-        $list->push(new OperationList());
-    }
+    // public function testTypeParser()
+    // {
+    //     $parser = new TypeParser('String!=Test');
+    //     $this->assertTrue($parser->isRequired());
+    //     $this->assertEquals('String', $parser->getArgTypeName());
+    //     $this->assertEquals('Test', $parser->getDefaultValue());
+
+    //     $parser = new TypeParser('String! = Test');
+    //     $this->assertTrue($parser->isRequired());
+    //     $this->assertEquals('String', $parser->getArgTypeName());
+    //     $this->assertEquals('Test', $parser->getDefaultValue());
+
+    //     $parser = new TypeParser('Int!');
+    //     $this->assertTrue($parser->isRequired());
+    //     $this->assertEquals('Int', $parser->getArgTypeName());
+    //     $this->assertNull($parser->getDefaultValue());
+
+    //     $parser = new TypeParser('Boolean');
+    //     $this->assertFalse($parser->isRequired());
+    //     $this->assertEquals('Boolean', $parser->getArgTypeName());
+    //     $this->assertNull($parser->getDefaultValue());
+
+    //     $parser = new TypeParser('String!=Test');
+    //     $arr = $parser->toArray();
+    //     $this->assertInstanceOf(NonNull::class, $arr['type']);
+    //     $this->assertInstanceOf(StringType::class, $arr['type']->getWrappedType());
+    //     $this->assertEquals('Test', $arr['defaultValue']);
+
+    //     $this->setExpectedException(InvalidArgumentException::class);
+    //     $parser = new TypeParser('  ... Nothing');
+
+    //     $this->setExpectedException(InvalidArgumentException::class);
+    //     $parser = (new TypeParser('Nothing'))->toArray();
+    // }
+
+    // public function testArgsParser()
+    // {
+    //     $parsers = [
+    //         new ArgsParser([
+    //             'Test' => 'String'
+    //         ]),
+    //         new ArgsParser([
+    //             'Test' => Type::string()
+    //         ]),
+    //         new ArgsParser([
+    //             'Test' => ['type' => Type::string()]
+    //         ])
+    //     ];
+
+    //     foreach ($parsers as $parser) {
+    //         $arr = $parser->toArray();
+    //         $this->assertArrayHasKey('Test', $arr);
+    //         $this->assertArrayHasKey('type', $arr['Test']);
+    //         $this->assertInstanceOf(StringType::class, $arr['Test']['type']);
+    //     }
+    // }
+
+
+    // public function testOperationList()
+    // {
+    //     $list = new OperationList();
+
+    //     $list->push(new MutationScaffolder('myMutation1', 'test1'));
+    //     $list->push(new MutationScaffolder('myMutation2', 'test2'));
+
+    //     $this->assertInstanceOf(
+    //         MutationScaffolder::class,
+    //         $list->findByName('myMutation1')
+    //     );
+    //     $this->assertFalse($list->findByName('myMutation3'));
+
+    //     $list->removeByName('myMutation2');
+    //     $this->assertEquals(1, $list->count());
+
+    //     $list->removeByName('nothing');
+    //     $this->assertEquals(1, $list->count());
+
+    //     $this->setExpectedException(InvalidArgumentException::class);
+    //     $list->push(new OperationList());
+    // }
 
     protected function createOperationCreator($resolver = null)
     {

From e353462f2f4bab86d3210646bf563d997fd3677e Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Sun, 18 Dec 2016 21:38:48 +1300
Subject: [PATCH 14/66] Cast default value for args

---
 src/Scaffolding/Util/TypeParser.php |   8 +-
 tests/ScaffoldingTest.php           | 173 +++++++++++++++-------------
 2 files changed, 100 insertions(+), 81 deletions(-)

diff --git a/src/Scaffolding/Util/TypeParser.php b/src/Scaffolding/Util/TypeParser.php
index c0dd98f2a..7f599fcb7 100644
--- a/src/Scaffolding/Util/TypeParser.php
+++ b/src/Scaffolding/Util/TypeParser.php
@@ -82,21 +82,27 @@ public function getDefaultValue()
     public function toArray()
     {
         $type = null;
+        $defaultValue = null;
         switch ($this->argType) {
             case Type::ID:
                 $type = Type::id();
+                $defaultValue = (int) $this->defaultValue;
                 break;
             case Type::STRING:
                 $type = Type::string();
+                $defaultValue = (string) $this->defaultValue;
                 break;
             case Type::BOOLEAN:
                 $type = Type::boolean();
+                $defaultValue = (boolean) $this->defaultValue;
                 break;
             case Type::INT:
                 $type = Type::int();
+                $defaultValue = (int) $this->defaultValue;
                 break;
             case Type::FLOAT:
                 $type = Type::float();
+                $defaultValue = (float) $this->defaultValue;
                 break;
 
         }
@@ -111,7 +117,7 @@ public function toArray()
 
         return [
             'type' => $type,
-            'defaultValue' => $this->defaultValue
+            'defaultValue' => $defaultValue
         ];
     }
 }
\ No newline at end of file
diff --git a/tests/ScaffoldingTest.php b/tests/ScaffoldingTest.php
index 785da4537..d4e35459a 100644
--- a/tests/ScaffoldingTest.php
+++ b/tests/ScaffoldingTest.php
@@ -681,86 +681,99 @@ public function testInputTypesAreCreated()
         $this->assertInstanceOf(InputObjectType::class, $type->getWrappedType());
     }
 
-    // public function testTypeParser()
-    // {
-    //     $parser = new TypeParser('String!=Test');
-    //     $this->assertTrue($parser->isRequired());
-    //     $this->assertEquals('String', $parser->getArgTypeName());
-    //     $this->assertEquals('Test', $parser->getDefaultValue());
-
-    //     $parser = new TypeParser('String! = Test');
-    //     $this->assertTrue($parser->isRequired());
-    //     $this->assertEquals('String', $parser->getArgTypeName());
-    //     $this->assertEquals('Test', $parser->getDefaultValue());
-
-    //     $parser = new TypeParser('Int!');
-    //     $this->assertTrue($parser->isRequired());
-    //     $this->assertEquals('Int', $parser->getArgTypeName());
-    //     $this->assertNull($parser->getDefaultValue());
-
-    //     $parser = new TypeParser('Boolean');
-    //     $this->assertFalse($parser->isRequired());
-    //     $this->assertEquals('Boolean', $parser->getArgTypeName());
-    //     $this->assertNull($parser->getDefaultValue());
-
-    //     $parser = new TypeParser('String!=Test');
-    //     $arr = $parser->toArray();
-    //     $this->assertInstanceOf(NonNull::class, $arr['type']);
-    //     $this->assertInstanceOf(StringType::class, $arr['type']->getWrappedType());
-    //     $this->assertEquals('Test', $arr['defaultValue']);
-
-    //     $this->setExpectedException(InvalidArgumentException::class);
-    //     $parser = new TypeParser('  ... Nothing');
-
-    //     $this->setExpectedException(InvalidArgumentException::class);
-    //     $parser = (new TypeParser('Nothing'))->toArray();
-    // }
-
-    // public function testArgsParser()
-    // {
-    //     $parsers = [
-    //         new ArgsParser([
-    //             'Test' => 'String'
-    //         ]),
-    //         new ArgsParser([
-    //             'Test' => Type::string()
-    //         ]),
-    //         new ArgsParser([
-    //             'Test' => ['type' => Type::string()]
-    //         ])
-    //     ];
-
-    //     foreach ($parsers as $parser) {
-    //         $arr = $parser->toArray();
-    //         $this->assertArrayHasKey('Test', $arr);
-    //         $this->assertArrayHasKey('type', $arr['Test']);
-    //         $this->assertInstanceOf(StringType::class, $arr['Test']['type']);
-    //     }
-    // }
-
-
-    // public function testOperationList()
-    // {
-    //     $list = new OperationList();
-
-    //     $list->push(new MutationScaffolder('myMutation1', 'test1'));
-    //     $list->push(new MutationScaffolder('myMutation2', 'test2'));
-
-    //     $this->assertInstanceOf(
-    //         MutationScaffolder::class,
-    //         $list->findByName('myMutation1')
-    //     );
-    //     $this->assertFalse($list->findByName('myMutation3'));
-
-    //     $list->removeByName('myMutation2');
-    //     $this->assertEquals(1, $list->count());
-
-    //     $list->removeByName('nothing');
-    //     $this->assertEquals(1, $list->count());
-
-    //     $this->setExpectedException(InvalidArgumentException::class);
-    //     $list->push(new OperationList());
-    // }
+    public function testTypeParser()
+    {
+        $parser = new TypeParser('String!=Test');
+        $this->assertTrue($parser->isRequired());
+        $this->assertEquals('String', $parser->getArgTypeName());
+        $this->assertEquals('Test', $parser->getDefaultValue());
+        $this->assertTrue(is_string($parser->toArray()['defaultValue']));
+
+        $parser = new TypeParser('String! = Test');
+        $this->assertTrue($parser->isRequired());
+        $this->assertEquals('String', $parser->getArgTypeName());
+        $this->assertEquals('Test', $parser->getDefaultValue());
+
+        $parser = new TypeParser('Int!');
+        $this->assertTrue($parser->isRequired());
+        $this->assertEquals('Int', $parser->getArgTypeName());
+        $this->assertNull($parser->getDefaultValue());
+
+        $parser = new TypeParser('Int!=23');
+        $this->assertTrue($parser->isRequired());
+        $this->assertEquals('Int', $parser->getArgTypeName());
+        $this->assertEquals('23', $parser->getDefaultValue());
+		$this->assertTrue(is_int($parser->toArray()['defaultValue']));
+
+        $parser = new TypeParser('Boolean');
+        $this->assertFalse($parser->isRequired());
+        $this->assertEquals('Boolean', $parser->getArgTypeName());
+        $this->assertNull($parser->getDefaultValue());
+
+        $parser = new TypeParser('Boolean=1');
+        $this->assertFalse($parser->isRequired());
+        $this->assertEquals('Boolean', $parser->getArgTypeName());
+        $this->assertEquals('1', $parser->getDefaultValue());
+		$this->assertTrue(is_bool($parser->toArray()['defaultValue']));
+
+        $parser = new TypeParser('String!=Test');
+        $arr = $parser->toArray();
+        $this->assertInstanceOf(NonNull::class, $arr['type']);
+        $this->assertInstanceOf(StringType::class, $arr['type']->getWrappedType());
+        $this->assertEquals('Test', $arr['defaultValue']);
+
+        $this->setExpectedException(InvalidArgumentException::class);
+        $parser = new TypeParser('  ... Nothing');
+
+        $this->setExpectedException(InvalidArgumentException::class);
+        $parser = (new TypeParser('Nothing'))->toArray();
+    }
+
+    public function testArgsParser()
+    {
+        $parsers = [
+            new ArgsParser([
+                'Test' => 'String'
+            ]),
+            new ArgsParser([
+                'Test' => Type::string()
+            ]),
+            new ArgsParser([
+                'Test' => ['type' => Type::string()]
+            ])
+        ];
+
+        foreach ($parsers as $parser) {
+            $arr = $parser->toArray();
+            $this->assertArrayHasKey('Test', $arr);
+            $this->assertArrayHasKey('type', $arr['Test']);
+            $this->assertInstanceOf(StringType::class, $arr['Test']['type']);
+        }
+    }
+
+
+    public function testOperationList()
+    {
+        $list = new OperationList();
+
+        $list->push(new MutationScaffolder('myMutation1', 'test1'));
+        $list->push(new MutationScaffolder('myMutation2', 'test2'));
+
+        $this->assertInstanceOf(
+            MutationScaffolder::class,
+            $list->findByName('myMutation1')
+        );
+        $this->assertFalse($list->findByName('myMutation3'));
+
+        $list->removeByName('myMutation2');
+        $this->assertEquals(1, $list->count());
+
+        $list->removeByName('nothing');
+        $this->assertEquals(1, $list->count());
+
+        $this->setExpectedException(InvalidArgumentException::class);
+        $list->push(new OperationList());
+    }
 
     protected function createOperationCreator($resolver = null)
     {

From 54de8f7f81382ef10c75bc500d785c7be31f6cf4 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 20 Dec 2016 15:55:50 +1300
Subject: [PATCH 15/66] API changes to put queries and mutations at top level,
 nested query support

---
 src/Scaffolding/DataObjectTypeTrait.php       |  18 +-
 .../Scaffolders/DataObjectScaffolder.php      | 354 +++++++++++-------
 .../Scaffolders/GraphQLScaffolder.php         | 121 +++++-
 src/Scaffolding/Util/ScaffoldingUtil.php      |  25 ++
 4 files changed, 346 insertions(+), 172 deletions(-)
 create mode 100644 src/Scaffolding/Util/ScaffoldingUtil.php

diff --git a/src/Scaffolding/DataObjectTypeTrait.php b/src/Scaffolding/DataObjectTypeTrait.php
index af2700db1..bf41121ac 100644
--- a/src/Scaffolding/DataObjectTypeTrait.php
+++ b/src/Scaffolding/DataObjectTypeTrait.php
@@ -4,6 +4,7 @@
 
 use SilverStripe\Core\Injector\Injector;
 use SilverStripe\Core\Config\Config;
+use SilverStripe\GraphQL\Scaffolding\Util\ScaffoldingUtil;
 
 /**
  * Offers a few helper methods for classes that are DataObject subclass bound.
@@ -38,7 +39,7 @@ public function getDataObjectClass()
      */
     public function typeName()
     {
-        return $this->typeNameForDataObject($this->dataObjectClass);
+        return ScaffoldingUtil::typeNameForDataObject($this->dataObjectClass);
     }
 
     /**
@@ -65,19 +66,4 @@ public function setDataObjectClass($class)
         return $this;
     }
 
-    /**
-     * Given a DataObject subclass name, transform it into a sanitised (and implicitly unique) type
-     * name suitable for the GraphQL schema
-     * 
-     * @param $class
-     * @return mixed
-     */
-    protected function typeNameForDataObject($class)
-    {
-        $typeName = Config::inst()->get($class, 'table_name', Config::UNINHERITED) ?:
-            Injector::inst()->get($class)->singular_name();
-
-        return preg_replace('/[^A-Za-z0-9_]/', '_', $typeName);
-    }
-
 }
\ No newline at end of file
diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
index 59a794d3b..da748611d 100644
--- a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -11,9 +11,12 @@
 use GraphQL\Type\Definition\Type;
 use SilverStripe\GraphQL\Scaffolding\OperationList;
 use SilverStripe\GraphQL\Scaffolding\Util\TypeParser;
+use SilverStripe\GraphQL\Scaffolding\Util\ScaffoldingUtil;
 use SilverStripe\GraphQL\Scaffolding\Creators\DataObjectTypeCreator;
 use SilverStripe\GraphQL\Scaffolding\DataObjectTypeTrait;
 use SilverStripe\Core\Config\Config;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\QueryScaffolder;
+use SilverStripe\Core\ClassInfo;
 
 /**
  * Scaffolds a DataObjectTypeCreator
@@ -23,19 +26,19 @@ class DataObjectScaffolder implements ManagerMutatorInterface, ScaffolderInterfa
     use DataObjectTypeTrait;
 
     /**
-     * @var OperationList
+     * @var array
      */
-    protected $queries;
+    protected $fields;
 
     /**
-     * @var  OperationList
+     * @var  SilverStripe\GraphQL\Scaffolding\OperationList
      */
-    protected $mutations;
+    protected $operations;
 
     /**
-     * @var array
+     * @var  SilverStripe\GraphQL\Scaffolding\OperationList     
      */
-    protected $fields;
+    protected $nestedQueries;
 
     /**
      * DataObjectScaffold constructor.
@@ -52,102 +55,19 @@ public function __construct($dataObjectClass)
 
         if (!is_subclass_of($dataObjectClass, DataObject::class)) {
             throw new InvalidArgumentException(sprintf(
-                'DataObjectScaffold must instantiate with a classname that is a subclass of %s',
-                DataObject::class
+                'DataObjectScaffold must instantiate with a classname that is a subclass of %s (%s given)',
+                DataObject::class,
+                $dataObjectClass
             ));
         }
 
-        $this->queries = OperationList::create([]);
-        $this->mutations = OperationList::create([]);
         $this->fields = ArrayList::create([]);
+        $this->operations = OperationList::create([]);
+        $this->nestedQueries = OperationList::create([]);
 
         $this->dataObjectClass = $dataObjectClass;
     }
 
-    /**
-     * Find or make a query
-     * @param $name
-     * @param null $resolver
-     * @return bool|QueryScaffolder
-     */
-    public function query($name, $resolver = null)
-    {
-        $query = $this->queries->findByName($name);
-
-        if ($query) {
-            return $query;
-        }
-
-        if ($scaffoldClass = self::getOperationScaffoldForName($name)) {
-            $operationScaffold = new $scaffoldClass($this->dataObjectClass);
-        } else {
-            $operationScaffold = new QueryScaffolder(
-                $name,
-                $this->typeName(),
-                $resolver
-            );
-        }
-
-        $this->queries->push($operationScaffold);
-
-        return $operationScaffold;
-    }
-
-
-    /**
-     * Find or make a mutation
-     * @param $name
-     * @param null $resolver
-     * @return bool|MutationScaffolder
-     */
-    public function mutation($name, $resolver = null)
-    {
-        $mutation = $this->mutations->findByName($name);
-
-        if ($mutation) {
-            return $mutation;
-        }
-
-        if ($scaffoldClass = self::getOperationScaffoldForName($name)) {
-            $operationScaffold = new $scaffoldClass($this->dataObjectClass);
-        } else {
-            $operationScaffold = new MutationScaffolder(
-                $name,
-                $this->typeName(),
-                $resolver
-            );
-        }
-
-        $this->mutations->push($operationScaffold);
-
-        return $operationScaffold;
-    }
-
-    /**
-     * Removes a mutation
-     * @param $name
-     * @return $this
-     */
-    public function removeMutation($name)
-    {
-        $this->mutations->removeByName($name);
-
-        return $this;
-    }
-
-
-    /**
-     * Removes a query
-     * @param $name
-     * @return $this
-     */
-    public function removeQuery($name)
-    {
-        $this->queries->removeByName($name);
-
-        return $this;
-    }
-
     /**
      * Adds visible fields.
      * @param array $fields
@@ -172,6 +92,34 @@ public function addField($field)
         return $this->addFields((array)$field);
     }
 
+    /**
+     * Adds all db fields, and optionally has_one
+     * 
+     * @param boolean $includeHasOne
+     * @return  $this
+     */
+    public function addAllFields($includeHasOne = false)
+    {
+    	$fields = $this->allFieldsFromDataObject($includeHasOne);
+
+    	return $this->addFields($fields);
+    }
+
+    /**
+     * Adds fields against a blacklist
+     * 
+     * @param array   $exclusions
+     * @param boolean $includeHasOne
+     * @return  $this
+     */
+    public function addAllFieldsExcept(array $exclusions, $includeHasOne = false)
+    {
+    	$fields = $this->allFieldsFromDataObject($includeHasOne);
+    	$filteredFields = array_diff($fields, $exclusions);
+
+    	return $this->addFields($filteredFields);
+    }
+
     /**
      * @param $field
      * @return $this
@@ -199,27 +147,90 @@ public function removeFields(array $fields)
     /**
      * @return array
      */
-    public function getQueries()
+    public function getFields()
     {
-        return $this->queries;
+        return $this->fields;
     }
 
     /**
-     * @return array
+     * @return OperationList
      */
-    public function getMutations()
+    public function getNestedQueries()
     {
-        return $this->mutations;
+    	return $this->nestedQueries;
     }
 
     /**
-     * @return array
+     * Removes an operation
+     * @param $name
+     * @return $this
      */
-    public function getFields()
+    public function removeOperation($identifier)
     {
-        return $this->fields;
+        $this->operations->removeByName($identifier);
+
+        return $this;
     }
 
+    public function nestedQuery($fieldName)
+    {
+    	$query = $this->nestedQueries->findByName($fieldName);
+
+    	if($query) {
+    		return $query;
+    	}
+
+    	$result = $this->getDataObjectInstance()->obj($fieldName);
+
+        if (!$result instanceof DataList && !$result instanceof ArrayList) {
+        	throw new InvalidArgumentException(sprintf(
+        		'%s::addNestedQuery() tried to add %s, but must be passed a method name or relation that returns a DataList or ArrayList',
+        		__CLASS__,
+        		$fieldName
+        	));
+        }
+
+        $typeName = ScaffoldingUtil::typeNameForDataObject($result->dataClass());
+
+        $queryScaffolder = new QueryScaffolder(
+        	$fieldName,
+        	$typeName,
+        	function ($obj) use ($fieldName) {        		
+        		return $obj->obj($fieldName);
+        	}
+        );
+
+        $this->nestedQueries->push($queryScaffolder);
+    }
+
+    /**
+     * Find or make an operation
+     * @param int $identifier
+     * 
+     * @return OperationScaffolder
+     */
+    public function operation($identifier)
+    {
+        $op = $this->operations->findByName($identifier);
+
+        if ($op) {
+            return $op;
+        }
+
+        if ($scaffoldClass = self::getOperationScaffoldForName($identifier)) {
+            $operationScaffold = new $scaffoldClass($this->dataObjectClass);
+        } else {
+        	throw new InvalidArgumentException(sprintf(
+        		'Invalid operation: %s added to %s',
+        		$identifier,
+        		$this->dataObjectClass
+        	));
+        }
+
+        $this->operations->push($operationScaffold);
+
+        return $operationScaffold;
+    }
 
     /**
      * Puts all of the configuration into a type creator
@@ -229,7 +240,7 @@ public function getCreator(Manager $manager)
     {
         $fieldMap = [];
         $instance = $this->getDataObjectInstance();
-        $extraDataObjects = $this->getExtraDataObjects();
+        $extraDataObjects = $this->nestedDataObjectTypes();
         $fields = array_unique($this->fields->toArray());
 
         if (empty($fields)) {
@@ -238,6 +249,15 @@ public function getCreator(Manager $manager)
 
         foreach ($fields as $fieldName) {
             $result = $instance->obj($fieldName);
+            if ($result instanceof DataList || $result instanceof ArrayList) {
+                throw new InvalidArgumentException(sprintf(
+                	'Fieldname %s added to %s returns a list. This should be defined as a nested query using addNestedQuery(%s)',
+                	$fieldName,
+                	$this->dataObjectClass,
+                	$fieldName
+                ));
+            }
+
             if ($result instanceof DBField) {
                 $typeName = $result->config()->graphql_type;
                 $fieldMap[$fieldName] = (new TypeParser($typeName))->toArray();
@@ -254,50 +274,35 @@ public function getCreator(Manager $manager)
 
         foreach ($extraDataObjects as $fieldName => $className) {
             $result = $instance->obj($fieldName);
-            $typeName = $this->typeNameForDataObject($className);
+            $typeName = ScaffoldingUtil::typeNameForDataObject($className);
 
-            if ($result instanceof DataList || $result instanceof ArrayList) {
-                $fieldMap[$fieldName] = [
-                    'type' => function () use ($manager, $typeName) {
-                        return Type::listOf($manager->getType($typeName));
-                    }
-                ];
-            } else {
-                $fieldMap[$fieldName] = [
-                    'type' => function () use ($manager, $typeName) {
-                        return $manager->getType($typeName);
-                    }
-                ];
-            }
+            $fieldMap[$fieldName] = [
+                'type' => function () use ($manager, $typeName) {
+                    return $manager->getType($typeName);
+                }
+            ];
+        }
+
+        foreach ($this->nestedQueries as $scaffolder) {
+        	$creator = $scaffolder->getCreator($manager);
+        	$fieldMap[$scaffolder->getName()] = $creator->toArray();
         }
 
         return new DataObjectTypeCreator($manager, $this->typeName(), $fieldMap);
     }
 
-
     /**
-     * Gets any DataObjects that are implicitly required by this type definition, e.g. has_one, has_many
+     * Gets types for all ancestors of this class that will need to be added
      * @return array
      */
-    public function getExtraDataObjects()
-    {
-        $types = [];
-        $instance = $this->getDataObjectInstance();
-        $fields = $this->fields->toArray();
-
-        foreach ($fields as $fieldName) {
-            $result = $instance->obj($fieldName);
-            if ($result instanceof DataList || $result instanceof ArrayList) {
-                $types[$fieldName] = $result->dataClass();
-            } else {
-                if ($result instanceof DataObjectInterface) {
-                    $types[$fieldName] = get_class($result);
-                }
-            }
-        }
-
-        return $types;
-    }
+    public function getDependentTypes()
+    {    	
+    	return array_merge(
+    		$this->ancestralTypes(),
+    		array_values($this->nestedDataObjectTypes()),
+    		array_values($this->nestedConnections())
+    	);
+    }	
 
 
     /**
@@ -307,21 +312,84 @@ public function getExtraDataObjects()
     public function addToManager(Manager $manager)
     {
         $creator = $this->getCreator($manager);
-
         if (!$manager->hasType($this->typeName())) {
             $manager->addType($creator->toType(), $this->typeName());
         }
 
-        foreach ($this->queries as $op) {
-            $op->addToManager($manager);
+        foreach($this->operations as $op) {
+        	$op->addToManager($manager);
         }
+    }
+
+    /**
+     * @param  boolean $includeHasOne
+     * @return array
+     */
+    protected function allFieldsFromDataObject($includeHasOne = false)
+    {
+    	$fields = [];
+    	$db = DataObject::config()->fixed_fields;
+    	$db = array_merge($db, Config::inst()->get($this->dataObjectClass, 'db', Config::INHERITED));
+
+    	foreach($db as $fieldName => $type) {
+    		$fields[] = $fieldName;
+    	}
+
+    	if($includeHasOne) {    		
+    		$hasOne = $this->getDataObjectInstance()->hasOne();
+    		foreach($hasOne as $fieldName => $class) {
+    			$fields[] = $fieldName;
+    		}
+    	}
+
+    	return $fields;
+    }
 
-        foreach ($this->mutations as $op) {
-            $op->addToManager($manager);
+    /**
+     * Gets any DataObjects that are implicitly required by this type definition, e.g. has_one, has_many
+     * @return array
+     */
+    protected function nestedDataObjectTypes()
+    {
+        $types = [];
+        $instance = $this->getDataObjectInstance();
+        $fields = $this->fields->toArray();
+
+        foreach ($fields as $fieldName) {
+            $result = $instance->obj($fieldName);
+            if ($result instanceof DataObjectInterface) {
+                $types[$fieldName] = get_class($result);
+            }
         }
 
+        return $types;
     }
 
+    protected function nestedConnections()
+    {
+    	$queries = [];
+    	foreach($this->nestedQueries as $q) {
+    		$queries[$q->getName()] = $this->getDataObjectInstance()
+    			->obj($q->getName())
+    			->dataClass();
+    	}
+
+    	return $queries;
+    }
+
+
+    protected function ancestralTypes()
+    {
+    	$types = [];
+    	$ancestry = array_reverse(ClassInfo::ancestry($this->dataObjectClass));
+    	
+    	foreach($ancestry as $class) {    		
+    		if($class == DataObject::class) break;
+    		$types[] = $class;
+    	}
+
+    	return $types;
+    }
 
     /**
      * @param $name
diff --git a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
index cbff65b27..50a6dd0f8 100644
--- a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
+++ b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
@@ -7,6 +7,8 @@
 use SilverStripe\GraphQL\Manager;
 use SilverStripe\GraphQL\Scaffolding\Creators\MutationOperationCreator;
 use SilverStripe\GraphQL\Scaffolding\Creators\QueryOperationCreator;
+use SilverStripe\GraphQL\Scaffolding\OperationList;
+use SilverStripe\GraphQL\Scaffolding\Util\ScaffoldingUtil;
 
 /**
  * The entry point for a GraphQL scaffolding definition. Holds DataObject type definitions,
@@ -28,6 +30,16 @@ class GraphQLScaffolder implements ManagerMutatorInterface
      */
     protected $scaffolds = [];
 
+    /**
+     * @var OperationList
+     */
+    protected $queries;
+
+    /**
+     * @var  OperationList
+     */
+    protected $mutations;
+	
     /**
      * Create from an array, e.g. derived from YAML
      *
@@ -45,7 +57,7 @@ public static function createFromConfig($config)
                 );
             }
 
-            $scaffolder->dataObject($dataObjectClass)
+            $scaffolder->type($dataObjectClass)
                 ->addFields($settings['fields']);
 
             if (isset($settings['operations'])) {
@@ -76,7 +88,7 @@ public static function createFromConfig($config)
                 }
                 foreach ($ops as $op) {
                     $method = ($op === GraphQLScaffolder::READ) ? 'query' : 'mutation';
-                    $scaffolder->dataObject($dataObjectClass)
+                    $scaffolder->type($dataObjectClass)
                         ->$method($op);
                 }
             }
@@ -94,7 +106,7 @@ public static function createFromConfig($config)
                             );
                         }
                         $args = isset($fieldSettings['args']) ? (array)$fieldSettings['args'] : [];
-                        $operation = $scaffolder->dataObject($dataObjectClass)
+                        $operation = $scaffolder->type($dataObjectClass)
                             ->$method($fieldName)
                             ->setResolver($fieldSettings['resolver'])
                             ->addArgs($args);
@@ -109,13 +121,22 @@ public static function createFromConfig($config)
         return $scaffolder;
     }
 
+    /**
+     * Constructor
+     */
+	public function __construct()
+	{
+        $this->queries = OperationList::create([]);
+        $this->mutations = OperationList::create([]);		
+	}    
+
     /**
      * Finds or makes a DataObject definition
      *
      * @param DataObjectScaffold $scaffold
      * @throws InvalidArgumentException
      */
-    public function dataObject($class, $typeName = null)
+    public function type($class, $typeName = null)
     {
         foreach ($this->scaffolds as $scaffold) {
             if ($scaffold->getDataObjectClass() == $class) {
@@ -129,6 +150,83 @@ public function dataObject($class, $typeName = null)
         return $scaffold;
     }
 
+    /**
+     * Find or make a query
+     * @param string $name
+     * @param  string $class
+     * @param null $resolver
+     * @return bool|QueryScaffolder
+     */
+    public function query($name, $class, $resolver = null)
+    {
+        $query = $this->queries->findByName($name);
+
+        if ($query) {
+            return $query;
+        }
+
+        $operationScaffold = new QueryScaffolder(
+            $name,
+            ScaffoldingUtil::typeNameForDataObject($class),
+            $resolver
+        );
+
+        $this->queries->push($operationScaffold);
+
+        return $operationScaffold;
+    }
+
+
+    /**
+     * Find or make a mutation
+     * @param  string $name
+     * @param  string  $class
+     * @param null $resolver
+     * @return bool|MutationScaffolder
+     */
+    public function mutation($name, $class, $resolver = null)
+    {
+        $mutation = $this->mutations->findByName($name);
+
+        if ($mutation) {
+            return $mutation;
+        }
+
+        $operationScaffold = new MutationScaffolder(
+            $name,
+            ScaffoldingUtil::typeNameForDataObject($class),
+            $resolver
+        );
+
+        $this->mutations->push($operationScaffold);
+
+        return $operationScaffold;
+    }
+
+    /**
+     * Removes a mutation
+     * @param $name
+     * @return $this
+     */
+    public function removeMutation($name)
+    {
+        $this->mutations->removeByName($name);
+
+        return $this;
+    }
+
+
+    /**
+     * Removes a query
+     * @param $name
+     * @return $this
+     */
+    public function removeQuery($name)
+    {
+        $this->queries->removeByName($name);
+
+        return $this;
+    }
 
     /**
      * Adds every DataObject and its dependencies to the Manager
@@ -137,20 +235,17 @@ public function dataObject($class, $typeName = null)
     public function addToManager(Manager $manager)
     {
         // Gather all new types that were implicitly added through
-        // addFields(), e.g. member->addFields(['Groups'])
-        $extraDataObjects = [];
+        // addFields() and addNestedQuery()
+        $types = [];
         foreach ($this->scaffolds as $scaffold) {
-            $types = $scaffold->getExtraDataObjects();
-            foreach ($types as $fieldName => $className) {
-                $extraDataObjects[] = $className;
-            }
+            $types = array_merge($types, $scaffold->getDependentTypes());
         }
 
-        $extraDataObjects = array_unique($extraDataObjects);
+        $types = array_unique($types);
 
         // Ensure that all these types exist in the scaffolder
-        foreach ($extraDataObjects as $className) {
-            $this->dataObject($className);
+        foreach ($types as $className) {
+            $this->type($className);
         }
 
         // Add all DataObjects to the manager
diff --git a/src/Scaffolding/Util/ScaffoldingUtil.php b/src/Scaffolding/Util/ScaffoldingUtil.php
new file mode 100644
index 000000000..704145a97
--- /dev/null
+++ b/src/Scaffolding/Util/ScaffoldingUtil.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Util;
+
+use SilverStripe\Core\Config\Config;
+use SilverStripe\Core\Injector\Injector;
+
+class ScaffoldingUtil
+{
+    /**
+     * Given a DataObject subclass name, transform it into a sanitised (and implicitly unique) type
+     * name suitable for the GraphQL schema
+     * 
+     * @param $class
+     * @return mixed
+     */
+    public static function typeNameForDataObject($class)
+    {
+        $typeName = Config::inst()->get($class, 'table_name', Config::UNINHERITED) ?:
+            Injector::inst()->get($class)->singular_name();
+
+        return preg_replace('/[^A-Za-z0-9_]/', '_', $typeName);
+    }
+
+}
\ No newline at end of file

From a47421aa8f43f7d09ebe8eed56cebf0d079e78c5 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 20 Dec 2016 23:10:36 +1300
Subject: [PATCH 16/66] Remove creators, major reorganisation

---
 src/Manager.php                               |   2 +-
 src/Pagination/PaginatedQueryCreator.php      |   4 +-
 .../Creators/DataObjectTypeCreator.php        |  74 ---
 .../Creators/MutationOperationCreator.php     |  25 -
 .../Creators/OperationCreatorTrait.php        |  74 ---
 .../PaginatedQueryOperationCreator.php        |  61 ---
 .../Creators/PolymorphicResolverTrait.php     |  35 --
 .../Creators/QueryOperationCreator.php        |  29 --
 src/Scaffolding/Interfaces/CRUDInterface.php  |   8 +
 src/Scaffolding/Interfaces/Configurable.php   |   8 +
 .../ManagerMutatorInterface.php               |   2 +-
 .../{ => Interfaces}/ResolverInterface.php    |   2 +-
 .../ScaffolderInterface.php                   |   4 +-
 .../{ => Interfaces}/ScaffoldingProvider.php  |   2 +-
 .../Create.php}                               |  44 +-
 src/Scaffolding/Scaffolders/CRUD/Delete.php   |  70 +++
 .../Read.php}                                 |  27 +-
 .../Update.php}                               |  70 +--
 .../Scaffolders/DataObjectScaffolder.php      | 443 +++++++++++-------
 .../Scaffolders/DeleteOperationScaffolder.php |  64 ---
 .../Scaffolders/GraphQLScaffolder.php         | 214 ++++-----
 .../Scaffolders/MutationScaffolder.php        |  32 +-
 .../Scaffolders/OperationScaffolder.php       | 111 +++--
 .../Scaffolders/PaginationScaffolder.php      |  22 +
 .../Scaffolders/QueryScaffolder.php           | 124 +++--
 src/Scaffolding/Traits/Chainable.php          |  20 +
 .../{ => Traits}/DataObjectTypeTrait.php      |   2 +-
 src/Scaffolding/{ => Util}/OperationList.php  |  19 +-
 src/Scaffolding/Util/ScaffoldingUtil.php      |   8 +
 29 files changed, 794 insertions(+), 806 deletions(-)
 delete mode 100644 src/Scaffolding/Creators/DataObjectTypeCreator.php
 delete mode 100644 src/Scaffolding/Creators/MutationOperationCreator.php
 delete mode 100644 src/Scaffolding/Creators/OperationCreatorTrait.php
 delete mode 100644 src/Scaffolding/Creators/PaginatedQueryOperationCreator.php
 delete mode 100644 src/Scaffolding/Creators/PolymorphicResolverTrait.php
 delete mode 100644 src/Scaffolding/Creators/QueryOperationCreator.php
 create mode 100644 src/Scaffolding/Interfaces/CRUDInterface.php
 create mode 100644 src/Scaffolding/Interfaces/Configurable.php
 rename src/Scaffolding/{Scaffolders => Interfaces}/ManagerMutatorInterface.php (81%)
 rename src/Scaffolding/{ => Interfaces}/ResolverInterface.php (85%)
 rename src/Scaffolding/{Scaffolders => Interfaces}/ScaffolderInterface.php (67%)
 rename src/Scaffolding/{ => Interfaces}/ScaffoldingProvider.php (83%)
 rename src/Scaffolding/Scaffolders/{CreateOperationScaffolder.php => CRUD/Create.php} (68%)
 create mode 100644 src/Scaffolding/Scaffolders/CRUD/Delete.php
 rename src/Scaffolding/Scaffolders/{ReadOperationScaffolder.php => CRUD/Read.php} (53%)
 rename src/Scaffolding/Scaffolders/{UpdateOperationScaffolder.php => CRUD/Update.php} (62%)
 delete mode 100644 src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php
 create mode 100644 src/Scaffolding/Scaffolders/PaginationScaffolder.php
 create mode 100644 src/Scaffolding/Traits/Chainable.php
 rename src/Scaffolding/{ => Traits}/DataObjectTypeTrait.php (96%)
 rename src/Scaffolding/{ => Util}/OperationList.php (83%)

diff --git a/src/Manager.php b/src/Manager.php
index 176509454..8b6beb244 100644
--- a/src/Manager.php
+++ b/src/Manager.php
@@ -11,7 +11,7 @@
 use GraphQL\Error;
 use GraphQL\Type\Definition\Type;
 use SilverStripe\Security\Member;
-use SilverStripe\GraphQL\Scaffolding\ScaffoldingProvider;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ScaffoldingProvider;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
 
 class Manager
diff --git a/src/Pagination/PaginatedQueryCreator.php b/src/Pagination/PaginatedQueryCreator.php
index 13cd6eeb3..41547b868 100644
--- a/src/Pagination/PaginatedQueryCreator.php
+++ b/src/Pagination/PaginatedQueryCreator.php
@@ -22,11 +22,11 @@ abstract class PaginatedQueryCreator extends QueryCreator implements OperationRe
     /**
      * @param Manager $manager
      */
-    public function __construct(Manager $manager)
+    public function __construct(Manager $manager, Connection $connection = null)
     {
         parent::__construct($manager);
 
-        $this->connection = $this->connection();
+        $this->connection = $connection ?: $this->connection();
     }
 
     /**
diff --git a/src/Scaffolding/Creators/DataObjectTypeCreator.php b/src/Scaffolding/Creators/DataObjectTypeCreator.php
deleted file mode 100644
index 92503b6a2..000000000
--- a/src/Scaffolding/Creators/DataObjectTypeCreator.php
+++ /dev/null
@@ -1,74 +0,0 @@
-<?php
-
-namespace SilverStripe\GraphQL\Scaffolding\Creators;
-
-use SilverStripe\GraphQL\TypeCreator;
-use SilverStripe\GraphQL\Manager;
-use SilverStripe\ORM\DataObjectInterface;
-use GraphQL\Type\Definition\ResolveInfo;
-
-/**
- * Creates a GraphQL type for a DataObject
- */
-class DataObjectTypeCreator extends TypeCreator
-{
-
-    /**
-     * @var string
-     */
-    protected $typeName;
-
-
-    /**
-     * @var array
-     */
-    protected $fieldsMap;
-
-
-    /**
-     * DataObjectTypeCreator constructor.
-     * @param Manager $manager
-     * @param string $typeName
-     * @param array $fields
-     */
-    public function __construct(Manager $manager, $typeName, $fields)
-    {
-        $this->typeName = $typeName;
-        $this->fieldsMap = $fields;
-
-        parent::__construct($manager);
-    }
-
-
-    /**
-     * @return array
-     */
-    public function attributes()
-    {
-        return [
-            'name' => $this->typeName
-        ];
-    }
-
-
-    /**
-     * @return array
-     */
-    public function fields()
-    {
-        return $this->fieldsMap;
-    }
-
-
-    /**
-     * @param DataObjectInterface $obj
-     * @param array $args
-     * @param $context
-     * @param ResolveInfo $info
-     * @return mixed
-     */
-    public function resolveField(DataObjectInterface $obj, array $args, $context, ResolveInfo $info)
-    {
-        return $obj->obj($info->fieldName);
-    }
-}
\ No newline at end of file
diff --git a/src/Scaffolding/Creators/MutationOperationCreator.php b/src/Scaffolding/Creators/MutationOperationCreator.php
deleted file mode 100644
index bcd54a5a0..000000000
--- a/src/Scaffolding/Creators/MutationOperationCreator.php
+++ /dev/null
@@ -1,25 +0,0 @@
-<?php
-
-namespace SilverStripe\GraphQL\Scaffolding\Creators;
-
-use SilverStripe\GraphQL\MutationCreator;
-
-/**
- * Creates a GraphQL mutation field
- */
-class MutationOperationCreator extends MutationCreator
-{
-    use OperationCreatorTrait;
-
-    /**
-     * @return \Closure
-     */
-    public function type()
-    {
-        return function () {
-            return $this->manager->getType($this->typeName);
-        };
-    }
-
-
-}
\ No newline at end of file
diff --git a/src/Scaffolding/Creators/OperationCreatorTrait.php b/src/Scaffolding/Creators/OperationCreatorTrait.php
deleted file mode 100644
index 9bf87e35a..000000000
--- a/src/Scaffolding/Creators/OperationCreatorTrait.php
+++ /dev/null
@@ -1,74 +0,0 @@
-<?php
-
-namespace SilverStripe\GraphQL\Scaffolding\Creators;
-
-use SilverStripe\GraphQL\Manager;
-
-/**
- * Injects Operation creator features into mutations and queries, which are different inheritance chains
- */
-trait OperationCreatorTrait
-{
-    use PolymorphicResolverTrait;
-    
-    /**
-     * @var string
-     */
-    protected $typeName;
-
-    /**
-     * @var string
-     */
-    protected $operationName;
-
-    /**
-     * @var array
-     */
-    protected $argsMap = [];
-
-    /**
-     * OperationCreatorTrait constructor.
-     * @param Manager $manager
-     * @param string $operationName
-     * @param string $typeName
-     * @param SilverStripe\GraphQL\Scaffolding\ResolverInterface|\Closure $resolver
-     * @param array $argsMap
-     */
-    public function __construct(Manager $manager, $operationName, $typeName, $resolver, $argsMap = [])
-    {
-        $this->typeName = $typeName;
-        $this->resolver = $resolver;
-        $this->operationName = $operationName;
-        $this->argsMap = $argsMap;
-
-        parent::__construct($manager);
-    }
-
-    /**
-     * @return array
-     */
-    public function attributes()
-    {
-        return [
-            'name' => $this->operationName
-        ];
-    }
-
-    /**
-     * @return array
-     */
-    public function args()
-    {
-        return $this->argsMap;
-    }
-
-    /**
-     * Overload the getResolver() method to be aware of the polymorphic resolvers
-     * @return mixed
-     */
-    public function getResolver()
-    {
-    	return $this->createResolverFunction();
-    }
-
-}
\ No newline at end of file
diff --git a/src/Scaffolding/Creators/PaginatedQueryOperationCreator.php b/src/Scaffolding/Creators/PaginatedQueryOperationCreator.php
deleted file mode 100644
index 9d3a1e491..000000000
--- a/src/Scaffolding/Creators/PaginatedQueryOperationCreator.php
+++ /dev/null
@@ -1,61 +0,0 @@
-<?php
-
-namespace SilverStripe\GraphQL\Scaffolding\Creators;
-
-use SilverStripe\GraphQL\Pagination\PaginatedQueryCreator;
-use SilverStripe\GraphQL\Pagination\Connection;
-use SilverStripe\GraphQL\Manager;
-
-class PaginatedQueryOperationCreator extends PaginatedQueryCreator
-{
-
-	use PolymorphicResolverTrait;
-	
-	/**
-	 * @var string
-	 */
-	protected $operationName;
-
-	/**
-	 * @param Manager    $manager       
-	 * @param Connection $connection    
-	 * @param string     $operationName 
-	 * @param string     $typeName      
-	 * @param Callable|ResolverInterface     $resolver  
-	 */
-	public function __construct(Manager $manager, Connection $connection, $operationName, $typeName, $resolver)
-	{
-		$this->connection = $connection;
-		$this->resolver = $resolver;
-		$this->operationName = $operationName;
-
-		parent::__construct($manager);
-
-        $this->connection
-        	->setConnectionType(function() use ($typeName) {
-           		return $this->manager->getType($typeName);
-        	})
-        	->setConnectionResolver($this->createResolverFunction());
-	}
-
-	/**
-	 * @return array
-	 */
-	public function attributes()
-	{
-		return [
-			'name' => $this->operationName
-		];
-	}
-
-	/**
-	 * This method usually builds a new Connection interface, but since it is
-	 * assigned in the constructor of this class, it's overloaded as a simple accessor
-	 * 
-	 * @return SilverStripe\GraphQL\Pagination\Connection;
-	 */
-	public function connection()
-	{
-		return $this->connection;
-	}
-}
\ No newline at end of file
diff --git a/src/Scaffolding/Creators/PolymorphicResolverTrait.php b/src/Scaffolding/Creators/PolymorphicResolverTrait.php
deleted file mode 100644
index f874c6799..000000000
--- a/src/Scaffolding/Creators/PolymorphicResolverTrait.php
+++ /dev/null
@@ -1,35 +0,0 @@
-<?php
-
-namespace SilverStripe\GraphQL\Scaffolding\Creators;
-
-use SilverStripe\GraphQL\Scaffolding\ResolverInterface;
-
-trait PolymorphicResolverTrait
-{
-    /**
-     * @var \Closure|SilverStripe\GraphQL\ResolverInterface
-     */
-    protected $resolver;
-
-    protected function createResolverFunction()
-    {
-        $resolver = $this->resolver;
-
-        return function () use ($resolver) {
-            $args = func_get_args();
-            if (is_callable($resolver)) {
-                return call_user_func_array($resolver, $args);
-            } else {
-                if ($resolver instanceof ResolverInterface) {
-                    return call_user_func_array([$resolver, 'resolve'], $args);
-                } else {
-                    throw new \Exception(sprintf(
-                        '%s resolver must be a closure or implement %s',
-                        __CLASS__,
-                        ResolverInterface::class
-                    ));
-                }
-            }
-        };
-    }
-}
\ No newline at end of file
diff --git a/src/Scaffolding/Creators/QueryOperationCreator.php b/src/Scaffolding/Creators/QueryOperationCreator.php
deleted file mode 100644
index 9413604a8..000000000
--- a/src/Scaffolding/Creators/QueryOperationCreator.php
+++ /dev/null
@@ -1,29 +0,0 @@
-<?php
-
-namespace SilverStripe\GraphQL\Scaffolding\Creators;
-
-use SilverStripe\GraphQL\Manager;
-use SilverStripe\GraphQL\QueryCreator;
-use GraphQL\Type\Definition\Type;
-
-/**
- * Creates a GraphQL query field
- */
-class QueryOperationCreator extends QueryCreator
-{
-
-    use OperationCreatorTrait;
-
-    /**
-     * @return \Closure
-     */
-    public function type()
-    {
-        return function () {
-            return Type::listOf($this->manager->getType(
-                $this->typeName
-            ));
-        };
-    }
-
-}
diff --git a/src/Scaffolding/Interfaces/CRUDInterface.php b/src/Scaffolding/Interfaces/CRUDInterface.php
new file mode 100644
index 000000000..b95d39a28
--- /dev/null
+++ b/src/Scaffolding/Interfaces/CRUDInterface.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Interfaces;
+
+interface CRUDInterface
+{
+    public function getIdentifier();
+}
diff --git a/src/Scaffolding/Interfaces/Configurable.php b/src/Scaffolding/Interfaces/Configurable.php
new file mode 100644
index 000000000..fe979d9a1
--- /dev/null
+++ b/src/Scaffolding/Interfaces/Configurable.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Interfaces;
+
+interface Configurable
+{
+    public function applyConfig(array $config);
+}
diff --git a/src/Scaffolding/Scaffolders/ManagerMutatorInterface.php b/src/Scaffolding/Interfaces/ManagerMutatorInterface.php
similarity index 81%
rename from src/Scaffolding/Scaffolders/ManagerMutatorInterface.php
rename to src/Scaffolding/Interfaces/ManagerMutatorInterface.php
index 6fb4d76d9..42a3ce9fb 100644
--- a/src/Scaffolding/Scaffolders/ManagerMutatorInterface.php
+++ b/src/Scaffolding/Interfaces/ManagerMutatorInterface.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
+namespace SilverStripe\GraphQL\Scaffolding\Interfaces;
 
 use SilverStripe\GraphQL\Manager;
 
diff --git a/src/Scaffolding/ResolverInterface.php b/src/Scaffolding/Interfaces/ResolverInterface.php
similarity index 85%
rename from src/Scaffolding/ResolverInterface.php
rename to src/Scaffolding/Interfaces/ResolverInterface.php
index 32136b5f6..00cbb7a29 100644
--- a/src/Scaffolding/ResolverInterface.php
+++ b/src/Scaffolding/Interfaces/ResolverInterface.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace SilverStripe\GraphQL\Scaffolding;
+namespace SilverStripe\GraphQL\Scaffolding\Interfaces;
 
 /**
  * Applied to classes that resolve queries or mutations
diff --git a/src/Scaffolding/Scaffolders/ScaffolderInterface.php b/src/Scaffolding/Interfaces/ScaffolderInterface.php
similarity index 67%
rename from src/Scaffolding/Scaffolders/ScaffolderInterface.php
rename to src/Scaffolding/Interfaces/ScaffolderInterface.php
index 937138169..a6bfaa060 100644
--- a/src/Scaffolding/Scaffolders/ScaffolderInterface.php
+++ b/src/Scaffolding/Interfaces/ScaffolderInterface.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
+namespace SilverStripe\GraphQL\Scaffolding\Interfaces;
 
 use SilverStripe\GraphQL\Manager;
 
@@ -13,5 +13,5 @@ interface ScaffolderInterface
      * @param Manager $manager
      * @return mixed
      */
-    public function getCreator(Manager $manager);
+    public function scaffold(Manager $manager);
 }
\ No newline at end of file
diff --git a/src/Scaffolding/ScaffoldingProvider.php b/src/Scaffolding/Interfaces/ScaffoldingProvider.php
similarity index 83%
rename from src/Scaffolding/ScaffoldingProvider.php
rename to src/Scaffolding/Interfaces/ScaffoldingProvider.php
index 1a4923b26..085cabeed 100644
--- a/src/Scaffolding/ScaffoldingProvider.php
+++ b/src/Scaffolding/Interfaces/ScaffoldingProvider.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace SilverStripe\GraphQL\Scaffolding;
+namespace SilverStripe\GraphQL\Scaffolding\Interfaces;
 
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
 
diff --git a/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php b/src/Scaffolding/Scaffolders/CRUD/Create.php
similarity index 68%
rename from src/Scaffolding/Scaffolders/CreateOperationScaffolder.php
rename to src/Scaffolding/Scaffolders/CRUD/Create.php
index 4c3c4c2e8..bdeeb3dce 100644
--- a/src/Scaffolding/Scaffolders/CreateOperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Create.php
@@ -1,26 +1,28 @@
 <?php
 
-namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
+namespace SilverStripe\GraphQL\Scaffolding\Scaffolders\CRUD;
 
-use SilverStripe\GraphQL\Scaffolding\DataObjectTypeTrait;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\MutationScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Traits\DataObjectTypeTrait;
 use GraphQL\Type\Definition\InputObjectType;
 use GraphQL\Type\Definition\Type;
 use SilverStripe\Core\Injector\Injector;
 use SilverStripe\Core\Config\Config;
 use SilverStripe\GraphQL\Scaffolding\Util\TypeParser;
-use SilverStripe\GraphQL\Manager;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\CRUDInterface;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
 use Exception;
 
 /**
- * A generic "create" operation for a DataObject
+ * A generic "create" operation for a DataObject.
  */
-class CreateOperationScaffolder extends MutationScaffolder
+class Create extends MutationScaffolder implements CRUDInterface
 {
-
     use DataObjectTypeTrait;
 
     /**
      * CreateOperationScaffolder constructor.
+     *
      * @param string $dataObjectClass
      */
     public function __construct($dataObjectClass)
@@ -28,7 +30,7 @@ public function __construct($dataObjectClass)
         $this->dataObjectClass = $dataObjectClass;
 
         parent::__construct(
-            'create' . ucfirst($this->typeName()),
+            'create'.ucfirst($this->typeName()),
             $this->typeName()
         );
 
@@ -46,7 +48,14 @@ public function __construct($dataObjectClass)
                 throw new Exception("Cannot create {$this->dataObjectClass}");
             }
         });
+    }
 
+    /**
+     * @return string`
+     */
+    public function getIdentifier()
+    {
+        return GraphQLScaffolder::CREATE;
     }
 
     /**
@@ -56,8 +65,8 @@ protected function createArgs()
     {
         return [
             'Input' => [
-                'type' => Type::nonNull($this->generateInputType())
-            ]
+                'type' => Type::nonNull($this->generateInputType()),
+            ],
         ];
     }
 
@@ -70,11 +79,11 @@ protected function generateInputType()
         $instance = $this->getDataObjectInstance();
 
         // Setup default input args.. Placeholder!
-		$db = (array) Config::inst()->get(
-			$this->dataObjectClass,
-			'db',
-			Config::INHERITED
-		);
+        $db = (array) Config::inst()->get(
+            $this->dataObjectClass,
+            'db',
+            Config::INHERITED
+        );
 
         unset($db['ID']);
 
@@ -87,9 +96,8 @@ protected function generateInputType()
         }
 
         return new InputObjectType([
-            'name' => $this->typeName() . 'CreateInputType',
-            'fields' => $fields
+            'name' => $this->typeName().'CreateInputType',
+            'fields' => $fields,
         ]);
-
     }
-}
\ No newline at end of file
+}
diff --git a/src/Scaffolding/Scaffolders/CRUD/Delete.php b/src/Scaffolding/Scaffolders/CRUD/Delete.php
new file mode 100644
index 000000000..cde53a8a3
--- /dev/null
+++ b/src/Scaffolding/Scaffolders/CRUD/Delete.php
@@ -0,0 +1,70 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Scaffolders\CRUD;
+
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\MutationScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Traits\DataObjectTypeTrait;
+use SilverStripe\ORM\DataList;
+use GraphQL\Type\Definition\Type;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\CRUDInterface;
+use Exception;
+
+/**
+ * A generic delete operation.
+ */
+class Delete extends MutationScaffolder implements CRUDInterface
+{
+    use DataObjectTypeTrait;
+
+    /**
+     * DeleteOperationScaffolder constructor.
+     *
+     * @param string $dataObjectClass
+     */
+    public function __construct($dataObjectClass)
+    {
+        $this->dataObjectClass = $dataObjectClass;
+
+        parent::__construct(
+            'delete'.ucfirst($this->typeName()),
+            $this->typeName()
+        );
+
+        $this->setResolver(function ($object, array $args, $context, $info) {
+            $results = DataList::create($this->dataObjectClass)
+                ->byIDs($args['IDs']);
+
+            foreach ($results as $obj) {
+                if ($obj->canDelete()) {
+                    $obj->delete();
+                } else {
+                    throw new Exception(sprintf(
+                        'Cannot delete %s with ID %s',
+                        $this->dataObjectClass,
+                        $obj->ID
+                    ));
+                }
+            }
+        });
+    }
+
+    /**
+     * @return string`
+     */
+    public function getIdentifier()
+    {
+        return GraphQLScaffolder::DELETE;
+    }
+
+    /**
+     * @return array
+     */
+    protected function createArgs()
+    {
+        return [
+            'IDs' => [
+                'type' => Type::nonNull(Type::listOf(Type::id())),
+            ],
+        ];
+    }
+}
diff --git a/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php b/src/Scaffolding/Scaffolders/CRUD/Read.php
similarity index 53%
rename from src/Scaffolding/Scaffolders/ReadOperationScaffolder.php
rename to src/Scaffolding/Scaffolders/CRUD/Read.php
index c4db154ab..23e494ec4 100644
--- a/src/Scaffolding/Scaffolders/ReadOperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Read.php
@@ -1,21 +1,23 @@
 <?php
 
-namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
+namespace SilverStripe\GraphQL\Scaffolding\Scaffolders\CRUD;
 
-use SilverStripe\GraphQL\Scaffolding\DataObjectTypeTrait;
-use SilverStripe\GraphQL\Scaffolding\Resolvers\Read;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\QueryScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Traits\DataObjectTypeTrait;
 use SilverStripe\ORM\DataList;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\CRUDInterface;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
 
 /**
- * Scaffolds a generic read operation for DataObjects
+ * Scaffolds a generic read operation for DataObjects.
  */
-class ReadOperationScaffolder extends QueryScaffolder
+class Read extends QueryScaffolder implements CRUDInterface
 {
-
     use DataObjectTypeTrait;
 
     /**
      * ReadOperationScaffolder constructor.
+     *
      * @param string $dataObjectClass
      */
     public function __construct($dataObjectClass)
@@ -25,15 +27,22 @@ public function __construct($dataObjectClass)
         $typeName = $this->getDataObjectInstance()->plural_name();
         $typeName = str_replace(' ', '', $typeName);
         $typeName = ucfirst($typeName);
-        $operationName = 'read' . $typeName;
+        $operationName = 'read'.$typeName;
 
         parent::__construct($operationName, $this->typeName());
 
         $this->setResolver(function ($object, array $args, $context, $info) {
             $list = DataList::create($this->dataObjectClass);
-            
+
             return $list;
         });
+    }
 
+    /**
+     * @return string`
+     */
+    public function getIdentifier()
+    {
+        return GraphQLScaffolder::READ;
     }
-}
\ No newline at end of file
+}
diff --git a/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php b/src/Scaffolding/Scaffolders/CRUD/Update.php
similarity index 62%
rename from src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php
rename to src/Scaffolding/Scaffolders/CRUD/Update.php
index 23b305eb4..79db2fcc2 100644
--- a/src/Scaffolding/Scaffolders/UpdateOperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Update.php
@@ -1,28 +1,28 @@
 <?php
 
-namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
+namespace SilverStripe\GraphQL\Scaffolding\Scaffolders\CRUD;
 
-use SilverStripe\GraphQL\Scaffolding\DataObjectTypeTrait;
-use SilverStripe\GraphQL\Scaffolding\Resolvers\Update;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\MutationScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Traits\DataObjectTypeTrait;
 use GraphQL\Type\Definition\InputObjectType;
-use SilverStripe\Core\Injector\Injector;
 use SilverStripe\Core\Config\Config;
 use SilverStripe\GraphQL\Scaffolding\Util\TypeParser;
 use SilverStripe\ORM\DataList;
 use SilverStripe\GraphQL\Manager;
 use GraphQL\Type\Definition\Type;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\CRUDInterface;
 use Exception;
 
 /**
- * Scaffolds a generic update operation for DataObjects
+ * Scaffolds a generic update operation for DataObjects.
  */
-class UpdateOperationScaffolder extends MutationScaffolder
+class Update extends MutationScaffolder implements CRUDInterface
 {
-
     use DataObjectTypeTrait;
 
     /**
      * UpdateOperationScaffolder constructor.
+     *
      * @param string $dataObjectClass
      */
     public function __construct($dataObjectClass)
@@ -30,20 +30,20 @@ public function __construct($dataObjectClass)
         $this->dataObjectClass = $dataObjectClass;
 
         parent::__construct(
-            'update' . ucfirst($this->typeName()),
+            'update'.ucfirst($this->typeName()),
             $this->typeName()
         );
 
         // Todo: this is totally half baked
-        $this->setResolver(function ($object, array $args, $context, $info) {            
+        $this->setResolver(function ($object, array $args, $context, $info) {
             $obj = DataList::create($this->dataObjectClass)
                 ->byID($args['ID']);
-            if(!$obj) {
-            	throw new Exception(sprintf(
-            		"%s with ID %s not found",
-            		$this->dataObjectClass,
-            		$args['ID']
-            	));
+            if (!$obj) {
+                throw new Exception(sprintf(
+                    '%s with ID %s not found',
+                    $this->dataObjectClass,
+                    $args['ID']
+                ));
             }
 
             if ($obj->canEdit()) {
@@ -53,17 +53,24 @@ public function __construct($dataObjectClass)
                 return $obj;
             } else {
                 throw new Exception(sprintf(
-                	"Cannot edit this %s",
-                	$this->dataObjectClass
+                    'Cannot edit this %s',
+                    $this->dataObjectClass
                 ));
             }
         });
-
     }
 
+    /**
+     * @return string`
+     */
+    public function getIdentifier()
+    {
+        return GraphQLScaffolder::UPDATE;
+    }
 
     /**
-     * Use a generated Input type, and require an ID
+     * Use a generated Input type, and require an ID.
+     *
      * @return array
      */
     protected function createArgs()
@@ -71,13 +78,14 @@ protected function createArgs()
         return [
             'ID' => (new TypeParser('ID!'))->toArray(),
             'Input' => [
-                'type' => Type::nonNull($this->generateInputType())
-            ]
+                'type' => Type::nonNull($this->generateInputType()),
+            ],
         ];
     }
 
     /**
-     * Based on the args provided, create an Input type to add to the Manager
+     * Based on the args provided, create an Input type to add to the Manager.
+     *
      * @return InputObjectType
      */
     protected function generateInputType()
@@ -86,14 +94,14 @@ protected function generateInputType()
         $instance = $this->getDataObjectInstance();
 
         // Setup default input args.. Placeholder!
-		$db = (array) Config::inst()->get(
-			$this->dataObjectClass,
-			'db',
-			Config::INHERITED
-		);
+        $db = (array) Config::inst()->get(
+            $this->dataObjectClass,
+            'db',
+            Config::INHERITED
+        );
 
         unset($db['ID']);
-        
+
         foreach ($db as $dbFieldName => $dbFieldType) {
             $result = $instance->obj($dbFieldName);
             $typeName = $result->config()->graphql_type;
@@ -103,8 +111,8 @@ protected function generateInputType()
         }
 
         return new InputObjectType([
-            'name' => $this->typeName() . 'UpdateInputType',
-            'fields' => $fields
+            'name' => $this->typeName().'UpdateInputType',
+            'fields' => $fields,
         ]);
     }
-}
\ No newline at end of file
+}
diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
index da748611d..17d264bb8 100644
--- a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -9,21 +9,26 @@
 use SilverStripe\ORM\FieldType\DBField;
 use SilverStripe\GraphQL\Manager;
 use GraphQL\Type\Definition\Type;
-use SilverStripe\GraphQL\Scaffolding\OperationList;
+use GraphQL\Type\Definition\ObjectType;
+use SilverStripe\GraphQL\Scaffolding\Util\OperationList;
 use SilverStripe\GraphQL\Scaffolding\Util\TypeParser;
 use SilverStripe\GraphQL\Scaffolding\Util\ScaffoldingUtil;
-use SilverStripe\GraphQL\Scaffolding\Creators\DataObjectTypeCreator;
-use SilverStripe\GraphQL\Scaffolding\DataObjectTypeTrait;
+use SilverStripe\GraphQL\Scaffolding\Traits\DataObjectTypeTrait;
 use SilverStripe\Core\Config\Config;
-use SilverStripe\GraphQL\Scaffolding\Scaffolders\QueryScaffolder;
 use SilverStripe\Core\ClassInfo;
+use SilverStripe\GraphQL\Scaffolding\Traits\Chainable;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ManagerMutatorInterface;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ScaffolderInterface;
+use SilverStripe\ORM\ArrayLib;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\Configurable;
 
 /**
- * Scaffolds a DataObjectTypeCreator
+ * Scaffolds a DataObjectTypeCreator.
  */
-class DataObjectScaffolder implements ManagerMutatorInterface, ScaffolderInterface
+class DataObjectScaffolder implements ManagerMutatorInterface, ScaffolderInterface, Configurable
 {
     use DataObjectTypeTrait;
+    use Chainable;
 
     /**
      * @var array
@@ -31,17 +36,18 @@ class DataObjectScaffolder implements ManagerMutatorInterface, ScaffolderInterfa
     protected $fields;
 
     /**
-     * @var  SilverStripe\GraphQL\Scaffolding\OperationList
+     * @var SilverStripe\GraphQL\Scaffolding\OperationList
      */
     protected $operations;
 
     /**
-     * @var  SilverStripe\GraphQL\Scaffolding\OperationList     
+     * @var SilverStripe\GraphQL\Scaffolding\OperationList
      */
     protected $nestedQueries;
 
     /**
      * DataObjectScaffold constructor.
+     *
      * @param string $dataObjectClass
      */
     public function __construct($dataObjectClass)
@@ -70,6 +76,7 @@ public function __construct($dataObjectClass)
 
     /**
      * Adds visible fields.
+     *
      * @param array $fields
      */
     public function addFields(array $fields)
@@ -85,43 +92,47 @@ public function addFields(array $fields)
 
     /**
      * @param $field
+     *
      * @return mixed
      */
     public function addField($field)
     {
-        return $this->addFields((array)$field);
+        return $this->addFields((array) $field);
     }
 
     /**
-     * Adds all db fields, and optionally has_one
-     * 
-     * @param boolean $includeHasOne
-     * @return  $this
+     * Adds all db fields, and optionally has_one.
+     *
+     * @param bool $includeHasOne
+     *
+     * @return $this
      */
     public function addAllFields($includeHasOne = false)
     {
-    	$fields = $this->allFieldsFromDataObject($includeHasOne);
+        $fields = $this->allFieldsFromDataObject($includeHasOne);
 
-    	return $this->addFields($fields);
+        return $this->addFields($fields);
     }
 
     /**
-     * Adds fields against a blacklist
-     * 
-     * @param array   $exclusions
-     * @param boolean $includeHasOne
-     * @return  $this
+     * Adds fields against a blacklist.
+     *
+     * @param array $exclusions
+     * @param bool  $includeHasOne
+     *
+     * @return $this
      */
     public function addAllFieldsExcept(array $exclusions, $includeHasOne = false)
     {
-    	$fields = $this->allFieldsFromDataObject($includeHasOne);
-    	$filteredFields = array_diff($fields, $exclusions);
+        $fields = $this->allFieldsFromDataObject($includeHasOne);
+        $filteredFields = array_diff($fields, $exclusions);
 
-    	return $this->addFields($filteredFields);
+        return $this->addFields($filteredFields);
     }
 
     /**
      * @param $field
+     *
      * @return $this
      */
     public function removeField($field)
@@ -133,6 +144,7 @@ public function removeField($field)
 
     /**
      * @param array $fields
+     *
      * @return $this
      */
     public function removeFields(array $fields)
@@ -155,14 +167,16 @@ public function getFields()
     /**
      * @return OperationList
      */
-    public function getNestedQueries()
+    public function getOperations()
     {
-    	return $this->nestedQueries;
+        return $this->operations;
     }
 
     /**
-     * Removes an operation
+     * Removes an operation.
+     *
      * @param $name
+     *
      * @return $this
      */
     public function removeOperation($identifier)
@@ -172,184 +186,242 @@ public function removeOperation($identifier)
         return $this;
     }
 
+    /**
+     * Finds or adds a nested query, e.g. has_many/many_many relation.
+     *
+     * @param string $fieldName
+     *
+     * @return OperationScaffolder
+     */
     public function nestedQuery($fieldName)
     {
-    	$query = $this->nestedQueries->findByName($fieldName);
+        $query = $this->nestedQueries->findByName($fieldName);
 
-    	if($query) {
-    		return $query;
-    	}
+        if ($query) {
+            return $query;
+        }
 
-    	$result = $this->getDataObjectInstance()->obj($fieldName);
+        $result = $this->getDataObjectInstance()->obj($fieldName);
 
         if (!$result instanceof DataList && !$result instanceof ArrayList) {
-        	throw new InvalidArgumentException(sprintf(
-        		'%s::addNestedQuery() tried to add %s, but must be passed a method name or relation that returns a DataList or ArrayList',
-        		__CLASS__,
-        		$fieldName
-        	));
+            throw new InvalidArgumentException(sprintf(
+                '%s::addNestedQuery() tried to add %s, but must be passed a method name or relation that returns a DataList or ArrayList',
+                __CLASS__,
+                $fieldName
+            ));
         }
 
         $typeName = ScaffoldingUtil::typeNameForDataObject($result->dataClass());
 
-        $queryScaffolder = new QueryScaffolder(
-        	$fieldName,
-        	$typeName,
-        	function ($obj) use ($fieldName) {        		
-        		return $obj->obj($fieldName);
-        	}
-        );
+        $queryScaffolder = (new QueryScaffolder(
+            $fieldName,
+            $typeName,
+            function ($obj) use ($fieldName) {
+                return $obj->obj($fieldName);
+            }
+        ))->setChainableParent($this);
 
         $this->nestedQueries->push($queryScaffolder);
+
+        return $queryScaffolder;
     }
 
     /**
-     * Find or make an operation
-     * @param int $identifier
-     * 
+     * Find or make an operation.
+     *
+     * @param string $operation
+     *
      * @return OperationScaffolder
      */
-    public function operation($identifier)
+    public function operation($operation)
     {
-        $op = $this->operations->findByName($identifier);
+        $scaffoldClass = OperationScaffolder::getOperationScaffoldFromIdentifier($operation);
 
-        if ($op) {
-            return $op;
+        if (!$scaffoldClass) {
+            throw new InvalidArgumentException(sprintf(
+                'Invalid operation: %s added to %s',
+                $operation,
+                $this->dataObjectClass
+            ));
         }
 
-        if ($scaffoldClass = self::getOperationScaffoldForName($identifier)) {
-            $operationScaffold = new $scaffoldClass($this->dataObjectClass);
-        } else {
-        	throw new InvalidArgumentException(sprintf(
-        		'Invalid operation: %s added to %s',
-        		$identifier,
-        		$this->dataObjectClass
-        	));
+        $operation = new $scaffoldClass($this->dataObjectClass);
+        $existing = $this->operations->findByType(get_class($operation));
+
+        if ($existing) {
+            return $existing;
         }
 
-        $this->operations->push($operationScaffold);
+        $this->operations->push(
+            $operation->setChainableParent($this)
+        );
+
+        return $operation;
+    }
 
-        return $operationScaffold;
+    /**
+     * Gets types for all ancestors of this class that will need to be added.
+     *
+     * @return array
+     */
+    public function getDependentClasses()
+    {
+        return array_merge(
+            array_values($this->nestedDataObjectClasses()),
+            array_values($this->nestedConnections())
+        );
     }
 
     /**
-     * Puts all of the configuration into a type creator
-     * @return DataObjectTypeCreator
+     * Gets the class ancestry back to DataObject.
+     *
+     * @return array
      */
-    public function getCreator(Manager $manager)
+    public function getAncestralClasses()
     {
-        $fieldMap = [];
-        $instance = $this->getDataObjectInstance();
-        $extraDataObjects = $this->nestedDataObjectTypes();
-        $fields = array_unique($this->fields->toArray());
+        $classes = [];
+        $ancestry = array_reverse(ClassInfo::ancestry($this->dataObjectClass));
 
-        if (empty($fields)) {
-        	$fields = Config::inst()->get(self::class, 'default_fields');        	
+        foreach ($ancestry as $class) {
+            if ($class == DataObject::class) {
+                break;
+            }
+            $classes[] = $class;
         }
 
-        foreach ($fields as $fieldName) {
-            $result = $instance->obj($fieldName);
-            if ($result instanceof DataList || $result instanceof ArrayList) {
+        return $classes;
+    }
+
+    public function applyConfig(array $config)
+    {
+        if (empty($config['fields']) || !is_array($config['fields'])) {
+            throw new \Exception(
+                "No array of fields defined for $dataObjectClass"
+            );
+        }
+
+        $this->addFields($config['fields']);
+
+        if (isset($config['fieldsExcept'])) {
+            if (!is_array($config['fieldsExcept'])) {
                 throw new InvalidArgumentException(sprintf(
-                	'Fieldname %s added to %s returns a list. This should be defined as a nested query using addNestedQuery(%s)',
-                	$fieldName,
-                	$this->dataObjectClass,
-                	$fieldName
+                    '"fieldsExcept" must be an array. See %s',
+                    $this->dataObjectClass
                 ));
             }
 
-            if ($result instanceof DBField) {
-                $typeName = $result->config()->graphql_type;
-                $fieldMap[$fieldName] = (new TypeParser($typeName))->toArray();
-            } else if(is_bool($result)) {
-            	$fieldMap[$fieldName] = ['type' => Type::boolean()];
-            } else if(is_int($result)) {
-            	$fieldMap[$fieldName] = ['type' => Type::int()];
-            } else if(is_float($result)) {
-            	$fieldMap[$fieldName] = ['type' => Type::float()];
-            } else {
-            	$fieldMap[$fieldName] = ['type' => Type::string()];
-            }
+            $this->addAllFieldsExcept($config['fieldsExcept']);
         }
 
-        foreach ($extraDataObjects as $fieldName => $className) {
-            $result = $instance->obj($fieldName);
-            $typeName = ScaffoldingUtil::typeNameForDataObject($className);
+        if (!isset($config['operations'])) {
+            return $this;
+        }
 
-            $fieldMap[$fieldName] = [
-                'type' => function () use ($manager, $typeName) {
-                    return $manager->getType($typeName);
-                }
+        if ($config['operations'] === '*') {
+            $config['operations'] = [
+                GraphQLScaffolder::CREATE => true,
+                GraphQLScaffolder::READ => true,
+                GraphQLScaffolder::UPDATE => true,
+                GraphQLScaffolder::DELETE => true,
             ];
         }
 
-        foreach ($this->nestedQueries as $scaffolder) {
-        	$creator = $scaffolder->getCreator($manager);
-        	$fieldMap[$scaffolder->getName()] = $creator->toArray();
+        if (!ArrayLib::is_associative($config['operations'])) {
+            throw new \Exception(
+                'Operations field must be a map of operation names to a map of settings, or true/false'
+            );
         }
 
-        return new DataObjectTypeCreator($manager, $this->typeName(), $fieldMap);
+        foreach ($config['operations'] as $opID => $opSettings) {
+            if ($opSettings === false) {
+                continue;
+            }
+
+            $this->operation($opID)
+                ->applyConfig((array) $opSettings);
+        }
+
+        if (isset($config['nestedQueries'])) {
+            if (!ArrayLib::is_associative($config['nestedQueries'])) {
+                throw new InvalidArgumentException(sprintf(
+                    '"nestedQueries" must be a map of relation name to a map of settings, or true/false. See %s',
+                    $this->dataObjectClass
+                ));
+            }
+
+            foreach ($config['nestedQueries'] as $relationName => $settings) {
+                if ($settings === false) {
+                    continue;
+                }
+                $queryScaffold = $this->nestedQuery($relationName)
+                    ->applyConfig((array) $settings);
+            }
+        }
+
+        return $this;
     }
 
     /**
-     * Gets types for all ancestors of this class that will need to be added
-     * @return array
+     * @param Manager $manager
+     *
+     * @return ObjectType
      */
-    public function getDependentTypes()
-    {    	
-    	return array_merge(
-    		$this->ancestralTypes(),
-    		array_values($this->nestedDataObjectTypes()),
-    		array_values($this->nestedConnections())
-    	);
-    }	
-
+    public function scaffold(Manager $manager)
+    {
+        return new ObjectType([
+            'name' => $this->typeName(),
+            'fields' => $this->createFields($manager),
+        ]);
+    }
 
     /**
-     * Adds the type to the Manager
+     * Adds the type to the Manager.
+     *
      * @param Manager $manager
      */
     public function addToManager(Manager $manager)
     {
-        $creator = $this->getCreator($manager);
+        $scaffold = $this->scaffold($manager);
         if (!$manager->hasType($this->typeName())) {
-            $manager->addType($creator->toType(), $this->typeName());
+            $manager->addType($scaffold, $this->typeName());
         }
 
-        foreach($this->operations as $op) {
-        	$op->addToManager($manager);
+        foreach ($this->operations as $op) {
+            $op->addToManager($manager);
         }
     }
 
     /**
-     * @param  boolean $includeHasOne
+     * @param bool $includeHasOne
+     *
      * @return array
      */
     protected function allFieldsFromDataObject($includeHasOne = false)
     {
-    	$fields = [];
-    	$db = DataObject::config()->fixed_fields;
-    	$db = array_merge($db, Config::inst()->get($this->dataObjectClass, 'db', Config::INHERITED));
-
-    	foreach($db as $fieldName => $type) {
-    		$fields[] = $fieldName;
-    	}
-
-    	if($includeHasOne) {    		
-    		$hasOne = $this->getDataObjectInstance()->hasOne();
-    		foreach($hasOne as $fieldName => $class) {
-    			$fields[] = $fieldName;
-    		}
-    	}
-
-    	return $fields;
+        $fields = [];
+        $db = DataObject::config()->fixed_fields;
+        $db = array_merge($db, Config::inst()->get($this->dataObjectClass, 'db', Config::INHERITED));
+
+        foreach ($db as $fieldName => $type) {
+            $fields[] = $fieldName;
+        }
+
+        if ($includeHasOne) {
+            $hasOne = $this->getDataObjectInstance()->hasOne();
+            foreach ($hasOne as $fieldName => $class) {
+                $fields[] = $fieldName;
+            }
+        }
+
+        return $fields;
     }
 
     /**
-     * Gets any DataObjects that are implicitly required by this type definition, e.g. has_one, has_many
+     * Gets any DataObjects that are implicitly required by this type definition, e.g. has_one, has_many.
+     *
      * @return array
      */
-    protected function nestedDataObjectTypes()
+    protected function nestedDataObjectClasses()
     {
         $types = [];
         $instance = $this->getDataObjectInstance();
@@ -367,48 +439,75 @@ protected function nestedDataObjectTypes()
 
     protected function nestedConnections()
     {
-    	$queries = [];
-    	foreach($this->nestedQueries as $q) {
-    		$queries[$q->getName()] = $this->getDataObjectInstance()
-    			->obj($q->getName())
-    			->dataClass();
-    	}
-
-    	return $queries;
-    }
-
+        $queries = [];
+        foreach ($this->nestedQueries as $q) {
+            $queries[$q->getName()] = $this->getDataObjectInstance()
+                ->obj($q->getName())
+                ->dataClass();
+        }
 
-    protected function ancestralTypes()
-    {
-    	$types = [];
-    	$ancestry = array_reverse(ClassInfo::ancestry($this->dataObjectClass));
-    	
-    	foreach($ancestry as $class) {    		
-    		if($class == DataObject::class) break;
-    		$types[] = $class;
-    	}
-
-    	return $types;
+        return $queries;
     }
 
-    /**
-     * @param $name
-     * @return null
-     */
-    protected static function getOperationScaffoldForName($name)
+    protected function createFields(Manager $manager)
     {
-        switch ($name) {
-            case GraphQLScaffolder::CREATE:
-                return CreateOperationScaffolder::class;
-            case GraphQLScaffolder::READ:
-                return ReadOperationScaffolder::class;
-            case GraphQLScaffolder::UPDATE:
-                return UpdateOperationScaffolder::class;
-            case GraphQLScaffolder::DELETE:
-                return DeleteOperationScaffolder::class;
+        $fieldMap = [];
+        $instance = $this->getDataObjectInstance();
+        $extraDataObjects = $this->nestedDataObjectClasses();
+        $fields = array_unique($this->fields->toArray());
+
+        if (empty($fields)) {
+            $fields = Config::inst()->get(self::class, 'default_fields');
         }
 
-        return null;
-    }
+        $resolver = function ($obj, $args, $context, $info) {
+            return $obj->obj($info->fieldName);
+        };
 
-}
\ No newline at end of file
+        foreach ($fields as $fieldName) {
+            if (!ScaffoldingUtil::isValidFieldName($instance, $fieldName)) {
+                throw new InvalidArgumentException(sprintf(
+                    'Invalid field "%s" on %s',
+                    $fieldName,
+                    $this->dataObjectClass
+                ));
+            }
+
+            $result = $instance->obj($fieldName);
+
+            if ($result instanceof DataList || $result instanceof ArrayList) {
+                throw new InvalidArgumentException(sprintf(
+                    'Fieldname %s added to %s returns a list. This should be defined as a nested query using addNestedQuery(%s)',
+                    $fieldName,
+                    $this->dataObjectClass,
+                    $fieldName
+                ));
+            }
+
+            if ($result instanceof DBField) {
+                $typeName = $result->config()->graphql_type;
+                $fieldMap[$fieldName] = (new TypeParser($typeName))->toArray();
+                $fieldMap[$fieldName]['resolve'] = $resolver;
+            }
+        }
+
+        foreach ($extraDataObjects as $fieldName => $className) {
+            $result = $instance->obj($fieldName);
+            $typeName = ScaffoldingUtil::typeNameForDataObject($className);
+
+            $fieldMap[$fieldName] = [
+                'type' => function () use ($manager, $typeName) {
+                    return $manager->getType($typeName);
+                },
+                'resolve' => $resolver,
+            ];
+        }
+
+        foreach ($this->nestedQueries as $scaffolder) {
+            $scaffold = $scaffolder->scaffold($manager);
+            $fieldMap[$scaffolder->getName()] = $scaffold;
+        }
+
+        return $fieldMap;
+    }
+}
diff --git a/src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php b/src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php
deleted file mode 100644
index 426a2d7de..000000000
--- a/src/Scaffolding/Scaffolders/DeleteOperationScaffolder.php
+++ /dev/null
@@ -1,64 +0,0 @@
-<?php
-
-namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
-
-use SilverStripe\GraphQL\Scaffolding\DataObjectTypeTrait;
-use SilverStripe\GraphQL\Scaffolding\Resolvers\Delete;
-use SilverStripe\ORM\DataList;
-use GraphQL\Type\Definition\Type;
-use GraphQL\Type\Definition\InputObjectType;
-use Exception;
-
-/**
- * A generic delete operation
- */
-class DeleteOperationScaffolder extends MutationScaffolder
-{
-
-    use DataObjectTypeTrait;
-
-    /**
-     * DeleteOperationScaffolder constructor.
-     * @param string $dataObjectClass
-     */
-    public function __construct($dataObjectClass)
-    {
-        $this->dataObjectClass = $dataObjectClass;
-
-        parent::__construct(
-            'delete' . ucfirst($this->typeName()),
-            $this->typeName()
-        );
-
-        $this->setResolver(function ($object, array $args, $context, $info) {
-            $results = DataList::create($this->dataObjectClass)
-                ->byIDs($args['IDs']);
-
-            foreach($results as $obj) {
-            	if($obj->canDelete()) {
-            		$obj->delete();
-            	} else {
-            		throw new Exception(sprintf(
-            			"Cannot delete %s with ID %s",
-            			$this->dataObjectClass,
-            			$obj->ID
-            		));
-            	}
-            }
-        });
-
-    }
-
-    /**
-     * @return array
-     */
-    protected function createArgs()
-    {
-    	return [
-    		'IDs' => [
-    			'type' => Type::nonNull(Type::listOf(Type::id()))
-    		]
-    	];
-    }	
-
-}
\ No newline at end of file
diff --git a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
index 50a6dd0f8..38dff6703 100644
--- a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
+++ b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
@@ -5,10 +5,10 @@
 use SilverStripe\Core\Injector\Injector;
 use Doctrine\Instantiator\Exception\InvalidArgumentException;
 use SilverStripe\GraphQL\Manager;
-use SilverStripe\GraphQL\Scaffolding\Creators\MutationOperationCreator;
-use SilverStripe\GraphQL\Scaffolding\Creators\QueryOperationCreator;
-use SilverStripe\GraphQL\Scaffolding\OperationList;
+use SilverStripe\GraphQL\Scaffolding\Util\OperationList;
 use SilverStripe\GraphQL\Scaffolding\Util\ScaffoldingUtil;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ManagerMutatorInterface;
+use SilverStripe\ORM\ArrayLib;
 
 /**
  * The entry point for a GraphQL scaffolding definition. Holds DataObject type definitions,
@@ -16,14 +16,13 @@
  */
 class GraphQLScaffolder implements ManagerMutatorInterface
 {
+    const CREATE = 'create';
 
-    const CREATE = 1;
+    const READ = 'read';
 
-    const READ = 2;
+    const UPDATE = 'update';
 
-    const UPDATE = 3;
-
-    const DELETE = 4;
+    const DELETE = 'delete';
 
     /**
      * @var array
@@ -36,84 +35,60 @@ class GraphQLScaffolder implements ManagerMutatorInterface
     protected $queries;
 
     /**
-     * @var  OperationList
+     * @var OperationList
      */
     protected $mutations;
-	
+
     /**
-     * Create from an array, e.g. derived from YAML
+     * Create from an array, e.g. derived from YAML.
      *
      * @param $config
+     *
      * @return mixed
+     *
      * @throws InvalidArgumentException
      */
     public static function createFromConfig($config)
     {
-        $scaffolder = Injector::inst()->create(GraphQLScaffolder::class);
-        foreach ($config as $dataObjectClass => $settings) {
-            if (empty($settings['fields']) || !is_array($settings['fields'])) {
-                throw new \Exception(
-                    "No array of fields defined for $dataObjectClass"
+        $scaffolder = Injector::inst()->create(self::class);
+        if (isset($config['types'])) {
+            if (!ArrayLib::is_associative($config['types'])) {
+                throw new InvalidArgumentException(
+                    '"types" must be a map of class name to settings.'
                 );
             }
 
-            $scaffolder->type($dataObjectClass)
-                ->addFields($settings['fields']);
-
-            if (isset($settings['operations'])) {
-                $ops = [];
-                if ($settings['operations'] === 'all') {
-                    $ops = [self::CREATE, self::READ, self::UPDATE, self::DELETE];
-                } else {
-                    if (is_array($settings['operations'])) {
-                        foreach ($settings['operations'] as $op) {
-                            $constStr = sprintf(
-                                '%s::%s',
-                                GraphQLScaffolder::class,
-                                strtoupper($op)
-                            );
-                            if (defined($constStr)) {
-                                $ops[] = constant($constStr);
-                            } else {
-                                throw new \Exception(
-                                    "Invalid operation: $op on $dataobjectClass"
-                                );
-                            }
-                        }
-                    } else {
-                        throw new \Exception(
-                            "Operations field must be an array of operations or 'all'"
-                        );
-                    }
-                }
-                foreach ($ops as $op) {
-                    $method = ($op === GraphQLScaffolder::READ) ? 'query' : 'mutation';
-                    $scaffolder->type($dataObjectClass)
-                        ->$method($op);
-                }
+            foreach ($config['types'] as $dataObjectClass => $settings) {
+                $scaffold = $scaffolder->type($dataObjectClass)
+                    ->applyConfig($settings);
             }
-            $queryMap = [
-                'queries' => 'query',
-                'mutations' => 'mutation'
-            ];
-
-            foreach ($queryMap as $group => $method) {
-                if (isset($settings[$group]) && is_array($settings[$group])) {
-                    foreach ($settings[$group] as $fieldName => $fieldSettings) {
-                        if (empty($fieldSettings['resolver'])) {
-                            throw new \Exception(
-                                "All queries and mutations must have a 'resolver' attribute"
-                            );
-                        }
-                        $args = isset($fieldSettings['args']) ? (array)$fieldSettings['args'] : [];
-                        $operation = $scaffolder->type($dataObjectClass)
-                            ->$method($fieldName)
-                            ->setResolver($fieldSettings['resolver'])
-                            ->addArgs($args);
-                        if($group === 'queries' && isset($fieldSettings['paginate'])) {
-                        	$operation->setUsePagination((boolean) $fieldSettings['paginate']);
-                        }
+        }
+
+        $queryMap = [
+            'queries' => 'query',
+            'mutations' => 'mutation',
+        ];
+
+        foreach ($queryMap as $group => $method) {
+            if (isset($config[$group])) {
+                if (!ArrayLib::is_associative($config[$group])) {
+                    throw new InvalidArgumentException(sprintf(
+                        '"%s" must be a map of operation name to settings.',
+                        $group
+                    ));
+                }
+
+                foreach ($config[$group] as $fieldName => $fieldSettings) {
+                    if (!isset($fieldSettings['type'])) {
+                        throw new InvalidArgumentException(sprintf(
+                            '"%s" must have a "type" field. See %s',
+                            $group,
+                            $queryName
+                        ));
                     }
+
+                    $scaffolder->$method($fieldName, $fieldSettings['type'])
+                        ->applyConfig($fieldSettings);
                 }
             }
         }
@@ -122,21 +97,22 @@ public static function createFromConfig($config)
     }
 
     /**
-     * Constructor
+     * Constructor.
      */
-	public function __construct()
-	{
+    public function __construct()
+    {
         $this->queries = OperationList::create([]);
-        $this->mutations = OperationList::create([]);		
-	}    
+        $this->mutations = OperationList::create([]);
+    }
 
     /**
-     * Finds or makes a DataObject definition
+     * Finds or makes a DataObject definition.
      *
      * @param DataObjectScaffold $scaffold
+     *
      * @throws InvalidArgumentException
      */
-    public function type($class, $typeName = null)
+    public function type($class)
     {
         foreach ($this->scaffolds as $scaffold) {
             if ($scaffold->getDataObjectClass() == $class) {
@@ -144,17 +120,20 @@ public function type($class, $typeName = null)
             }
         }
 
-        $scaffold = new DataObjectScaffolder($class, $typeName);
+        $scaffold = (new DataObjectScaffolder($class))
+                ->setChainableParent($this);
         $this->scaffolds[] = $scaffold;
 
         return $scaffold;
     }
 
     /**
-     * Find or make a query
+     * Find or make a query.
+     *
      * @param string $name
-     * @param  string $class
-     * @param null $resolver
+     * @param string $class
+     * @param null   $resolver
+     *
      * @return bool|QueryScaffolder
      */
     public function query($name, $class, $resolver = null)
@@ -165,23 +144,24 @@ public function query($name, $class, $resolver = null)
             return $query;
         }
 
-        $operationScaffold = new QueryScaffolder(
+        $operationScaffold = (new QueryScaffolder(
             $name,
             ScaffoldingUtil::typeNameForDataObject($class),
             $resolver
-        );
+        ))->setChainableParent($this);
 
         $this->queries->push($operationScaffold);
 
         return $operationScaffold;
     }
 
-
     /**
-     * Find or make a mutation
-     * @param  string $name
-     * @param  string  $class
-     * @param null $resolver
+     * Find or make a mutation.
+     *
+     * @param string $name
+     * @param string $class
+     * @param null   $resolver
+     *
      * @return bool|MutationScaffolder
      */
     public function mutation($name, $class, $resolver = null)
@@ -192,11 +172,11 @@ public function mutation($name, $class, $resolver = null)
             return $mutation;
         }
 
-        $operationScaffold = new MutationScaffolder(
+        $operationScaffold = (new MutationScaffolder(
             $name,
             ScaffoldingUtil::typeNameForDataObject($class),
             $resolver
-        );
+        ))->setChainableParent($this);
 
         $this->mutations->push($operationScaffold);
 
@@ -204,8 +184,10 @@ public function mutation($name, $class, $resolver = null)
     }
 
     /**
-     * Removes a mutation
+     * Removes a mutation.
+     *
      * @param $name
+     *
      * @return $this
      */
     public function removeMutation($name)
@@ -215,10 +197,11 @@ public function removeMutation($name)
         return $this;
     }
 
-
     /**
-     * Removes a query
+     * Removes a query.
+     *
      * @param $name
+     *
      * @return $this
      */
     public function removeQuery($name)
@@ -229,28 +212,47 @@ public function removeQuery($name)
     }
 
     /**
-     * Adds every DataObject and its dependencies to the Manager
+     * Adds every DataObject and its dependencies to the Manager.
+     *
      * @param Manager $manager
      */
     public function addToManager(Manager $manager)
     {
-        // Gather all new types that were implicitly added through
-        // addFields() and addNestedQuery()
-        $types = [];
         foreach ($this->scaffolds as $scaffold) {
-            $types = array_merge($types, $scaffold->getDependentTypes());
+            // Add dependent classes, e.g has_one, has_many nested queries
+            foreach ($scaffold->getDependentClasses() as $class) {
+                $this->type($class);
+            }
+            // The fields and operations explicitly exposed to the lowest type in the ancestry
+            $exposedFields = $scaffold->getFields();
+            $exposedOperations = $scaffold->getOperations();
+
+            // Expose all the ancestors, and add the exposed fields and operations
+            foreach ($scaffold->getAncestralClasses() as $class) {
+                $ancestorType = $this->type($class);
+                $inst = $ancestorType->getDataObjectInstance();
+                foreach ($exposedFields as $field) {
+                    if (ScaffoldingUtil::isValidFieldName($inst, $field)) {
+                        $ancestorType->addField($field);
+                    }
+                }
+                foreach ($exposedOperations as $op) {
+                    $ancestorType->operation($op->getIdentifier());
+                }
+            }
         }
 
-        $types = array_unique($types);
+        // Add all DataObjects to the manager
+        foreach ($this->scaffolds as $scaffold) {
+            $scaffold->addToManager($manager);
+        }
 
-        // Ensure that all these types exist in the scaffolder
-        foreach ($types as $className) {
-            $this->type($className);
+        foreach ($this->queries as $scaffold) {
+            $scaffold->addToManager($manager);
         }
 
-        // Add all DataObjects to the manager
-        foreach ($this->scaffolds as $scaffold) {
+        foreach ($this->mutations as $scaffold) {
             $scaffold->addToManager($manager);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Scaffolding/Scaffolders/MutationScaffolder.php b/src/Scaffolding/Scaffolders/MutationScaffolder.php
index ea8a0dce3..c0b2bc281 100644
--- a/src/Scaffolding/Scaffolders/MutationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/MutationScaffolder.php
@@ -3,39 +3,39 @@
 namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
 
 use SilverStripe\GraphQL\Manager;
-use SilverStripe\GraphQL\Scaffolding\Creators\MutationOperationCreator;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ManagerMutatorInterface;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ScaffolderInterface;
 
 /**
- * Scaffolds a GraphQL mutation field
+ * Scaffolds a GraphQL mutation field.
  */
 class MutationScaffolder extends OperationScaffolder implements ManagerMutatorInterface, ScaffolderInterface
 {
-
     /**
      * @param Manager $manager
      */
     public function addToManager(Manager $manager)
     {
-        $operationType = $this->getCreator($manager);
         $manager->addMutation(
-            $operationType->toArray(),
+            $this->scaffold($manager),
             $this->getName()
         );
     }
 
     /**
      * @param Manager $manager
-     * @return MutationOperationCreator
+     *
+     * @return array
      */
-    public function getCreator(Manager $manager)
+    public function scaffold(Manager $manager)
     {
-        return new MutationOperationCreator(
-            $manager,
-            $this->operationName,
-            $this->typeName,
-            $this->resolver,
-            $this->createArgs()
-        );
+        return [
+            'name' => $this->operationName,
+            'args' => $this->createArgs(),
+            'type' => function () use ($manager) {
+                return $manager->getType($this->typeName);
+            },
+            'resolve' => $this->createResolverFunction(),
+        ];
     }
-
-}
\ No newline at end of file
+}
diff --git a/src/Scaffolding/Scaffolders/OperationScaffolder.php b/src/Scaffolding/Scaffolders/OperationScaffolder.php
index d3434badf..72df3961c 100644
--- a/src/Scaffolding/Scaffolders/OperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/OperationScaffolder.php
@@ -4,15 +4,23 @@
 
 use Doctrine\Instantiator\Exception\InvalidArgumentException;
 use SilverStripe\GraphQL\Scaffolding\Util\ArgsParser;
-use SilverStripe\GraphQL\Scaffolding\ResolverInterface;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ResolverInterface;
 use SilverStripe\Core\Injector\Injector;
+use SilverStripe\GraphQL\Scaffolding\Traits\Chainable;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\CRUD\Read;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\CRUD\Create;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\CRUD\Update;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\CRUD\Delete;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\Configurable;
 
 /**
  * Provides functionality common to both operation scaffolders. Cannot
- * be a subclass due to their distinct inheritance chains
+ * be a subclass due to their distinct inheritance chains.
  */
-abstract class OperationScaffolder
+abstract class OperationScaffolder implements Configurable
 {
+    use Chainable;
+
     /**
      * @var string
      */
@@ -23,9 +31,8 @@ abstract class OperationScaffolder
      */
     protected $operationName;
 
-
     /**
-     * @var \Closure | SilverStripe\GraphQL\Scaffolding\ResolverInterface
+     * @var \Closure|SilverStripe\GraphQL\ResolverInterface
      */
     protected $resolver;
 
@@ -34,36 +41,30 @@ abstract class OperationScaffolder
      */
     protected $args = [];
 
-
     /**
-     * @param array $config
-     * @return OperationScaffolder
-     * @throws InvalidArgumentException
+     * @param $name
      */
-    public static function createFromConfig($typeName, $config)
+    public static function getOperationScaffoldFromIdentifier($name)
     {
-        if (!isset($config['name'])) {
-            throw new InvalidArgumentException(sprintf(
-                '%s::%s() config array must have a key for "name"',
-                __CLASS__,
-                __FUNCTION__
-            ));
+        switch ($name) {
+            case GraphQLScaffolder::CREATE:
+                return Create::class;
+            case GraphQLScaffolder::READ:
+                return Read::class;
+            case GraphQLScaffolder::UPDATE:
+                return Update::class;
+            case GraphQLScaffolder::DELETE:
+                return Delete::class;
         }
 
-        $operation = new static($config['name'], $typeName);
-
-        if (isset($config['resolver'])) {
-            $operation->setResolver($config['resolver']);
-        }
-
-        return $operation;
+        return null;
     }
 
-
     /**
      * OperationScaffolder constructor.
+     *
      * @param null $operationName
-     * @param  null $resolver Resolver|\Closure
+     * @param null $resolver      Resolver|\Closure
      */
     public function __construct($operationName, $typeName, $resolver = null)
     {
@@ -75,15 +76,16 @@ public function __construct($operationName, $typeName, $resolver = null)
         }
     }
 
-
     /**
      * Adds arguments to the mutation. e.g.
      * [
      *    'Email' => 'String!', // required
      *    'Limit' => 'Int=10', // optional, default value of 10
      *    'Featured' => 'Boolean'
-     * ]
+     * ].
+     *
      * @param array $args
+     *
      * @return $this
      */
     public function addArgs($args = [])
@@ -103,7 +105,9 @@ public function getName()
 
     /**
      * @param $resolver
+     *
      * @return $this
+     *
      * @throws InvalidArgumentException
      */
     public function setResolver($resolver)
@@ -114,8 +118,9 @@ public function setResolver($resolver)
             if (is_subclass_of($resolver, ResolverInterface::class)) {
                 $this->resolver = Injector::inst()->create($resolver);
             } else {
+                var_dump($resolver);
                 throw new InvalidArgumentException(sprintf(
-                    "%s::setResolver() accepts closures, instances of %s or names of resolver subclasses.",
+                    '%s::setResolver() accepts closures, instances of %s or names of resolver subclasses.',
                     __CLASS__,
                     ResolverInterface::class
                 ));
@@ -126,12 +131,56 @@ public function setResolver($resolver)
     }
 
     /**
-     * Parses the args to proper graphql-php spec
+     * @param array $config
+     *
+     * @return OperationScaffolder
+     */
+    public function applyConfig(array $config)
+    {
+        if (isset($config['args'])) {
+            $this->addArgs($config['args']);
+        }
+        if (isset($config['resolver'])) {
+            $this->setResolver($config['resolver']);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Based on the type of resolver, create a function that invokes it.
+     *
+     * @return Closure
+     */
+    protected function createResolverFunction()
+    {
+        $resolver = $this->resolver;
+
+        return function () use ($resolver) {
+            $args = func_get_args();
+            if (is_callable($resolver)) {
+                return call_user_func_array($resolver, $args);
+            } else {
+                if ($resolver instanceof ResolverInterface) {
+                    return call_user_func_array([$resolver, 'resolve'], $args);
+                } else {
+                    throw new \Exception(sprintf(
+                        '%s resolver must be a closure or implement %s',
+                        __CLASS__,
+                        ResolverInterface::class
+                    ));
+                }
+            }
+        };
+    }
+
+    /**
+     * Parses the args to proper graphql-php spec.
+     *
      * @return array
      */
     protected function createArgs()
     {
         return (new ArgsParser($this->args))->toArray();
     }
-
-}
\ No newline at end of file
+}
diff --git a/src/Scaffolding/Scaffolders/PaginationScaffolder.php b/src/Scaffolding/Scaffolders/PaginationScaffolder.php
new file mode 100644
index 000000000..37c75f0a8
--- /dev/null
+++ b/src/Scaffolding/Scaffolders/PaginationScaffolder.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
+
+use SilverStripe\GraphQL\Pagination\PaginatedQueryCreator;
+use SilverStripe\GraphQL\Pagination\Connection;
+use SilverStripe\GraphQL\Manager;
+
+class PaginationScaffolder extends PaginatedQueryCreator
+{
+
+	public function __construct(Manager $manager, Connection $connection)
+	{
+		$this->manager = $manager;
+		$this->connection = $connection;
+	}
+
+	public function connection()
+	{
+		return $this->connection;
+	}
+}
\ No newline at end of file
diff --git a/src/Scaffolding/Scaffolders/QueryScaffolder.php b/src/Scaffolding/Scaffolders/QueryScaffolder.php
index e0b628306..bb6f31fad 100644
--- a/src/Scaffolding/Scaffolders/QueryScaffolder.php
+++ b/src/Scaffolding/Scaffolders/QueryScaffolder.php
@@ -3,44 +3,43 @@
 namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
 
 use SilverStripe\GraphQL\Manager;
-use SilverStripe\GraphQL\Scaffolding\Creators\QueryOperationCreator;
-use SilverStripe\GraphQL\Scaffolding\Creators\PaginatedQueryOperationCreator;
 use SilverStripe\GraphQL\Pagination\Connection;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ManagerMutatorInterface;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ScaffolderInterface;
+use Doctrine\Instantiator\Exception\InvalidArgumentException;
 
 /**
- * Scaffolds a GraphQL query field
+ * Scaffolds a GraphQL query field.
  */
 class QueryScaffolder extends OperationScaffolder implements ManagerMutatorInterface, ScaffolderInterface
 {
+    /**
+     * @var bool
+     */
+    protected $usePagination = true;
 
-	/**
-	 * @var boolean
-	 */
-	protected $usePagination = true;
-
-	/**
-	 * @var array
-	 */
-	protected $sortableFields = [];
+    /**
+     * @var array
+     */
+    protected $sortableFields = [];
 
-	/**
-	 * @param boolean $bool
-	 */
-	public function setUsePagination($bool)
-	{
-		$this->usePagination = (boolean) $bool;
+    /**
+     * @param bool $bool
+     */
+    public function setUsePagination($bool)
+    {
+        $this->usePagination = (bool) $bool;
 
-		return $this;
-	}
+        return $this;
+    }
 
     /**
      * @param Manager $manager
      */
     public function addToManager(Manager $manager)
     {
-        $operationType = $this->getCreator($manager);
         $manager->addQuery(
-            $operationType->toArray(),
+            $this->scaffold($manager),
             $this->getName()
         );
     }
@@ -50,50 +49,75 @@ public function addToManager(Manager $manager)
      */
     public function addSortableFields($fields)
     {
-    	$this->sortableFields = array_unique(
-    		array_merge(
-    			$this->sortableFields,
-    			(array) $fields
-    		)
-    	);
-    	
-    	return $this;
+        $this->sortableFields = array_unique(
+            array_merge(
+                $this->sortableFields,
+                (array) $fields
+            )
+        );
+
+        return $this;
+    }
+
+    public function applyConfig(array $config)
+    {
+        parent::applyConfig($config);
+        if (isset($config['sortableFields'])) {
+            if (is_array($config['sortableFields'])) {
+                $this->addSortableFields($config['sortableFields']);
+            } else {
+                throw new InvalidArgumentException(sprintf(
+                    'sortableFields must be an array (see %s)',
+                    $this->typeName
+                ));
+            }
+        }
+        if (isset($config['paginate'])) {
+            $this->setUsePagination((bool) $config['paginate']);
+        }
+
+        return $this;
     }
 
     /**
-     * Creates a Connection for pagination
+     * Creates a Connection for pagination.
+     *
      * @return Connection
      */
-    protected function createConnection()
+    protected function createConnection(Manager $manager)
     {
+        $typeName = $this->typeName;
+
         return Connection::create($this->operationName)
+            ->setConnectionType(function () use ($manager, $typeName) {
+                return $manager->getType($typeName);
+            })
+            ->setConnectionResolver($this->createResolverFunction())
             ->setArgs($this->createArgs())
             ->setSortableFields($this->sortableFields);
     }
 
     /**
      * @param Manager $manager
-     * @return QueryOperationCreator
+     *
+     * @return array
      */
-    public function getCreator(Manager $manager)
+    public function scaffold(Manager $manager)
     {
-        if($this->usePagination) {
-        	return new PaginatedQueryOperationCreator(
-        		$manager,
-        		$this->createConnection(),
-        		$this->operationName,
-        		$this->typeName,
-        		$this->resolver
-        	);
+        if ($this->usePagination) {
+            return (new PaginationScaffolder(
+                $manager,
+                $this->createConnection($manager)
+            ))->toArray();
         }
 
-        return new QueryOperationCreator(
-            $manager,
-            $this->operationName,
-            $this->typeName,
-            $this->resolver,
-            $this->createArgs()
-        );
+        return [
+            'name' => $this->operationName,
+            'args' => $this->createArgs(),
+            'type' => function () use ($manager) {
+                return $manager->getType($this->typeName);
+            },
+            'resolve' => $this->createResolverFunction(),
+        ];
     }
 }
-
diff --git a/src/Scaffolding/Traits/Chainable.php b/src/Scaffolding/Traits/Chainable.php
new file mode 100644
index 000000000..2370b5a27
--- /dev/null
+++ b/src/Scaffolding/Traits/Chainable.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Traits;
+
+trait Chainable
+{
+	protected $chainableParent;
+
+	public function setChainableParent($parent)
+	{
+		$this->chainableParent = $parent;
+
+		return $this;
+	}
+
+	public function end()
+	{
+		return $this->chainableParent;
+	}
+}
\ No newline at end of file
diff --git a/src/Scaffolding/DataObjectTypeTrait.php b/src/Scaffolding/Traits/DataObjectTypeTrait.php
similarity index 96%
rename from src/Scaffolding/DataObjectTypeTrait.php
rename to src/Scaffolding/Traits/DataObjectTypeTrait.php
index bf41121ac..0350d7bb6 100644
--- a/src/Scaffolding/DataObjectTypeTrait.php
+++ b/src/Scaffolding/Traits/DataObjectTypeTrait.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace SilverStripe\GraphQL\Scaffolding;
+namespace SilverStripe\GraphQL\Scaffolding\Traits;
 
 use SilverStripe\Core\Injector\Injector;
 use SilverStripe\Core\Config\Config;
diff --git a/src/Scaffolding/OperationList.php b/src/Scaffolding/Util/OperationList.php
similarity index 83%
rename from src/Scaffolding/OperationList.php
rename to src/Scaffolding/Util/OperationList.php
index 0eb02bd06..b4642812f 100644
--- a/src/Scaffolding/OperationList.php
+++ b/src/Scaffolding/Util/OperationList.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace SilverStripe\GraphQL\Scaffolding;
+namespace SilverStripe\GraphQL\Scaffolding\Util;
 
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\OperationScaffolder;
 use SilverStripe\ORM\ArrayList;
@@ -48,7 +48,7 @@ public function push($item)
 
     /**
      * @param $name
-     * @return bool
+     * @return bool|OperationScaffold
      */
     public function findByName($name)
     {
@@ -61,6 +61,21 @@ public function findByName($name)
         return false;
     }
 
+    /**
+     * @param  string $class
+     * @return bool|OperationScaffold
+     */
+    public function findByType($class)
+    {
+    	foreach ($this->items as $key => $value) {
+    		if($class === get_class($value)) {
+    			return $value;
+    		}
+    	}
+
+    	return false;
+    }
+
     /**
      * @param $name
      */
diff --git a/src/Scaffolding/Util/ScaffoldingUtil.php b/src/Scaffolding/Util/ScaffoldingUtil.php
index 704145a97..3e8f2f915 100644
--- a/src/Scaffolding/Util/ScaffoldingUtil.php
+++ b/src/Scaffolding/Util/ScaffoldingUtil.php
@@ -4,6 +4,8 @@
 
 use SilverStripe\Core\Config\Config;
 use SilverStripe\Core\Injector\Injector;
+use SilverStripe\ORM\DataObjectInterface;
+use SilverStripe\ORM\FieldType\DBField;
 
 class ScaffoldingUtil
 {
@@ -22,4 +24,10 @@ public static function typeNameForDataObject($class)
         return preg_replace('/[^A-Za-z0-9_]/', '_', $typeName);
     }
 
+
+    public static function isValidFieldName(DataObjectInterface $instance, $fieldName)
+    {
+        return ($instance->hasMethod($fieldName) || $instance->hasField($fieldName));
+    }
+
 }
\ No newline at end of file

From 327f60cf499b22cf52234e7ab0515a9fafa70e66 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Fri, 23 Dec 2016 15:56:33 +1300
Subject: [PATCH 17/66] Update readme with new scaffolding api

---
 README.md                            |  656 ++++++++---
 examples/_config/config.yml          |   43 +
 examples/code/Comment.php            |   23 +
 examples/code/CommentsResolver.php   |   20 +
 examples/code/LatestPostResolver.php |   13 +
 examples/code/Post.php               |  131 +++
 examples/code/ReadResolver.php       |   20 +
 examples/code/UpdatePostResolver.php |   21 +
 src/Pagination/SortInputType.php     |   86 ++
 tests/ScaffoldingTest.php            | 1510 +++++++++++++-------------
 10 files changed, 1637 insertions(+), 886 deletions(-)
 create mode 100644 examples/code/Comment.php
 create mode 100644 examples/code/CommentsResolver.php
 create mode 100644 examples/code/LatestPostResolver.php
 create mode 100644 examples/code/Post.php
 create mode 100644 examples/code/ReadResolver.php
 create mode 100644 examples/code/UpdatePostResolver.php
 create mode 100644 src/Pagination/SortInputType.php

diff --git a/README.md b/README.md
index 06162aa5c..eba3509e1 100644
--- a/README.md
+++ b/README.md
@@ -498,7 +498,7 @@ Making a DataObject accessible through the GraphQL API involves quite a bit of b
 see that creating endpoints for a query and a mutation requires creating three new classes, along with an update to the 
 configuration, and we haven't even dealt with data relations yet. For applications that require a lot of business logic 
 and specific functionality, an architecture like this affords the developer a lot of control, but for developers who 
-just want to make a given model accessible through GraphQL with some basic create, cead, update, and delete operations, 
+just want to make a given model accessible through GraphQL with some basic create, read, update, and delete operations, 
 scaffolding them can save a lot of time and reduce the clutter in your project.
 
 Scaffolding DataObjects can be achieved in two non-exclusive ways:
@@ -513,7 +513,7 @@ The example code will show demonstrate both methods for each section.
 For these examples, we'll imagine we have the following model:
 
 ```php
-namespace My\Project;
+namespace MyProject\GraphQL;
 
 class Post extends DataObject {
 
@@ -526,6 +526,10 @@ class Post extends DataObject {
   	'Author' => 'SilverStripe\Security\Member'
   ];
 
+  private static $has_many = [
+  	'Comments' => 'MyProject\GraphQL\Comment'
+  ];
+
   private static $many_many = [
   	'Files' => 'SilverStripe\Assets\File'
   ];
@@ -542,7 +546,7 @@ We'll need to define a `scaffolding` node in the `SilverStripe\GraphQL.schema` s
 ```yaml
 SilverStripe\GraphQL:
   schema:
-    scaffolding:
+    scaffolding:      
       ## scaffolding will go here
 
 ```
@@ -556,8 +560,8 @@ bootstrap itself with any scaffolders that are registered in its config. These s
 As a `ScaffoldingProvider`, the class must now offer the `provideGraphQLScaffolding()` method.
 
 ```php
-namespace My\Project;
-use SilverStripe\GraphQL\Scaffolding\ScaffoldingProvider;
+namespace MyProject\GraphQL;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ScaffoldingProvider;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
 
 class Post extends DataObject implements ScaffoldingProvider {
@@ -575,7 +579,7 @@ In order to register the scaffolding provider with the manager, we'll need to ma
 SilverStripe\GraphQL:
   schema:
     scaffolding_providers:
-      - My\Project\Post
+      - MyProject\GraphQL\Post
 ```
 
 
@@ -585,24 +589,17 @@ Let's now expose the `Post` type. We'll choose the fields we want to offer, alon
 resolve queries and mutations, we'll need to specify the name of a resolver class. This class
 must implement the `SilverStripe\GraphQL\Scaffolding\ResolverInterface`. (More on this below).
 
-**YAML**:
+**Via YAML**:
 ```
 SilverStripe\GraphQL:
   schema:
-    scaffolding_providers:
-      - My\Project\Post
     scaffolding:
-      My\Project\Post:
-        fields: [ID, Title, Content]
-        queries:
-          readPosts:
-            resolver: MyResolver
-        mutations:
-          updatePostTitle:
-            args:
-              ID: 'ID!'
-              NewTitle: 'String!'
-            resolver: MyResolver
+      types:
+        MyProject\GraphQL\Post:
+          fields: [ID, Title, Content]
+          operations:
+            read: true
+            create: true
 ```
 
 We can now access the posts via GraphQL.
@@ -616,62 +613,111 @@ query {
 ```
 
 ```
-mutation UpdatePostTitle($ID: ID!, $NewTitle: String!) {
-	updatePostTitle(ID:$ID, NewTitle: $NewTitle) {
+mutation UpdatePost($ID: ID!, $Input: PostUpdateInputType!)
+	updatePost(ID:$ID, Input: { Title: "Some new Title" }) {
 		Title
 	}
 }
 ```
 
-**Code**:
+**...Or with code**:
 ```php
-namespace My\Project;
+namespace MyProject\GraphQL;
 
 class Post extends DataObject implements ScaffoldingProvider {
 	//...
     public function provideGraphQLScaffolding(GraphQLScaffolder $scaffolder)
     {
-    	$scaffolder->dataObject(Post::class)
-    		->addFields(['ID','Title','Content'])
-    		->query('readPosts', function() {
-    			if(Injector::inst()->get('Post')->canView()) {
-    				return Post::get()->limit(10);
-    			}
-    		});
-    	$scaffolder->dataObject(Post::class)
-    		->mutation('updatePostTitle')
-    		->addArgs([
-    			'ID' => 'ID!',
-    			'NewTitle' => 'String!'
-    		])
-    		->setResolver(function($obj, $args) {
-    			$post = Post::get()->byID($args['ID']);
-    			if($post->canEdit()) {
-	    			$post->Title = $args['NewTitle'];
-	    			$post->write();
-    			}
-
-    			return $post;
-    		});
+    	$scaffolder
+    		->type(Post::class)
+	    		->addFields(['ID','Title','Content'])
+	    		->operation(GraphQLScaffolder::READ)
+	    			->end()
+	    		->operation(GraphQLScaffolder::UPDATE)
+	    			->end()
+	    		->end();
 
     	return $scaffolder;
 	}
 }
 ```
 
+#### Adding arguments
+
+You can add arguments to basic crud operations, but keep in mind you'll need to use your own
+resolver, as the default resolvers will not be aware of any custom arguments you've allowed.
+
+Using YAML, simply use a map of options instead of `true`.
+
+**Via YAML**
+```yaml
+SilverStripe\GraphQL:
+  schema:
+    scaffolding:
+      types:
+        MyProject\GraphQL\Post:
+          fields: [ID, Title, Content]
+          operations:
+            read:
+              args:
+                StartingWith: String
+              resolver: MyProject\GraphQL\ReadPostResolver
+            create: true
+```
+
+**... Or with code**
+```php
+	$scaffolder
+		->type(Post::class)
+    		->addFields(['ID','Title','Content'])
+    		->operation(GraphQLScaffolder::READ)
+    			->addArgs([
+    				'StartingWith' => 'String'
+    			])
+        		->setResolver(function($obj, $args) {
+        			$list = Post::get();
+        			if(isset($args['StartingWith'])) {
+        				$list = $list->filter('Title:StartsWith', $args['StartingWith']);
+        			}
+
+        			return $list;
+        		})         	
+    			->end()
+    		->operation(GraphQLScaffolder::UPDATE)
+    			->end()
+    		->end();
+```
+
+**GraphQL**
+```
+query {
+  readPosts(StartingWith: "o") {
+    edges {
+      node {
+        Title
+        Content
+      }
+    }
+  }
+}
+```
+
+> Argument definitions are expressed using a shorthand. Append `!` to the argument type to
+make it required, and `=SomeValue` to set it to a default value, e.g. `'Category' => 'String!'` or
+`'Answer' => 'Int=42'`.
 
 #### Using a custom resolver
 
-The simplest way to add a resolver is via an anonymous function, passed as the optional second parameter to `mutation()` 
-or `query()`, or via the `setResolver()` method. Resolvers may also exist in class definitions that implement the 
+As seen in the code example above, the simplest way to add a resolver is via an anonymous function
+via the `setResolver()` method. In YAML, you can't define such functions, so resolvers be names or instances of classes thatt implement the 
 `ResolverInterface`.
 
 **When using the YAML approach, custom resolver classes are compulsory**, since you can't define closures in YAML.
 
 
 ```php
-namespace My\Project;
-use SilverStripe\GraphQL\Scaffolding\ResolverInterface;
+namespace MyProject\GraphQL;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ResolverInterface;
 
 class MyResolver implements ResolverInterface
 {
@@ -687,137 +733,485 @@ class MyResolver implements ResolverInterface
 This resolver class may now be assigned as either an instance, or a string to the query or mutation definition.
 
 ```php
-	$scaffolder->dataObject(Post::class)
-		->mutation('updatePostTitle')
-		->setResolver(MyResolver::class);
+	$scaffolder
+		->type(Post::class)
+			->operation(GraphQLScaffolder::UPDATE)
+				->setResolver(MyResolver::class)
+				->end();
 ```
 Or...
 ```php
-	$scaffolder->dataObject(Post::class)
-		->mutation('updatePostTitle')
-		->setResolver(new MyResolver());
+	$scaffolder
+		->type(Post::class)
+			->operation(GraphQLScaffolder::UPDATE)
+				->setResolver(new MyResolver())
+				->end();
 ```
+#### Configuring pagination and sorting
 
-#### Adding related objects
+By default, all queries are paginated and have no sortable fields. Both of these settings are
+configurable.
 
-Let's make the post author and attached files accessible through GraphQL. This requires only one small change.
+**Via YAML**
+```yaml
+SilverStripe\GraphQL:
+  schema:
+    scaffolding:
+      types:
+        MyProject\GraphQL\Post:
+          fields: [ID, Title, Content]
+          operations:
+            read:
+              args:
+                StartingWith: String
+              resolver: MyProject\GraphQL\ReadPostResolver
+              sortableFields: [Title]            
+            create: true
+        MyProject\GraphQL\Comment:
+          fields: [Comment, Author]
+          operations:
+            read:
+              paginate: false
+```
 
-**Code**:
+**... Or with code**
 ```php
-	$scaffolder->dataObject(Post::class)
-		->addFields(['ID','Title','Content','Author','Files'])
+	$scaffolder
+		->type(Post::class)
+    		->addFields(['ID','Title','Content'])
+    		->operation(GraphQLScaffolder::READ)
+    			->addArgs([
+    				'StartingWith' => 'String'
+    			])
+        		->setResolver(function($obj, $args) {
+        			$list = Post::get();
+        			if(isset($args['StartingWith'])) {
+        				$list = $list->filter('Title:StartsWith', $args['StartingWith']);
+        			}
+
+        			return $list;
+        		})
+        		->addSortableFields(['Title'])         	
+    			->end()
+    		->operation(GraphQLScaffolder::UPDATE)
+    			->end()
+    		->end()
+    	->type(Comment::class)
+    		->addFields(['Comment','Author'])
+    		->operation(GraphQLScaffolder::READ)
+    			->setUsePagination(false)
+    			->end();
+```
+
+**GraphQL**
+```
+query readPosts(StartingWith: "a", sortBy: [{field:Title, direction:DESC}]) {
+	edges {
+		node {
+			Title
+		}
+	}
+}
 ```
 
-**YAML**:
+```
+query readComments {
+	Author
+	Comment
+}
+```
+
+#### Adding related objects
+
+The `Post` type we're using has a `$has_one` relation to `Author` (Member), and plural relationships
+to `File` and `Comment`. Let's expose both of those to the query.
+
+For the `$has_one`, the relationship can simply be declared as a field. For `$has_many`, `$many_many`,
+and any custom getter that returns a `DataList`, we can set up a nested query.
+
+
+**Via YAML**:
 ```
 SilverStripe\GraphQL:
   schema:
     scaffolding:
-      My\Project\Post:
-        fields: [ID, Title, Content, Author, Files]
+      types:
+        MyProject\GraphQL\Post:
+          fields: [ID, Title, Content, Author]
+          operations:
+            read:
+              args:
+                StartingWith: String
+              resolver: MyProject\GraphQL\ReadPostResolver
+              sortableFields: [Title]            
+            create: true
+          nestedQueries:
+            Comments: true
+            Files: true
+        MyProject\GraphQL\Comment:
+          fields: [Comment, Author]
+          operations:
+            read:
+              paginate: false
+
+```
+
+**... Or with code**:
+```php
+	$scaffolder
+		->type(Post::class)
+    		->addFields(['ID','Title','Content', 'Author'])
+    		->operation(GraphQLScaffolder::READ)
+    			->addArgs([
+    				'StartingWith' => 'String'
+    			])
+        		->setResolver(function($obj, $args) {
+        			$list = Post::get();
+        			if(isset($args['StartingWith'])) {
+        				$list = $list->filter('Title:StartsWith', $args['StartingWith']);
+        			}
+
+        			return $list;
+        		})
+        		->addSortableFields(['Title'])         	
+    			->end()    			
+    		->operation(GraphQLScaffolder::UPDATE)
+    			->end()
+    		->nestedQuery('Comments')
+    			->end()
+    		->nestedQuery('Files')
+    			->end()
+    		->end()
+    	->type(Comment::class)
+    		->addFields(['Comment','Author'])
+    		->operation(GraphQLScaffolder::READ)
+    			->setUsePagination(false)
+    			->end();
+
+```
+
+**GraphQL**
+
+```
+query {
+  readPosts(StartingWith: "a") {
+    edges {
+      node {
+        Title
+        Content
+        Date
+        Author {
+        	ID
+        }
+        Comments {
+          edges {
+            node {
+              Comment
+            }
+          }
+        }
+        Files(limit: 2) {
+          edges {
+            node {
+            	ID
+            }
+          }
+        }
+      }
+    }
+  }
+}
 ```
 
-Relations are treated just like fields, and the new types are automatically detected, and added to the schema. By 
-default, these new types offer only `ID` as an exposed field (a configuration setting), so we'll probably want to 
-customise that a bit. 
+Notice that we can only query the `ID` field of `Files` and `Author`, our new related fields.
+This is because the types are implicitly created by the configuration, but only to the point that
+they exist in the schema. They won't eagerly add fields. That's still up to you. By default, you'll only
+get the `ID` field, as configured in `SilverStripe\GraphQL\Scaffolding\Scaffolders\DataObjectScaffolder.default_fields`.
+
+Let's add some more fields.
 
-**Code**:
+**Via YAML*:
+```yaml
+SilverStripe\GraphQL:
+  schema:
+    scaffolding:
+      types:
+        MyProject\GraphQL\Post:
+          ## ...
+        MyProject\GraphQL\Comment:
+          ## ...
+        SilverStripe\Security\Member
+          fields: [FirstName, Surname, Name, Email]
+        SilverStripe\Assets\File:
+          fields: [Filename, URL]
+```
+
+**... Or with code**
 ```php
-	$scaffolder->dataObject(Post::class)
-		->addFields(['ID','Title','Content','Author','Files'])
+	$scaffolder
+		->type(Post::class)
 		//...
-	$scaffolder->dataObject(Member::class)
-		->addFields(['ID','Name','Email','Groups']); // creates new type "Group"
-	$scaffolder->dataObject(File::class)
-		->addFields(['ID','Filename']);
-	$scaffolder->dataObject(Group::class)
-		->addFields(['ID','Title']);
+		->type(Member::class)
+			->addFields(['FirstName','Surname','Name','Email'])
+			->end()
+		->type(File::class)
+			->addFields(['Filename','URL'])
+			->end();
 ```
 
-**YAML**:
-```
+Notice that we can freely use the custom getter `Name` on the `Member` record. Fields and `$db` are not one-to-one.
+
+Nested queries can be configured just like operations.
+
+**Via YAML*:
+```yaml
 SilverStripe\GraphQL:
   schema:
     scaffolding:
-      My\Project\Post:
-        fields: [ID, Title, Content, Author, Files]
-        queries:
-          # ...
-        mutations:
-          # ...        
-      SilverStripe\Security\Member:
-        fields: [ID, Name, Email, Groups]
-      SilverStripe\Assets\File:
-        fields: [ID, Filename]
-      SilverStripe\Security\Group:
-        fields: [ID, Title]
+      types:
+        MyProject\GraphQL\Post:
+          ## ...
+          nestedQueries:
+            Comments:
+              args:
+                OnlyToday: Boolean
+                resolver: MyProject\GraphQL\CommentResolver
+          ##...
+        ##...
+```
 
+**... Or with code**
+```php
+	$scaffolder
+		->type(Post::class)
+			->nestedQuery('Comments')
+				->addArgs([
+					'OnlyToday' => 'Boolean'
+				])
+            	->setResolver(function($obj, $args, $context) {
+            		$comments = $obj->Comments();
+            		if(isset($args['OnlyToday']) && $args['OnlyToday']) {
+            			$comments = $comments->where('DATE(Created) = DATE(NOW())');
+            		}
+
+            		return $comments;
+            	})
+			->end()
+			//...
+		//...
 ```
 
-None of these new types have queries or mutations associated with them, but we can now access them as data related to 
-our `Post` object.
 
-Notice that we're able to use the computated value 'Name', which resolves to 'getName()' on the Member object. 
-Fields are not necessarily one-to-one with `$db`. They are simply any public method on the DataObject that returns a 
-`DataList`, `DataObject`, or `DBField`.
+**GraphQL**
 
 ```
 query {
-	readPosts {
-		Title
-		Content
-		Author {
-			Name
-			Groups {
-				Title
-			}
-		}
-		Files {
-			Filename
-		}
-	}
+  readPosts(StartingWith: "a") {
+    edges {
+      node {
+        Title
+        Content
+        Date
+        Author {
+        	Name
+        	Email
+        }
+        Comments(OnlyToday: true) {
+          edges {
+            node {
+              Comment
+            }
+          }
+        }
+        Files(limit: 2) {
+          edges {
+            node {
+            	Filename
+            	URL
+            }
+          }
+        }
+      }
+    }
+  }
 }
 ```
 
-### Ready-made CRUD operations
 
-Even with the fluency of scaffolding, many of these operations may look the same, and the resolver functions may start 
-to get repetitive with each simple read, create, edit, delete operation we offer. For basic CRUD definitions, you can 
-use the operations that come bundled with the scaffolder and save a lot configuration effort.
+#### Whitelisting fields in bulk
 
-These ready-made operations will automatically generate input types and add them to your schema. They offer very basic 
-functionality that checks for permission and performs a simple CRUD operation on your DataObject.
+If you have a type you want to be fairly well exposed, it can be tedious to add each
+field piecemeal. As a shortcut, you can use `addAllFieldsExcept()` (code) or `fieldsExcept` (yaml).
 
+**Via YAML**:
+```yaml
+SilverStripe\GraphQL:
+  schema:
+    scaffolding:
+      types:
+        MyProject\GraphQL\Post:
+          fieldsExcept: [SecretThing]
+```
 
-**Code:**
+**... Or with code**:
 ```php
-	$scaffolder->dataObject(Post::class)
-		->addFields(['ID','Title','Content','Author','Files'])
-		->query(GraphQLScaffolder::READ)
-		->mutation(GraphQLScaffolder::UPDATE)
-		->mutation(GraphQLScaffolder::DELETE)
-		->mutation(GraphQLScaffolder::CREATE)
+	$scaffolder
+		->type(Post::class)
+			->addAllFieldsExcept(['SecretThing'])
 ```
 
-For YAML, the API is slightly different. You'll need the `operations` setting for this.
+#### Adding arbitrary queries and mutations
 
-**YAML**:
+Not every operation maps to simple CRUD. For this, you can define custom queries and mutations
+in your schema, so long as they map to an existing type.
+
+**Via YAML**
 ```yaml
 SilverStripe\GraphQL:
   schema:
     scaffolding:
-      My\Project\Post:
-        operations: [CREATE, READ, UPDATE, DELETE]
+      types:
+        MyProject\GraphQL\Post:
+          ##...
+      mutations:
+        updatePostTitle:
+          type: MyProject\GraphQL\Post
+          args:
+            ID: ID!
+            NewTitle: String!
+          resolver: MyProject\GraphQL\UpdatePostResolver
+      queries:
+        latestPost:
+          type: MyProject\GraphQL\Post
+          paginate: false
+          resolver: MyProject\GraphQL\LatestPostResolver
 ```
 
-> As shorthand, the expression `[CREATE, READ, UPDATE, DELETE]` can also be expressed as `operations: all`.
+**... Or with code**:
+```php
+	$scaffolder
+		->type(Post::class)
+			//...            
+        ->mutation('updatePostTitle', Post::class)
+            ->addArgs([
+                'ID' => 'ID!',
+                'NewTitle' => 'String!'
+            ])
+            ->setResolver(function($obj, $args) {
+                $post = Post::get()->byID($args['ID']);
+                if($post->canEdit()) {
+                    $post->Title = $args['NewTitle'];
+                    $post->write();
+                }
 
-We now have a new queries and mutations with automatically generated names:
+                return $post;
+            })
+            ->end()
+	    ->query('latestPost', Post::class)
+        	->setUsePagination(false)
+        	->setResolver(function($obj, $args) {
+        		return Post::get()->sort('Date', 'DESC')->first();
+        	})
+        	->end()
+```
+
+**GraphQL**
+```
+mutation updatePostTitle(ID: 123, NewTitle: 'Foo') {
+	Title
+}
+```
+
+```
+query latestPost {
+	Title
+}
+```
+
+#### Dealing with inheritence
+
+Adding any given type will implicitly add all of its ancestors, all the way back to `DataObject`.
+Any fields you've listed on a descendant that are available on those ancestors will be exposed on the ancestors
+as well. For CRUD operations, each ancestor gets its own set of operations and input types.
+
+**Via YAML**:
+```yaml
+SilverStripe\GraphQL:
+  schema:
+    scaffolding:
+      types:
+        MyProject\GraphQL\Post:
+          ##...
+        SilverStripe\CMS\Model\RedirectorPage:
+          fields: [ExternalURL, Content]
+          operations:
+            read: true
+            create: true
+        Page:
+          fields: [MyCustomField]
+```
+
+**... Or with code**:
+```php
+	$scaffolder
+        ->type('SilverStripe\CMS\Model\RedirectorPage')
+        	->addFields(['ExternalURL','Content'])
+        	->operation(GraphQLScaffolder::READ)
+        		->end()
+        	->operation(GraphQLScaffolder::CREATE)
+        		->end()
+        	->end()
+        ->type('Page')
+        	->addFields(['MyCustomField'])
+        	->end();
+```
+
+We now have the following added to our schema:
+
+```
+type RedirectorPage {
+	ID
+	ExternalURL
+	Content
+	MyCustomField
+}
+
+type Page {
+	ID
+	Content
+	MyCustomField
+}
+
+type SiteTree {
+	ID
+	Content
+}
+
+query readRedirectorPages {
+	RedirectorPage
+}
+
+query readPages {
+	Page
+}
+
+query readSiteTrees {
+	SiteTree
+}
+
+mutation createRedirectorPage {
+	RedirectorPageCreateInputType
+}
+
+mutation createPage {
+	PageCreateInputType
+}
+
+mutation createSiteTree {
+	SiteTreeCreateInputType
+}
+```
 
-* readPosts
-* createPost(Input: PostCreateInputType)
-* updatePost(ID: ID!, Input: PostUpdateInputType)
-* deletePost(ID: ID!)
 
 ### Define Interfaces
 
diff --git a/examples/_config/config.yml b/examples/_config/config.yml
index b3717d611..46e6c3c35 100644
--- a/examples/_config/config.yml
+++ b/examples/_config/config.yml
@@ -12,3 +12,46 @@ SilverStripe\GraphQL:
   authenticators:
     - class: SilverStripe\GraphQL\Auth\BasicAuthAuthenticator
       priority: 10
+    scaffolding_providers:
+     - My\Project\Post
+    scaffolding:
+      types:
+        My\Project\Post:
+          fields: [ID, Title, Content, Author, Date]
+          nestedQueries:
+            Comments:
+              args:
+                Today: Boolean
+              sortableFields: [Author]
+              resolver: My\Project\CommentsResolver
+            Files: true
+          operations:
+            create: true
+            read:
+              args:
+                StartingWith: String
+              resolver: My\Project\ReadResolver
+        SilverStripe\Security\Member:
+          fields: [Name, FirstName, Surname, Email]
+        SilverStripe\Assets\File:
+          fieldsExcept: [Content]
+          fields: [File]
+        My\Project\Comment:
+          fields: [Comment, Author]
+        SilverStripe\CMS\Model\RedirectorPage:
+          fields: [ExternalURL, Content]
+          operations:
+            read: true
+            create: true
+      mutations:
+        updatePostTitle:
+          type: My\Project\Post
+          args:
+            ID: ID!
+            NewTitle: String!
+          resolver: My\Project\UpdatePostResolver
+      queries:
+        latestPost:
+          type: My\Project\Post
+          paginate: false
+          resolver: My\Project\LatestPostResolver
diff --git a/examples/code/Comment.php b/examples/code/Comment.php
new file mode 100644
index 000000000..83f045c3f
--- /dev/null
+++ b/examples/code/Comment.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace MyProject\GraphQL;
+
+use SilverStripe\ORM\DataObject;
+
+class Comment extends DataObject
+{
+	private static $db = [
+		'Comment' => 'Text',
+		'Author' => 'Varchar'
+	];
+
+	private static $has_one = [
+		'Post' => 'MyProject\GraphQL\Post'
+	];
+
+	public function canView($member = null, $context = []) { return true; }
+	public function canEdit($member = null, $context = []) { return true; }
+	public function canCreate($member = null, $context = []) { return true; }
+	public function canDelete($member = null, $context = []) { return true; }
+
+}
\ No newline at end of file
diff --git a/examples/code/CommentsResolver.php b/examples/code/CommentsResolver.php
new file mode 100644
index 000000000..e8ba64455
--- /dev/null
+++ b/examples/code/CommentsResolver.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace MyProject\GraphQL;
+
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ResolverInterface;
+
+class CommentsResolver implements ResolverInterface
+{
+    public function resolve($object, $args, $context, $info)
+    {
+		$comments = $object->Comments();
+		
+		if(isset($args['Today']) && $args['Today']) {
+			$comments = $comments->where('DATE(Created) = DATE(NOW())');
+		}
+
+		return $comments;
+    }
+
+}
\ No newline at end of file
diff --git a/examples/code/LatestPostResolver.php b/examples/code/LatestPostResolver.php
new file mode 100644
index 000000000..b7d0f058c
--- /dev/null
+++ b/examples/code/LatestPostResolver.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace MyProject\GraphQL;
+
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ResolverInterface;
+
+class LatestPostResolver implements ResolverInterface
+{
+    public function resolve($object, $args, $context, $info)
+    {
+        return Post::get()->sort('Date', 'DESC')->first();
+    }
+}
diff --git a/examples/code/Post.php b/examples/code/Post.php
new file mode 100644
index 000000000..ebf50b6c3
--- /dev/null
+++ b/examples/code/Post.php
@@ -0,0 +1,131 @@
+<?php
+
+namespace MyProject\GraphQL;
+
+use SilverStripe\ORM\DataObject;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ScaffoldingProvider;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
+use SilverStripe\Core\Injector\Injector;
+use SilverStripe\Security\Member;
+use SilverStripe\Assets\File;
+
+class Post extends DataObject implements ScaffoldingProvider {
+
+	private static $db = [
+		'Title' => 'Varchar',
+		'Content' => 'HTMLText',
+		'Date' => 'SilverStripe\ORM\FieldType\DBDateTime'
+	];
+
+	private static $has_one = [
+		'Author' => 'SilverStripe\Security\Member'
+	];
+
+	private static $many_many = [
+		'Files' => 'SilverStripe\Assets\File'
+	];
+
+	private static $has_many = [
+		'Comments' => 'MyProject\GraphQL\Comment'
+	];
+
+	public function provideGraphQLScaffolding(GraphQLScaffolder $scaffolder)
+	{
+        $scaffolder
+        	->type(Post::class)
+            	->addFields(['ID','Title','Content', 'Author', 'Date'])
+            	// basic many_many nested query, no options
+            	->nestedQuery('Files')
+	            	->end()
+	            // more complex nested query
+	            ->nestedQuery('Comments')
+	            	->addArgs([
+	            		'Today' => 'Boolean'
+	            	])
+	            	->addSortableFields(['Author'])
+	            	->setResolver(function($obj, $args, $context) {
+	            		$comments = $obj->Comments();
+	            		if(isset($args['Today']) && $args['Today']) {
+	            			$comments = $comments->where('DATE(Created) = DATE(NOW())');
+	            		}
+
+	            		return $comments;
+	            	})
+	            	->end()
+	            // basic crud operation, no options
+            	->operation(GraphQLScaffolder::CREATE)
+            		->end()
+
+            	// complex crud operation, with custom args
+            	->operation(GraphQLScaffolder::READ)
+            		->addArgs([
+            			'StartingWith' => 'String'
+            		])
+            		->setResolver(function($obj, $args) {
+            			$list = Post::get();
+            			if(isset($args['StartingWith'])) {
+            				$list = $list->filter('Title:StartsWith', $args['StartingWith']);
+            			}
+
+            			return $list;
+            		})         	
+            		->end()
+            	->end()
+
+            // these types were all created implicitly above. Add some fields to them.
+            ->type(Member::class)
+            	->addFields(['Name','FirstName', 'Surname', 'Email'])
+            	->end()
+            ->type(File::class)
+            	->addAllFieldsExcept(['Content'])
+            	->addFields(['File'])
+            	->end()
+            ->type(Comment::class)
+            	->addFields(['Comment','Author'])
+            	->end()
+
+            // Arbitrary mutation
+            ->mutation('updatePostTitle', Post::class)
+	            ->addArgs([
+	                'ID' => 'ID!',
+	                'NewTitle' => 'String!'
+	            ])
+	            ->setResolver(function($obj, $args) {
+	                $post = Post::get()->byID($args['ID']);
+	                if($post->canEdit()) {
+	                    $post->Title = $args['NewTitle'];
+	                    $post->write();
+	                }
+
+	                return $post;
+	            })
+	            ->end()
+
+	        // Arbitrary query
+	        ->query('latestPost', Post::class)
+	        	->setUsePagination(false)
+	        	->setResolver(function($obj, $args) {
+	        		return Post::get()->sort('Date', 'DESC')->first();
+	        	})
+	        	->end()
+	        ->type('SilverStripe\CMS\Model\RedirectorPage')
+	        	->addFields(['ExternalURL','Content'])
+	        	->operation(GraphQLScaffolder::READ)
+	        		->end()
+	        	->operation(GraphQLScaffolder::CREATE)
+	        		->end()
+	        	->end()
+	        ->type('Page')
+	        	->addFields(['BackwardsTitle'])
+	        	->end();
+
+
+
+        return $scaffolder;		
+	}  
+
+	public function canView($member = null, $context = []) { return true; }
+	public function canEdit($member = null, $context = []) { return true; }
+	public function canCreate($member = null, $context = []) { return true; }
+	public function canDelete($member = null, $context = []) { return true; }
+}
\ No newline at end of file
diff --git a/examples/code/ReadResolver.php b/examples/code/ReadResolver.php
new file mode 100644
index 000000000..c31b2ac40
--- /dev/null
+++ b/examples/code/ReadResolver.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace MyProject\GraphQL;
+
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ResolverInterface;
+
+class ReadResolver implements ResolverInterface
+{
+    public function resolve($object, $args, $context, $info)
+    {
+		$list = Post::get();
+		
+		if(isset($args['StartingWith'])) {
+			$list = $list->filter('Title:StartsWith', $args['StartingWith']);
+		}
+
+		return $list;
+    }
+
+}
\ No newline at end of file
diff --git a/examples/code/UpdatePostResolver.php b/examples/code/UpdatePostResolver.php
new file mode 100644
index 000000000..4f14b456a
--- /dev/null
+++ b/examples/code/UpdatePostResolver.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace MyProject\GraphQL;
+
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ResolverInterface;
+
+class UpdatePostResolver implements ResolverInterface
+{
+    public function resolve($object, $args, $context, $info)
+    {
+		$post = Post::get()->byID($args['ID']);
+		
+		if($post->canEdit()) {
+			$post->Title = $args['NewTitle'];
+			$post->write();
+		}
+
+		return $post;
+    }
+
+}
\ No newline at end of file
diff --git a/src/Pagination/SortInputType.php b/src/Pagination/SortInputType.php
new file mode 100644
index 000000000..c30c9d594
--- /dev/null
+++ b/src/Pagination/SortInputType.php
@@ -0,0 +1,86 @@
+<?php
+
+namespace SilverStripe\GraphQL\Pagination;
+
+use GraphQL\Type\Definition\Type;
+use GraphQL\Type\Definition\InputObjectType;
+use SilverStripe\Core\Injector\Injector;
+use SilverStripe\Core\Injector\Injectable;
+use GraphQL\Type\Definition\EnumType;
+
+class SortInputType
+{
+    use Injectable;
+
+    /**
+     * @var InputObjectType
+     */
+    private $type;
+
+    /**
+     * @var string
+     */
+    private $inputName;
+
+    /**
+     * @var array Keyed by field argument name, values as DataObject column names.
+     *            Does not support in-memory sorting for composite values (getters)
+     */
+    protected $sortableFields = [];
+
+    public function __construct($name)
+    {
+        $this->inputName = $name;
+    }
+
+    /**
+     * @param array $sortableFields
+     *
+     * @return $this
+     */
+    public function setSortableFields($sortableFields)
+    {
+        $this->sortableFields = $sortableFields;
+
+        return $this;
+    }
+
+    /**
+     * @return Type
+     */
+    public function toType()
+    {
+        $values = [];
+
+        foreach ($this->sortableFields as $fieldAlias => $fieldName) {
+            $values[$fieldAlias] = [
+                'value' => $fieldAlias,
+            ];
+        }
+
+        $sortableField = new EnumType([
+            'name' => ucfirst($this->inputName).'SortFieldType',
+            'description' => 'Field name to sort by.',
+            'values' => $values,
+        ]);
+
+        if (!$this->type) {
+            $this->type = new InputObjectType([
+                'name' => ucfirst($this->inputName).'SortInputType',
+                'description' => 'Define the sorting',
+                'fields' => [
+                    'field' => [
+                        'type' => Type::nonNull($sortableField),
+                        'description' => 'Sort field name.',
+                    ],
+                    'direction' => [
+                        'type' => Injector::inst()->get(SortDirectionType::class)->toType(),
+                        'description' => 'Sort direction (ASC / DESC)',
+                    ],
+                ],
+            ]);
+        }
+
+        return $this->type;
+    }
+}
diff --git a/tests/ScaffoldingTest.php b/tests/ScaffoldingTest.php
index d4e35459a..a01210d66 100644
--- a/tests/ScaffoldingTest.php
+++ b/tests/ScaffoldingTest.php
@@ -3,787 +3,787 @@
 namespace SilverStripe\GraphQL;
 
 use SilverStripe\Dev\SapphireTest;
-use GraphQL\Type\Definition\Type;
-use GraphQL\Type\Definition\NonNull;
-use GraphQL\Type\Definition\InputObjectType;
-use SilverStripe\GraphQL\Scaffolding\Creators\DataObjectTypeCreator;
-use SilverStripe\GraphQL\Manager;
-use GraphQL\Type\Definition\ResolveInfo;
-use GraphQL\Type\Definition\ObjectType;
-use GraphQL\Type\Definition\ListOfType;
-use GraphQL\Type\Definition\StringType;
-use GraphQL\Type\Definition\IntType;
-use SilverStripe\GraphQL\Tests\Fake\DataObjectFake;
-use SilverStripe\GraphQL\Scaffolding\Creators\MutationOperationCreator;
-use SilverStripe\GraphQL\Scaffolding\Creators\QueryOperationCreator;
-use SilverStripe\GraphQL\Scaffolding\Creators\PaginatedQueryOperationCreator;
-use SilverStripe\GraphQL\Tests\Fake\FakeResolver;
-use SilverStripe\GraphQL\Scaffolding\Scaffolders\MutationScaffolder;
-use SilverStripe\GraphQL\Scaffolding\Scaffolders\OperationScaffolder;
-use SilverStripe\GraphQL\Scaffolding\Scaffolders\DataObjectScaffolder;
-use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
-use SilverStripe\GraphQL\Scaffolding\Scaffolders\QueryScaffolder;
-use SilverStripe\GraphQL\Scaffolding\Scaffolders\CreateOperationScaffolder;
-use SilverStripe\GraphQL\Scaffolding\Scaffolders\UpdateOperationScaffolder;
-use SilverStripe\GraphQL\Scaffolding\Scaffolders\DeleteOperationScaffolder;
-use SilverStripe\GraphQL\Scaffolding\Scaffolders\ReadOperationScaffolder;
-use Doctrine\Instantiator\Exception\InvalidArgumentException;
-use SilverStripe\GraphQL\Scaffolding\OperationList;
-use SilverStripe\Core\Config\Config;
-use SilverStripe\Security\Member;
-use SilverStripe\Assets\File;
-use ReflectionClass;
-use SilverStripe\GraphQL\Scaffolding\Util\ArgsParser;
-use SilverStripe\GraphQL\Scaffolding\Util\TypeParser;
-use SilverStripe\GraphQL\Pagination\Connection;
+// use GraphQL\Type\Definition\Type;
+// use GraphQL\Type\Definition\NonNull;
+// use GraphQL\Type\Definition\InputObjectType;
+// use SilverStripe\GraphQL\Scaffolding\Creators\DataObjectTypeCreator;
+// use SilverStripe\GraphQL\Manager;
+// use GraphQL\Type\Definition\ResolveInfo;
+// use GraphQL\Type\Definition\ObjectType;
+// use GraphQL\Type\Definition\ListOfType;
+// use GraphQL\Type\Definition\StringType;
+// use GraphQL\Type\Definition\IntType;
+// use SilverStripe\GraphQL\Tests\Fake\DataObjectFake;
+// use SilverStripe\GraphQL\Scaffolding\Creators\MutationOperationCreator;
+// use SilverStripe\GraphQL\Scaffolding\Creators\QueryOperationCreator;
+// use SilverStripe\GraphQL\Scaffolding\Creators\PaginatedQueryOperationCreator;
+// use SilverStripe\GraphQL\Tests\Fake\FakeResolver;
+// use SilverStripe\GraphQL\Scaffolding\Scaffolders\MutationScaffolder;
+// use SilverStripe\GraphQL\Scaffolding\Scaffolders\OperationScaffolder;
+// use SilverStripe\GraphQL\Scaffolding\Scaffolders\DataObjectScaffolder;
+// use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
+// use SilverStripe\GraphQL\Scaffolding\Scaffolders\QueryScaffolder;
+// use SilverStripe\GraphQL\Scaffolding\Scaffolders\CreateOperationScaffolder;
+// use SilverStripe\GraphQL\Scaffolding\Scaffolders\UpdateOperationScaffolder;
+// use SilverStripe\GraphQL\Scaffolding\Scaffolders\DeleteOperationScaffolder;
+// use SilverStripe\GraphQL\Scaffolding\Scaffolders\ReadOperationScaffolder;
+// use Doctrine\Instantiator\Exception\InvalidArgumentException;
+// use SilverStripe\GraphQL\Scaffolding\OperationList;
+// use SilverStripe\Core\Config\Config;
+// use SilverStripe\Security\Member;
+// use SilverStripe\Assets\File;
+// use ReflectionClass;
+// use SilverStripe\GraphQL\Scaffolding\Util\ArgsParser;
+// use SilverStripe\GraphQL\Scaffolding\Util\TypeParser;
+// use SilverStripe\GraphQL\Pagination\Connection;
 
 class ScaffoldingTest extends SapphireTest
 {
 
-    public function testDataObjectTypeCreator()
-    {
-        $creator = new DataObjectTypeCreator(new Manager, 'test', ['Foo' => 'Bar']);
-
-        $this->assertEquals(['name' => 'test'], $creator->attributes());
-        $this->assertEquals(['Foo' => 'Bar'], $creator->fields());
-
-        $fake = new DataObjectFake([
-            'MyField' => 'test'
-        ]);
-        $info = new ResolveInfo(['fieldName' => 'MyField']);
-
-        $result = $creator->resolveField($fake, [], null, $info);
-
-        $this->assertInstanceOf('SilverStripe\ORM\FieldType\DBVarchar', $result);
-        $this->assertEquals('test', $result->getValue());
-    }
-
-    public function testMutationOperationCreator()
-    {
-        $managerMock = $this->getMockBuilder(Manager::class)
-            ->setMethods(['getType'])
-            ->getMock();
-        $managerMock
-            ->method('getType')
-            ->will($this->returnArgument(0));
-
-        $mutationCreator = new MutationOperationCreator($managerMock, 'testOperation', 'testType', 'testResolver');
-        $result = $mutationCreator->type();
-
-        $this->assertInstanceOf('\Closure', $result);
-        $this->assertEquals('testType', $result());
-
-    }
-
-    public function testQueryOperationCreator()
-    {
-        $managerMock = $this->getMockBuilder(Manager::class)
-            ->setMethods(['getType'])
-            ->getMock();
-        $managerMock
-            ->method('getType')
-            ->willReturn(new ObjectType(['name' => 'test']));
-
-        $mutationCreator = new QueryOperationCreator($managerMock, 'testOperation', 'testType','testResolver');
-        $result = $mutationCreator->type();
-
-        $this->assertInstanceOf('\Closure', $result);
-        $this->assertInstanceOf(ListOfType::class, $result());
-        $this->assertInstanceOf(ObjectType::class, $result()->getWrappedType());
-        $this->assertEquals('test', $result()->getWrappedType()->config['name']);
-
-    }
-
-    public function testOperationCreatorConstuctor()
-    {
-        $mutationCreator = $this->createOperationCreator();
-        $this->assertEquals(['name' => 'testOperation'], $mutationCreator->attributes());
-        $this->assertEquals(['foo' => 'bar'], $mutationCreator->args());
-
-        $this->assertInstanceOf('\Closure', $mutationCreator->toArray()['resolve']);
-    }
-
-    public function testOperationCreatorAcceptsClosureAsResolver()
-    {
-        // test resolvers
-        $mutationCreator = $this->createOperationCreator(function () {
-            return 'abc';
-        });
-        $field = $mutationCreator->toArray();
-        $this->assertEquals('abc', $field['resolve'](null, [], null, null));
-    }
-
-    public function testOperationCreatorAcceptsResolverInterfaceInstanceAsResolver()
-    {
-        $mutationCreator = $this->createOperationCreator(new FakeResolver());
-        $field = $mutationCreator->toArray();
-        $this->assertEquals('resolved', $field['resolve'](null, [], null, null));
-    }
-
-    public function testExceptionThrownOnBadResolver()
-    {
-        $this->setExpectedException(\Exception::class);
-        $mutationCreator = $this->createOperationCreator(FakeResolver::class);
-        $field = $mutationCreator->toArray();
-        $field['resolve'](null, [], null, null);
-    }
-
-    public function testMutationOperationScaffolderCore()
-    {
-        $scaffolder = new MutationScaffolder(
-            'testOperation',
-            'testType'
-        );
-
-        $this->assertEquals('testOperation', $scaffolder->getName());
-
-        $creator = $scaffolder->getCreator(new Manager());
-        $this->assertInstanceOf(MutationOperationCreator::class, $creator);
-        $this->assertEquals(['name' => 'testOperation'], $creator->attributes());
-    }
-
-    public function testQueryOperationScaffolderCore()
-    {
-        $scaffolder = new QueryScaffolder(
-            'testOperation',
-            'testType'
-        );
-
-        $this->assertEquals('testOperation', $scaffolder->getName());
-
-        $creator = $scaffolder->getCreator(new Manager());
-        $this->assertInstanceOf(PaginatedQueryOperationCreator::class, $creator);
-        $this->assertEquals(['name' => 'testOperation'], $creator->attributes());
-
-        $scaffolder->setUsePagination(false);
-        $creator = $scaffolder->getCreator(new Manager());
-        $this->assertInstanceOf(QueryOperationCreator::class, $creator);
-		$this->assertEquals(['name' => 'testOperation'], $creator->attributes());        
-    }
-
-    public function testOperationScaffolderCreator()
-    {
-        $scaffolder = new MutationScaffolder(
-            'testOperation',
-            'testType'
-        );
-
-        $scaffolder->addArgs(['foo' => 'String']);
-        $creator = $scaffolder->getCreator(new Manager());
-        // only test the keys to isolate testing of ArgsParser
-        $this->assertEquals(['foo'], array_keys($creator->args()));
-        $scaffolder->addArgs(['qux' => 'Int']);
-        $creator = $scaffolder->getCreator(new Manager());
-        $this->assertEquals(['foo', 'qux'], array_keys($creator->args()));
-
-        $scaffolder->setResolver(function () {
-        });
-    }
-
-    public function testOperationScaffolderRejectsInvalidResolvers()
-    {
-        $this->setExpectedException(InvalidArgumentException::class);
-        $scaffolder = new MutationScaffolder(
-            'testOperation',
-            'testType',
-            'notAValidResover'
-        );
-    }
-
-    public function testOperationScaffolderAcceptsValidResolvers()
-    {
-        $m = new Manager();
-        $resolver = $this->getMockBuilder(FakeResolver::class)
-            ->setMethods(['resolve'])
-            ->getMock();
-        $resolver->expects($this->once())
-            ->method('resolve');
-
-
-        $scaffolder = new MutationScaffolder(
-            'testOperation',
-            'testType',
-            $resolver
-        );
-
-        $resolveMethod = $scaffolder->getCreator($m)->toArray()['resolve'];
-        $resolveMethod(null, null, null, null);
-
-        $scaffolder = new MutationScaffolder(
-            'testOperation',
-            'testType',
-            function () {
-            }
-        );
-
-        $this->assertInstanceOf('\Closure', $scaffolder->getCreator($m)->toArray()['resolve']);
-    }
-
-
-    public function testOperationScaffolderCreateFromConfig()
-    {
-        $exception = null;
-        $mockManager = $this->getMockBuilder(Manager::class)
-            ->setMethods(['getType'])
-            ->getMock();
-        $mockManager
-            ->expects($this->once())
-            ->method('getType')
-            ->willReturn('abc');
-
-        try {
-            MutationScaffolder::createFromConfig('test', []);
-        } catch (\Exception $e) {
-            $exception = $e;
-        }
-        $this->assertInstanceOf('\Exception', $e);
-
-        try {
-            MutationScaffolder::createFromConfig('test', [
-                'name' => 'testOperation',
-                'resolver' => 'not a resolver'
-            ]);
-        } catch (\Exception $e) {
-            $exception = $e;
-        }
-
-        $this->assertInstanceOf('\Exception', $e);
-
-        $result = MutationScaffolder::createFromConfig('test', [
-            'name' => 'testOperation',
-            'resolver' => FakeResolver::class
-        ]);
-
-        $this->assertInstanceOf(MutationScaffolder::class, $result);
-
-        $creator = $result->getCreator($mockManager);
-        $typeCreator = $creator->type();
-        $type = $typeCreator();
-        $this->assertEquals('abc', $type);
-    }
-
-    public function testDataObjectScaffolderConstructor()
-    {
-        $this->setExpectedException(InvalidArgumentException::class);
-        $scaffolder = new DataObjectScaffolder('Not\A\Real\Thing');
-    }
-
-    public function testDataObjectScaffolderQueriesAndMutations()
-    {
-        $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
-
-        $this->assertInstanceOf(OperationList::class, $scaffolder->getQueries());
-        $this->assertInstanceOf(OperationList::class, $scaffolder->getMutations());
-
-        $query = $scaffolder->query('test');
-
-        $this->assertInstanceOf(QueryScaffolder::class, $query);
-        $this->assertEquals('test', $query->getName());
-
-        $mutation = $scaffolder->mutation('test');
-
-        $this->assertInstanceOf(MutationScaffolder::class, $mutation);
-        $this->assertEquals('test', $mutation->getName());
-
-        $query2 = $scaffolder->query('test');
-        $this->assertEquals(1, $scaffolder->getQueries()->count());
+  //   public function testDataObjectTypeCreator()
+  //   {
+  //       $creator = new DataObjectTypeCreator(new Manager, 'test', ['Foo' => 'Bar']);
+
+  //       $this->assertEquals(['name' => 'test'], $creator->attributes());
+  //       $this->assertEquals(['Foo' => 'Bar'], $creator->fields());
+
+  //       $fake = new DataObjectFake([
+  //           'MyField' => 'test'
+  //       ]);
+  //       $info = new ResolveInfo(['fieldName' => 'MyField']);
+
+  //       $result = $creator->resolveField($fake, [], null, $info);
+
+  //       $this->assertInstanceOf('SilverStripe\ORM\FieldType\DBVarchar', $result);
+  //       $this->assertEquals('test', $result->getValue());
+  //   }
+
+  //   public function testMutationOperationCreator()
+  //   {
+  //       $managerMock = $this->getMockBuilder(Manager::class)
+  //           ->setMethods(['getType'])
+  //           ->getMock();
+  //       $managerMock
+  //           ->method('getType')
+  //           ->will($this->returnArgument(0));
+
+  //       $mutationCreator = new MutationOperationCreator($managerMock, 'testOperation', 'testType', 'testResolver');
+  //       $result = $mutationCreator->type();
+
+  //       $this->assertInstanceOf('\Closure', $result);
+  //       $this->assertEquals('testType', $result());
+
+  //   }
+
+  //   public function testQueryOperationCreator()
+  //   {
+  //       $managerMock = $this->getMockBuilder(Manager::class)
+  //           ->setMethods(['getType'])
+  //           ->getMock();
+  //       $managerMock
+  //           ->method('getType')
+  //           ->willReturn(new ObjectType(['name' => 'test']));
+
+  //       $mutationCreator = new QueryOperationCreator($managerMock, 'testOperation', 'testType','testResolver');
+  //       $result = $mutationCreator->type();
+
+  //       $this->assertInstanceOf('\Closure', $result);
+  //       $this->assertInstanceOf(ListOfType::class, $result());
+  //       $this->assertInstanceOf(ObjectType::class, $result()->getWrappedType());
+  //       $this->assertEquals('test', $result()->getWrappedType()->config['name']);
+
+  //   }
+
+  //   public function testOperationCreatorConstuctor()
+  //   {
+  //       $mutationCreator = $this->createOperationCreator();
+  //       $this->assertEquals(['name' => 'testOperation'], $mutationCreator->attributes());
+  //       $this->assertEquals(['foo' => 'bar'], $mutationCreator->args());
+
+  //       $this->assertInstanceOf('\Closure', $mutationCreator->toArray()['resolve']);
+  //   }
+
+  //   public function testOperationCreatorAcceptsClosureAsResolver()
+  //   {
+  //       // test resolvers
+  //       $mutationCreator = $this->createOperationCreator(function () {
+  //           return 'abc';
+  //       });
+  //       $field = $mutationCreator->toArray();
+  //       $this->assertEquals('abc', $field['resolve'](null, [], null, null));
+  //   }
+
+  //   public function testOperationCreatorAcceptsResolverInterfaceInstanceAsResolver()
+  //   {
+  //       $mutationCreator = $this->createOperationCreator(new FakeResolver());
+  //       $field = $mutationCreator->toArray();
+  //       $this->assertEquals('resolved', $field['resolve'](null, [], null, null));
+  //   }
+
+  //   public function testExceptionThrownOnBadResolver()
+  //   {
+  //       $this->setExpectedException(\Exception::class);
+  //       $mutationCreator = $this->createOperationCreator(FakeResolver::class);
+  //       $field = $mutationCreator->toArray();
+  //       $field['resolve'](null, [], null, null);
+  //   }
+
+  //   public function testMutationOperationScaffolderCore()
+  //   {
+  //       $scaffolder = new MutationScaffolder(
+  //           'testOperation',
+  //           'testType'
+  //       );
+
+  //       $this->assertEquals('testOperation', $scaffolder->getName());
+
+  //       $creator = $scaffolder->getCreator(new Manager());
+  //       $this->assertInstanceOf(MutationOperationCreator::class, $creator);
+  //       $this->assertEquals(['name' => 'testOperation'], $creator->attributes());
+  //   }
+
+  //   public function testQueryOperationScaffolderCore()
+  //   {
+  //       $scaffolder = new QueryScaffolder(
+  //           'testOperation',
+  //           'testType'
+  //       );
+
+  //       $this->assertEquals('testOperation', $scaffolder->getName());
+
+  //       $creator = $scaffolder->getCreator(new Manager());
+  //       $this->assertInstanceOf(PaginatedQueryOperationCreator::class, $creator);
+  //       $this->assertEquals(['name' => 'testOperation'], $creator->attributes());
+
+  //       $scaffolder->setUsePagination(false);
+  //       $creator = $scaffolder->getCreator(new Manager());
+  //       $this->assertInstanceOf(QueryOperationCreator::class, $creator);
+		// $this->assertEquals(['name' => 'testOperation'], $creator->attributes());        
+  //   }
+
+  //   public function testOperationScaffolderCreator()
+  //   {
+  //       $scaffolder = new MutationScaffolder(
+  //           'testOperation',
+  //           'testType'
+  //       );
+
+  //       $scaffolder->addArgs(['foo' => 'String']);
+  //       $creator = $scaffolder->getCreator(new Manager());
+  //       // only test the keys to isolate testing of ArgsParser
+  //       $this->assertEquals(['foo'], array_keys($creator->args()));
+  //       $scaffolder->addArgs(['qux' => 'Int']);
+  //       $creator = $scaffolder->getCreator(new Manager());
+  //       $this->assertEquals(['foo', 'qux'], array_keys($creator->args()));
+
+  //       $scaffolder->setResolver(function () {
+  //       });
+  //   }
+
+  //   public function testOperationScaffolderRejectsInvalidResolvers()
+  //   {
+  //       $this->setExpectedException(InvalidArgumentException::class);
+  //       $scaffolder = new MutationScaffolder(
+  //           'testOperation',
+  //           'testType',
+  //           'notAValidResover'
+  //       );
+  //   }
+
+  //   public function testOperationScaffolderAcceptsValidResolvers()
+  //   {
+  //       $m = new Manager();
+  //       $resolver = $this->getMockBuilder(FakeResolver::class)
+  //           ->setMethods(['resolve'])
+  //           ->getMock();
+  //       $resolver->expects($this->once())
+  //           ->method('resolve');
+
+
+  //       $scaffolder = new MutationScaffolder(
+  //           'testOperation',
+  //           'testType',
+  //           $resolver
+  //       );
+
+  //       $resolveMethod = $scaffolder->getCreator($m)->toArray()['resolve'];
+  //       $resolveMethod(null, null, null, null);
+
+  //       $scaffolder = new MutationScaffolder(
+  //           'testOperation',
+  //           'testType',
+  //           function () {
+  //           }
+  //       );
+
+  //       $this->assertInstanceOf('\Closure', $scaffolder->getCreator($m)->toArray()['resolve']);
+  //   }
+
+
+  //   public function testOperationScaffolderCreateFromConfig()
+  //   {
+  //       $exception = null;
+  //       $mockManager = $this->getMockBuilder(Manager::class)
+  //           ->setMethods(['getType'])
+  //           ->getMock();
+  //       $mockManager
+  //           ->expects($this->once())
+  //           ->method('getType')
+  //           ->willReturn('abc');
+
+  //       try {
+  //           MutationScaffolder::createFromConfig('test', []);
+  //       } catch (\Exception $e) {
+  //           $exception = $e;
+  //       }
+  //       $this->assertInstanceOf('\Exception', $e);
+
+  //       try {
+  //           MutationScaffolder::createFromConfig('test', [
+  //               'name' => 'testOperation',
+  //               'resolver' => 'not a resolver'
+  //           ]);
+  //       } catch (\Exception $e) {
+  //           $exception = $e;
+  //       }
+
+  //       $this->assertInstanceOf('\Exception', $e);
+
+  //       $result = MutationScaffolder::createFromConfig('test', [
+  //           'name' => 'testOperation',
+  //           'resolver' => FakeResolver::class
+  //       ]);
+
+  //       $this->assertInstanceOf(MutationScaffolder::class, $result);
+
+  //       $creator = $result->getCreator($mockManager);
+  //       $typeCreator = $creator->type();
+  //       $type = $typeCreator();
+  //       $this->assertEquals('abc', $type);
+  //   }
+
+  //   public function testDataObjectScaffolderConstructor()
+  //   {
+  //       $this->setExpectedException(InvalidArgumentException::class);
+  //       $scaffolder = new DataObjectScaffolder('Not\A\Real\Thing');
+  //   }
+
+  //   public function testDataObjectScaffolderQueriesAndMutations()
+  //   {
+  //       $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
+
+  //       $this->assertInstanceOf(OperationList::class, $scaffolder->getQueries());
+  //       $this->assertInstanceOf(OperationList::class, $scaffolder->getMutations());
+
+  //       $query = $scaffolder->query('test');
+
+  //       $this->assertInstanceOf(QueryScaffolder::class, $query);
+  //       $this->assertEquals('test', $query->getName());
+
+  //       $mutation = $scaffolder->mutation('test');
+
+  //       $this->assertInstanceOf(MutationScaffolder::class, $mutation);
+  //       $this->assertEquals('test', $mutation->getName());
+
+  //       $query2 = $scaffolder->query('test');
+  //       $this->assertEquals(1, $scaffolder->getQueries()->count());
 
-        $mutation2 = $scaffolder->mutation('test');
-        $this->assertEquals(1, $scaffolder->getMutations()->count());
-
-        $this->assertSame($query, $query2);
-        $this->assertSame($mutation, $mutation2);
+  //       $mutation2 = $scaffolder->mutation('test');
+  //       $this->assertEquals(1, $scaffolder->getMutations()->count());
+
+  //       $this->assertSame($query, $query2);
+  //       $this->assertSame($mutation, $mutation2);
 
-        $query3 = $scaffolder->query('abc');
-        $mutation3 = $scaffolder->mutation('abc');
+  //       $query3 = $scaffolder->query('abc');
+  //       $mutation3 = $scaffolder->mutation('abc');
 
-        $this->assertEquals(2, $scaffolder->getQueries()->count());
-        $this->assertEquals(2, $scaffolder->getMutations()->count());
+  //       $this->assertEquals(2, $scaffolder->getQueries()->count());
+  //       $this->assertEquals(2, $scaffolder->getMutations()->count());
 
-        $scaffolder->removeQuery('test');
-        $scaffolder->removeMutation('test');
+  //       $scaffolder->removeQuery('test');
+  //       $scaffolder->removeMutation('test');
 
-        $this->assertEquals(1, $scaffolder->getQueries()->count());
-        $this->assertEquals(1, $scaffolder->getMutations()->count());
+  //       $this->assertEquals(1, $scaffolder->getQueries()->count());
+  //       $this->assertEquals(1, $scaffolder->getMutations()->count());
 
-    }
+  //   }
 
 
-    public function testDataObjectScaffolderThrowsIfNotDataObject()
-    {
-        $this->setExpectedException(InvalidArgumentException::class);
-        $scaffolder = new DataObjectScaffolder(Config::class);
-    }
+  //   public function testDataObjectScaffolderThrowsIfNotDataObject()
+  //   {
+  //       $this->setExpectedException(InvalidArgumentException::class);
+  //       $scaffolder = new DataObjectScaffolder(Config::class);
+  //   }
 
-    public function testStockOperations()
-    {
-        // Create
-        $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
-        $scaffolder->mutation(GraphQLScaffolder::CREATE);
-        $this->assertInstanceOf(CreateOperationScaffolder::class, $scaffolder->getMutations()->first());
+  //   public function testStockOperations()
+  //   {
+  //       // Create
+  //       $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
+  //       $scaffolder->mutation(GraphQLScaffolder::CREATE);
+  //       $this->assertInstanceOf(CreateOperationScaffolder::class, $scaffolder->getMutations()->first());
 
-        // Read
-        $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
-        $scaffolder->query(GraphQLScaffolder::READ);
-        $this->assertInstanceOf(ReadOperationScaffolder::class, $scaffolder->getQueries()->first());
+  //       // Read
+  //       $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
+  //       $scaffolder->query(GraphQLScaffolder::READ);
+  //       $this->assertInstanceOf(ReadOperationScaffolder::class, $scaffolder->getQueries()->first());
 
-        // Update
-        $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
-        $scaffolder->mutation(GraphQLScaffolder::UPDATE);
-        $this->assertInstanceOf(UpdateOperationScaffolder::class, $scaffolder->getMutations()->first());
+  //       // Update
+  //       $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
+  //       $scaffolder->mutation(GraphQLScaffolder::UPDATE);
+  //       $this->assertInstanceOf(UpdateOperationScaffolder::class, $scaffolder->getMutations()->first());
 
-        // Delete
-        $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
-        $scaffolder->mutation(GraphQLScaffolder::DELETE);
-        $this->assertInstanceOf(DeleteOperationScaffolder::class, $scaffolder->getMutations()->first());
+  //       // Delete
+  //       $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
+  //       $scaffolder->mutation(GraphQLScaffolder::DELETE);
+  //       $this->assertInstanceOf(DeleteOperationScaffolder::class, $scaffolder->getMutations()->first());
 
 
-    }
+  //   }
 
-    public function testDataObjectScaffolderFields()
-    {
-        $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
-        $scaffolder->addFields(['One', 'Two']);
+  //   public function testDataObjectScaffolderFields()
+  //   {
+  //       $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
+  //       $scaffolder->addFields(['One', 'Two']);
 
-        $this->assertEquals(['One', 'Two'], $scaffolder->getFields()->toArray());
+  //       $this->assertEquals(['One', 'Two'], $scaffolder->getFields()->toArray());
 
-        $scaffolder->addFields(['One', 'Two', 'Three']);
+  //       $scaffolder->addFields(['One', 'Two', 'Three']);
 
-        $this->assertCount(3, $scaffolder->getFields());
-        $this->assertEquals(['One', 'Two', 'Three'], $scaffolder->getFields()->toArray());
+  //       $this->assertCount(3, $scaffolder->getFields());
+  //       $this->assertEquals(['One', 'Two', 'Three'], $scaffolder->getFields()->toArray());
 
-        $scaffolder->removeField('Nothing');
-        $this->assertCount(3, $scaffolder->getFields());
-        $scaffolder->removeField('One');
-        $this->assertCount(2, $scaffolder->getFields());
+  //       $scaffolder->removeField('Nothing');
+  //       $this->assertCount(3, $scaffolder->getFields());
+  //       $scaffolder->removeField('One');
+  //       $this->assertCount(2, $scaffolder->getFields());
 
-        $scaffolder->removeFields(['Two', 'Three']);
-        $this->assertCount(0, $scaffolder->getFields());
-    }
+  //       $scaffolder->removeFields(['Two', 'Three']);
+  //       $this->assertCount(0, $scaffolder->getFields());
+  //   }
 
-    public function testDataObjectScaffolderUsesDefaultFields()
-    {
-    	Config::inst()->update(DataObjectScaffolder::class, 'default_fields', ['ID' => 'ID']);
-    	$scaffolder = new DataObjectScaffolder(DataObjectFake::class);
-    	$creator = $scaffolder->getCreator(new Manager());
+  //   public function testDataObjectScaffolderUsesDefaultFields()
+  //   {
+  //   	Config::inst()->update(DataObjectScaffolder::class, 'default_fields', ['ID' => 'ID']);
+  //   	$scaffolder = new DataObjectScaffolder(DataObjectFake::class);
+  //   	$creator = $scaffolder->getCreator(new Manager());
     	
-    	$this->assertEquals(
-    		['ID'],
-    		array_keys($creator->fields())
-    	);
-    }
-
-    public function testDataObjectTrait()
-    {
-        Config::inst()->update(DataObjectFake::class, 'table_name', 'Some\Namespaced\Table');
-        $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
-        $inst = $scaffolder->getDataObjectInstance();
-        $this->assertInstanceOf(DataObjectFake::class, $inst);
-
-        $this->assertEquals('Some_Namespaced_Table', $scaffolder->typeName());
-
-        $scaffolder->setDataObjectClass('test');
-        $this->assertEquals('test', $scaffolder->getDataObjectClass());
-    }
-
-    public function testDataObjectScaffolderCreator()
-    {
-        $scaffolder = (new DataObjectScaffolder(DataObjectFake::class))
-            ->addFields(['MyField', 'NonExistentField', 'Author', 'Files']);
-
-        $extraDataObjects = $scaffolder->getExtraDataObjects();
-        $this->assertArrayHasKey('Author', $extraDataObjects);
-        $this->assertArrayHasKey('Files', $extraDataObjects);
-
-        $this->assertEquals($extraDataObjects['Author'], 'SilverStripe\Security\Member');
-        $this->assertEquals($extraDataObjects['Files'], 'SilverStripe\Assets\File');
-
-        $creator = $scaffolder->getCreator(new Manager());
-
-        $this->assertEquals($scaffolder->typeName(), $creator->attributes()['name']);
-        $fields = array_keys($creator->fields());
-        $this->assertEquals(['MyField', 'NonExistentField', 'Author', 'Files'], $fields);
-    }
-
-
-    public function testDataObjectScaffolderAddToManager()
-    {
-        $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
-        $scaffolder->addFields(['MyField', 'NonExistentField', 'Author', 'Files']);
-        $scaffolder->mutation('myMutation', new FakeResolver());
-        $scaffolder->query('myQuery', new FakeResolver());
-
-        $managerMock = $this->getMockBuilder(Manager::class)
-            ->setMethods(['getType', 'addType', 'addQuery', 'addMutation'])
-            ->getMock();
-        $managerMock->expects($this->once())
-            ->method('addType')
-            ->with($scaffolder->typeName());
-        $managerMock->expects($this->once())
-            ->method('addMutation')
-            ->with(
-                $this->callback(function ($subject) {                	
-                    return (
-                        is_array($subject) && $subject['name'] == 'myMutation'
-                    );
-                }),
-                $this->equalTo('myMutation')
-            );
-
-        $managerMock->expects($this->once())
-            ->method('addQuery')
-            ->with(
-                $this->callback(function ($subject) {                
-                    return (
-                        is_array($subject) && $subject['name'] == 'myQuery'
-                    );
-                }),
-                $this->equalTo('myQuery')
-            );
-
-        $scaffolder->addToManager($managerMock);
-    }
-
-    public function testGraphQLScaffolderAddToManager()
-    {
-        $resolver = new FakeResolver();
-        $scaffolder = new GraphQLScaffolder();
-        $scaffolder->dataObject(DataObjectFake::class)
-            ->addFields(['MyField', 'MyInt', 'Author', 'Files'])
-            ->mutation('testMutation', $resolver)
-            ->addArgs(['Test' => 'String']);
-        $scaffolder->dataObject(DataObjectFake::class)
-            ->query('testQuery', $resolver)
-            ->addArgs(['Test' => 'String']);
-        $scaffolder->dataObject(DataObjectFake::class)
-            ->query('testQueryUnpaginated', $resolver)
-            ->addArgs(['Test' => 'String'])
-            ->setUsePagination(false);
-        $scaffolder->dataObject(Member::class)
-            ->addFields(['Surname']);
-        $scaffolder->dataObject(File::class)
-            ->addFields(['Filename']);
-        $managerMock = $this->getMockBuilder(Manager::class)
-            ->setMethods(['addType', 'addQuery', 'addMutation'])
-            ->getMock();
-
-        $doTypeName = $scaffolder->dataObject(DataObjectFake::class)->typeName();
-        $memberTypeName = $scaffolder->dataObject(Member::class)->typeName();
-        $fileTypeName = $scaffolder->dataObject(File::class)->typeName();
-
-        $createFieldCheckCallback = function ($fields, $typeName) {
-            return function ($subject) use ($fields, $typeName) {
-                if ($subject instanceof ObjectType) {
-                    $fieldFunc = $subject->config['fields'];
-                    $typeFields = $fieldFunc();
-                    return (
-                        ($subject->config['name'] == $typeName) &&
-                        (array_keys($typeFields) == $fields)
-                    );
-                }
-
-                return false;
-            };
-        };
-
-        $managerMock->expects($this->exactly(3))
-            ->method('addType')
-            ->withConsecutive(
-                [
-                    $this->callback($createFieldCheckCallback(
-                        ['MyField', 'MyInt', 'Author', 'Files'],
-                        $doTypeName
-                    )),
-                    $doTypeName
-                ],
-                [
-                    $this->callback($createFieldCheckCallback(['Surname'], $memberTypeName)),
-                    $memberTypeName
-                ],
-                [
-                    $this->callback($createFieldCheckCallback(['Filename'], $fileTypeName)),
-                    $fileTypeName
-                ]
-
-            );
-
-        $managerMock->expects($this->exactly(2))
-            ->method('addQuery')
-            ->withConsecutive(
-            	[
-            		$this->callback(function ($subject) {
-            			$connectionKeys = array_keys(Connection::create('dummy')->args());
-                		return (
-                			is_array($subject) &&
-                			$subject['name'] == 'testQuery' &&
-                			array_keys($subject['args']) == array_merge(['Test'], $connectionKeys)
-                		);
-            		})
-            	],
-            	[
-            		$this->callback(function ($subject) {
-                		return (
-                			is_array($subject) &&
-                			$subject['name'] == 'testQueryUnpaginated' &&
-                			array_keys($subject['args']) == ['Test']
-                		);
-            		})            	
-            	]
-            );
-
-        $managerMock->expects($this->once())
-            ->method('addMutation')
-            ->with($this->callback(function ($subject) {
-                return is_array($subject) &&
-                $subject['name'] == 'testMutation' &&
-                array_keys($subject['args']) == ['Test'];
-            }));
-
-        $scaffolder->addToManager($managerMock);
-    }
-
-    public function testGraphQLScaffolderCreateFromConfig()
-    {
-        $scaffolder = GraphQLScaffolder::createFromConfig([
-            DataObjectFake::class => [
-                'fields' => [
-                    'MyField',
-                    'MyInt',
-                    'Author',
-                    'Files'
-                ],
-                'operations' => ['CREATE', 'READ', 'UPDATE', 'DELETE']
-            ],
-
-            Member::class => [
-                'fields' => ['Surname'],
-                'operations' => 'all',
-                'queries' => [
-                    'myQuery' => [
-                        'args' => [
-                            'Test' => 'String'
-                        ],
-                        'resolver' => FakeResolver::class
-                    ],
-                    'myQueryUnpaginated' => [
-                    	'args' => [
-                    		'Test' => 'String'
-                    	],
-                    	'resolver' => FakeResolver::class
-                    ]
-                ]
-            ],
-
-            File::class => [
-                'fields' => ['Surname'],
-                'mutations' => [
-                    'myMutation' => [
-                        'args' => [
-                            'Test' => 'String'
-                        ],
-                        'resolver' => FakeResolver::class
-                    ]
-                ]
-            ]
-        ]);
-
-        $reflection = new ReflectionClass($scaffolder);
-        $property = $reflection->getProperty('scaffolds');
-        $property->setAccessible(true);
-        $scaffolds = $property->getValue($scaffolder);
-
-        $dataObjectClasses = [
-            DataObjectFake::class => true,
-            Member::class => true,
-            File::class => true
-        ];
-
-        foreach ($scaffolds as $scaffold) {
-            $name = $scaffold->getDataObjectClass();
-            $typeName = ucfirst($scaffold->typeName());
-            $pluralTypeName = $scaffold->getDataObjectInstance()->plural_name();
-            $pluralTypeName = str_replace(' ', '', $pluralTypeName);
-            $pluralTypeName = ucfirst($pluralTypeName);
-
-            $this->assertArrayHasKey($name, $dataObjectClasses);
-            unset($dataObjectClasses[$name]);
+  //   	$this->assertEquals(
+  //   		['ID'],
+  //   		array_keys($creator->fields())
+  //   	);
+  //   }
+
+  //   public function testDataObjectTrait()
+  //   {
+  //       Config::inst()->update(DataObjectFake::class, 'table_name', 'Some\Namespaced\Table');
+  //       $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
+  //       $inst = $scaffolder->getDataObjectInstance();
+  //       $this->assertInstanceOf(DataObjectFake::class, $inst);
+
+  //       $this->assertEquals('Some_Namespaced_Table', $scaffolder->typeName());
+
+  //       $scaffolder->setDataObjectClass('test');
+  //       $this->assertEquals('test', $scaffolder->getDataObjectClass());
+  //   }
+
+  //   public function testDataObjectScaffolderCreator()
+  //   {
+  //       $scaffolder = (new DataObjectScaffolder(DataObjectFake::class))
+  //           ->addFields(['MyField', 'NonExistentField', 'Author', 'Files']);
+
+  //       $extraDataObjects = $scaffolder->getExtraDataObjects();
+  //       $this->assertArrayHasKey('Author', $extraDataObjects);
+  //       $this->assertArrayHasKey('Files', $extraDataObjects);
+
+  //       $this->assertEquals($extraDataObjects['Author'], 'SilverStripe\Security\Member');
+  //       $this->assertEquals($extraDataObjects['Files'], 'SilverStripe\Assets\File');
+
+  //       $creator = $scaffolder->getCreator(new Manager());
+
+  //       $this->assertEquals($scaffolder->typeName(), $creator->attributes()['name']);
+  //       $fields = array_keys($creator->fields());
+  //       $this->assertEquals(['MyField', 'NonExistentField', 'Author', 'Files'], $fields);
+  //   }
+
+
+  //   public function testDataObjectScaffolderAddToManager()
+  //   {
+  //       $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
+  //       $scaffolder->addFields(['MyField', 'NonExistentField', 'Author', 'Files']);
+  //       $scaffolder->mutation('myMutation', new FakeResolver());
+  //       $scaffolder->query('myQuery', new FakeResolver());
+
+  //       $managerMock = $this->getMockBuilder(Manager::class)
+  //           ->setMethods(['getType', 'addType', 'addQuery', 'addMutation'])
+  //           ->getMock();
+  //       $managerMock->expects($this->once())
+  //           ->method('addType')
+  //           ->with($scaffolder->typeName());
+  //       $managerMock->expects($this->once())
+  //           ->method('addMutation')
+  //           ->with(
+  //               $this->callback(function ($subject) {                	
+  //                   return (
+  //                       is_array($subject) && $subject['name'] == 'myMutation'
+  //                   );
+  //               }),
+  //               $this->equalTo('myMutation')
+  //           );
+
+  //       $managerMock->expects($this->once())
+  //           ->method('addQuery')
+  //           ->with(
+  //               $this->callback(function ($subject) {                
+  //                   return (
+  //                       is_array($subject) && $subject['name'] == 'myQuery'
+  //                   );
+  //               }),
+  //               $this->equalTo('myQuery')
+  //           );
+
+  //       $scaffolder->addToManager($managerMock);
+  //   }
+
+  //   public function testGraphQLScaffolderAddToManager()
+  //   {
+  //       $resolver = new FakeResolver();
+  //       $scaffolder = new GraphQLScaffolder();
+  //       $scaffolder->dataObject(DataObjectFake::class)
+  //           ->addFields(['MyField', 'MyInt', 'Author', 'Files'])
+  //           ->mutation('testMutation', $resolver)
+  //           ->addArgs(['Test' => 'String']);
+  //       $scaffolder->dataObject(DataObjectFake::class)
+  //           ->query('testQuery', $resolver)
+  //           ->addArgs(['Test' => 'String']);
+  //       $scaffolder->dataObject(DataObjectFake::class)
+  //           ->query('testQueryUnpaginated', $resolver)
+  //           ->addArgs(['Test' => 'String'])
+  //           ->setUsePagination(false);
+  //       $scaffolder->dataObject(Member::class)
+  //           ->addFields(['Surname']);
+  //       $scaffolder->dataObject(File::class)
+  //           ->addFields(['Filename']);
+  //       $managerMock = $this->getMockBuilder(Manager::class)
+  //           ->setMethods(['addType', 'addQuery', 'addMutation'])
+  //           ->getMock();
+
+  //       $doTypeName = $scaffolder->dataObject(DataObjectFake::class)->typeName();
+  //       $memberTypeName = $scaffolder->dataObject(Member::class)->typeName();
+  //       $fileTypeName = $scaffolder->dataObject(File::class)->typeName();
+
+  //       $createFieldCheckCallback = function ($fields, $typeName) {
+  //           return function ($subject) use ($fields, $typeName) {
+  //               if ($subject instanceof ObjectType) {
+  //                   $fieldFunc = $subject->config['fields'];
+  //                   $typeFields = $fieldFunc();
+  //                   return (
+  //                       ($subject->config['name'] == $typeName) &&
+  //                       (array_keys($typeFields) == $fields)
+  //                   );
+  //               }
+
+  //               return false;
+  //           };
+  //       };
+
+  //       $managerMock->expects($this->exactly(3))
+  //           ->method('addType')
+  //           ->withConsecutive(
+  //               [
+  //                   $this->callback($createFieldCheckCallback(
+  //                       ['MyField', 'MyInt', 'Author', 'Files'],
+  //                       $doTypeName
+  //                   )),
+  //                   $doTypeName
+  //               ],
+  //               [
+  //                   $this->callback($createFieldCheckCallback(['Surname'], $memberTypeName)),
+  //                   $memberTypeName
+  //               ],
+  //               [
+  //                   $this->callback($createFieldCheckCallback(['Filename'], $fileTypeName)),
+  //                   $fileTypeName
+  //               ]
+
+  //           );
+
+  //       $managerMock->expects($this->exactly(2))
+  //           ->method('addQuery')
+  //           ->withConsecutive(
+  //           	[
+  //           		$this->callback(function ($subject) {
+  //           			$connectionKeys = array_keys(Connection::create('dummy')->args());
+  //               		return (
+  //               			is_array($subject) &&
+  //               			$subject['name'] == 'testQuery' &&
+  //               			array_keys($subject['args']) == array_merge(['Test'], $connectionKeys)
+  //               		);
+  //           		})
+  //           	],
+  //           	[
+  //           		$this->callback(function ($subject) {
+  //               		return (
+  //               			is_array($subject) &&
+  //               			$subject['name'] == 'testQueryUnpaginated' &&
+  //               			array_keys($subject['args']) == ['Test']
+  //               		);
+  //           		})            	
+  //           	]
+  //           );
+
+  //       $managerMock->expects($this->once())
+  //           ->method('addMutation')
+  //           ->with($this->callback(function ($subject) {
+  //               return is_array($subject) &&
+  //               $subject['name'] == 'testMutation' &&
+  //               array_keys($subject['args']) == ['Test'];
+  //           }));
+
+  //       $scaffolder->addToManager($managerMock);
+  //   }
+
+  //   public function testGraphQLScaffolderCreateFromConfig()
+  //   {
+  //       $scaffolder = GraphQLScaffolder::createFromConfig([
+  //           DataObjectFake::class => [
+  //               'fields' => [
+  //                   'MyField',
+  //                   'MyInt',
+  //                   'Author',
+  //                   'Files'
+  //               ],
+  //               'operations' => ['CREATE', 'READ', 'UPDATE', 'DELETE']
+  //           ],
+
+  //           Member::class => [
+  //               'fields' => ['Surname'],
+  //               'operations' => 'all',
+  //               'queries' => [
+  //                   'myQuery' => [
+  //                       'args' => [
+  //                           'Test' => 'String'
+  //                       ],
+  //                       'resolver' => FakeResolver::class
+  //                   ],
+  //                   'myQueryUnpaginated' => [
+  //                   	'args' => [
+  //                   		'Test' => 'String'
+  //                   	],
+  //                   	'resolver' => FakeResolver::class
+  //                   ]
+  //               ]
+  //           ],
+
+  //           File::class => [
+  //               'fields' => ['Surname'],
+  //               'mutations' => [
+  //                   'myMutation' => [
+  //                       'args' => [
+  //                           'Test' => 'String'
+  //                       ],
+  //                       'resolver' => FakeResolver::class
+  //                   ]
+  //               ]
+  //           ]
+  //       ]);
+
+  //       $reflection = new ReflectionClass($scaffolder);
+  //       $property = $reflection->getProperty('scaffolds');
+  //       $property->setAccessible(true);
+  //       $scaffolds = $property->getValue($scaffolder);
+
+  //       $dataObjectClasses = [
+  //           DataObjectFake::class => true,
+  //           Member::class => true,
+  //           File::class => true
+  //       ];
+
+  //       foreach ($scaffolds as $scaffold) {
+  //           $name = $scaffold->getDataObjectClass();
+  //           $typeName = ucfirst($scaffold->typeName());
+  //           $pluralTypeName = $scaffold->getDataObjectInstance()->plural_name();
+  //           $pluralTypeName = str_replace(' ', '', $pluralTypeName);
+  //           $pluralTypeName = ucfirst($pluralTypeName);
+
+  //           $this->assertArrayHasKey($name, $dataObjectClasses);
+  //           unset($dataObjectClasses[$name]);
             
-            if (in_array($name, [DataObjectFake::class, Member::class])) {
-                $this->assertInstanceOf(
-                    CreateOperationScaffolder::class,
-                    $scaffold->getMutations()->findByName('create' . $typeName)
-                );
-                $this->assertInstanceOf(
-                    UpdateOperationScaffolder::class,
-                    $scaffold->getMutations()->findByName('update' . $typeName)
-                );
-                $this->assertInstanceOf(
-                    DeleteOperationScaffolder::class,
-                    $scaffold->getMutations()->findByName('delete' . $typeName)
-                );
-                $this->assertInstanceOf(
-                    ReadOperationScaffolder::class,
-                    $scaffold->getQueries()->findByName('read' . $pluralTypeName)
-                );
-                if ($name == Member::class) {
-                    $op = $scaffold->getQueries()->findByName('myQuery');
-                    $this->assertInstanceOf(
-                        QueryScaffolder::class,
-                        $op
-                    );
-                    $args = $op->getCreator(new Manager())->args();
-                    foreach(Connection::create('dummy')->args() as $a => $config) {
-                    	$this->assertArrayHasKey($a, $args);
-                    }
-                    $this->assertArrayHasKey('Test', $args);
-
-                    $op = $scaffold->getQueries()->findByName('myQueryUnpaginated');
-                    $this->assertInstanceOf(
-                        QueryScaffolder::class,
-                        $op
-                    );
-                    $this->assertArrayHasKey('Test', $op->getCreator(new Manager())->args());
-
-                }
-
-            } else {
-                if ($name == File::class) {
-                    $op = $scaffold->getMutations()->findByName('myMutation');
-                    $this->assertInstanceOf(
-                        MutationScaffolder::class,
-                        $op
-                    );
-                    $this->assertArrayHasKey('Test', $op->getCreator(new Manager())->args());
-                }
-            }
-        }
-    }
-
-    public function testInputTypesAreCreated()
-    {
-        $create = (new CreateOperationScaffolder(DataObjectFake::class))
-            ->addArgs(['Test' => 'String']);
-        $creator = $create->getCreator(new Manager());
-
-        $this->assertArrayHasKey('Input', $creator->args());
-        $type = $creator->args()['Input']['type'];
-        $this->assertInstanceOf(NonNull::class, $type);
-        $this->assertInstanceOf(InputObjectType::class, $type->getWrappedType());
-
-        $create = (new UpdateOperationScaffolder(DataObjectFake::class))
-            ->addArgs(['Test' => 'String']);
-        $creator = $create->getCreator(new Manager());
-
-        $this->assertArrayHasKey('Input', $creator->args());
-        $this->assertArrayHasKey('ID', $creator->args());
-        $type = $creator->args()['Input']['type'];
-        $this->assertInstanceOf(NonNull::class, $type);
-        $this->assertInstanceOf(InputObjectType::class, $type->getWrappedType());
-    }
-
-    public function testTypeParser()
-    {
-        $parser = new TypeParser('String!=Test');
-        $this->assertTrue($parser->isRequired());
-        $this->assertEquals('String', $parser->getArgTypeName());
-        $this->assertEquals('Test', $parser->getDefaultValue());
-        $this->assertTrue(is_string($parser->toArray()['defaultValue']));
-
-        $parser = new TypeParser('String! = Test');
-        $this->assertTrue($parser->isRequired());
-        $this->assertEquals('String', $parser->getArgTypeName());
-        $this->assertEquals('Test', $parser->getDefaultValue());
-
-        $parser = new TypeParser('Int!');
-        $this->assertTrue($parser->isRequired());
-        $this->assertEquals('Int', $parser->getArgTypeName());
-        $this->assertNull($parser->getDefaultValue());
-
-        $parser = new TypeParser('Int!=23');
-        $this->assertTrue($parser->isRequired());
-        $this->assertEquals('Int', $parser->getArgTypeName());
-        $this->assertEquals('23', $parser->getDefaultValue());
-		$this->assertTrue(is_int($parser->toArray()['defaultValue']));
-
-        $parser = new TypeParser('Boolean');
-        $this->assertFalse($parser->isRequired());
-        $this->assertEquals('Boolean', $parser->getArgTypeName());
-        $this->assertNull($parser->getDefaultValue());
-
-        $parser = new TypeParser('Boolean=1');
-        $this->assertFalse($parser->isRequired());
-        $this->assertEquals('Boolean', $parser->getArgTypeName());
-        $this->assertEquals('1', $parser->getDefaultValue());
-		$this->assertTrue(is_bool($parser->toArray()['defaultValue']));
-
-        $parser = new TypeParser('String!=Test');
-        $arr = $parser->toArray();
-        $this->assertInstanceOf(NonNull::class, $arr['type']);
-        $this->assertInstanceOf(StringType::class, $arr['type']->getWrappedType());
-        $this->assertEquals('Test', $arr['defaultValue']);
-
-        $this->setExpectedException(InvalidArgumentException::class);
-        $parser = new TypeParser('  ... Nothing');
-
-        $this->setExpectedException(InvalidArgumentException::class);
-        $parser = (new TypeParser('Nothing'))->toArray();
-    }
-
-    public function testArgsParser()
-    {
-        $parsers = [
-            new ArgsParser([
-                'Test' => 'String'
-            ]),
-            new ArgsParser([
-                'Test' => Type::string()
-            ]),
-            new ArgsParser([
-                'Test' => ['type' => Type::string()]
-            ])
-        ];
-
-        foreach ($parsers as $parser) {
-            $arr = $parser->toArray();
-            $this->assertArrayHasKey('Test', $arr);
-            $this->assertArrayHasKey('type', $arr['Test']);
-            $this->assertInstanceOf(StringType::class, $arr['Test']['type']);
-        }
-    }
-
-
-    public function testOperationList()
-    {
-        $list = new OperationList();
-
-        $list->push(new MutationScaffolder('myMutation1', 'test1'));
-        $list->push(new MutationScaffolder('myMutation2', 'test2'));
-
-        $this->assertInstanceOf(
-            MutationScaffolder::class,
-            $list->findByName('myMutation1')
-        );
-        $this->assertFalse($list->findByName('myMutation3'));
-
-        $list->removeByName('myMutation2');
-        $this->assertEquals(1, $list->count());
-
-        $list->removeByName('nothing');
-        $this->assertEquals(1, $list->count());
-
-        $this->setExpectedException(InvalidArgumentException::class);
-        $list->push(new OperationList());
-    }
-
-    protected function createOperationCreator($resolver = null)
-    {
-        return new MutationOperationCreator(
-            new Manager(),
-            'testOperation',
-            'testType',
-            $resolver,
-            ['foo' => 'bar']
-        );
-    }
+  //           if (in_array($name, [DataObjectFake::class, Member::class])) {
+  //               $this->assertInstanceOf(
+  //                   CreateOperationScaffolder::class,
+  //                   $scaffold->getMutations()->findByName('create' . $typeName)
+  //               );
+  //               $this->assertInstanceOf(
+  //                   UpdateOperationScaffolder::class,
+  //                   $scaffold->getMutations()->findByName('update' . $typeName)
+  //               );
+  //               $this->assertInstanceOf(
+  //                   DeleteOperationScaffolder::class,
+  //                   $scaffold->getMutations()->findByName('delete' . $typeName)
+  //               );
+  //               $this->assertInstanceOf(
+  //                   ReadOperationScaffolder::class,
+  //                   $scaffold->getQueries()->findByName('read' . $pluralTypeName)
+  //               );
+  //               if ($name == Member::class) {
+  //                   $op = $scaffold->getQueries()->findByName('myQuery');
+  //                   $this->assertInstanceOf(
+  //                       QueryScaffolder::class,
+  //                       $op
+  //                   );
+  //                   $args = $op->getCreator(new Manager())->args();
+  //                   foreach(Connection::create('dummy')->args() as $a => $config) {
+  //                   	$this->assertArrayHasKey($a, $args);
+  //                   }
+  //                   $this->assertArrayHasKey('Test', $args);
+
+  //                   $op = $scaffold->getQueries()->findByName('myQueryUnpaginated');
+  //                   $this->assertInstanceOf(
+  //                       QueryScaffolder::class,
+  //                       $op
+  //                   );
+  //                   $this->assertArrayHasKey('Test', $op->getCreator(new Manager())->args());
+
+  //               }
+
+  //           } else {
+  //               if ($name == File::class) {
+  //                   $op = $scaffold->getMutations()->findByName('myMutation');
+  //                   $this->assertInstanceOf(
+  //                       MutationScaffolder::class,
+  //                       $op
+  //                   );
+  //                   $this->assertArrayHasKey('Test', $op->getCreator(new Manager())->args());
+  //               }
+  //           }
+  //       }
+  //   }
+
+  //   public function testInputTypesAreCreated()
+  //   {
+  //       $create = (new CreateOperationScaffolder(DataObjectFake::class))
+  //           ->addArgs(['Test' => 'String']);
+  //       $creator = $create->getCreator(new Manager());
+
+  //       $this->assertArrayHasKey('Input', $creator->args());
+  //       $type = $creator->args()['Input']['type'];
+  //       $this->assertInstanceOf(NonNull::class, $type);
+  //       $this->assertInstanceOf(InputObjectType::class, $type->getWrappedType());
+
+  //       $create = (new UpdateOperationScaffolder(DataObjectFake::class))
+  //           ->addArgs(['Test' => 'String']);
+  //       $creator = $create->getCreator(new Manager());
+
+  //       $this->assertArrayHasKey('Input', $creator->args());
+  //       $this->assertArrayHasKey('ID', $creator->args());
+  //       $type = $creator->args()['Input']['type'];
+  //       $this->assertInstanceOf(NonNull::class, $type);
+  //       $this->assertInstanceOf(InputObjectType::class, $type->getWrappedType());
+  //   }
+
+  //   public function testTypeParser()
+  //   {
+  //       $parser = new TypeParser('String!=Test');
+  //       $this->assertTrue($parser->isRequired());
+  //       $this->assertEquals('String', $parser->getArgTypeName());
+  //       $this->assertEquals('Test', $parser->getDefaultValue());
+  //       $this->assertTrue(is_string($parser->toArray()['defaultValue']));
+
+  //       $parser = new TypeParser('String! = Test');
+  //       $this->assertTrue($parser->isRequired());
+  //       $this->assertEquals('String', $parser->getArgTypeName());
+  //       $this->assertEquals('Test', $parser->getDefaultValue());
+
+  //       $parser = new TypeParser('Int!');
+  //       $this->assertTrue($parser->isRequired());
+  //       $this->assertEquals('Int', $parser->getArgTypeName());
+  //       $this->assertNull($parser->getDefaultValue());
+
+  //       $parser = new TypeParser('Int!=23');
+  //       $this->assertTrue($parser->isRequired());
+  //       $this->assertEquals('Int', $parser->getArgTypeName());
+  //       $this->assertEquals('23', $parser->getDefaultValue());
+		// $this->assertTrue(is_int($parser->toArray()['defaultValue']));
+
+  //       $parser = new TypeParser('Boolean');
+  //       $this->assertFalse($parser->isRequired());
+  //       $this->assertEquals('Boolean', $parser->getArgTypeName());
+  //       $this->assertNull($parser->getDefaultValue());
+
+  //       $parser = new TypeParser('Boolean=1');
+  //       $this->assertFalse($parser->isRequired());
+  //       $this->assertEquals('Boolean', $parser->getArgTypeName());
+  //       $this->assertEquals('1', $parser->getDefaultValue());
+		// $this->assertTrue(is_bool($parser->toArray()['defaultValue']));
+
+  //       $parser = new TypeParser('String!=Test');
+  //       $arr = $parser->toArray();
+  //       $this->assertInstanceOf(NonNull::class, $arr['type']);
+  //       $this->assertInstanceOf(StringType::class, $arr['type']->getWrappedType());
+  //       $this->assertEquals('Test', $arr['defaultValue']);
+
+  //       $this->setExpectedException(InvalidArgumentException::class);
+  //       $parser = new TypeParser('  ... Nothing');
+
+  //       $this->setExpectedException(InvalidArgumentException::class);
+  //       $parser = (new TypeParser('Nothing'))->toArray();
+  //   }
+
+  //   public function testArgsParser()
+  //   {
+  //       $parsers = [
+  //           new ArgsParser([
+  //               'Test' => 'String'
+  //           ]),
+  //           new ArgsParser([
+  //               'Test' => Type::string()
+  //           ]),
+  //           new ArgsParser([
+  //               'Test' => ['type' => Type::string()]
+  //           ])
+  //       ];
+
+  //       foreach ($parsers as $parser) {
+  //           $arr = $parser->toArray();
+  //           $this->assertArrayHasKey('Test', $arr);
+  //           $this->assertArrayHasKey('type', $arr['Test']);
+  //           $this->assertInstanceOf(StringType::class, $arr['Test']['type']);
+  //       }
+  //   }
+
+
+  //   public function testOperationList()
+  //   {
+  //       $list = new OperationList();
+
+  //       $list->push(new MutationScaffolder('myMutation1', 'test1'));
+  //       $list->push(new MutationScaffolder('myMutation2', 'test2'));
+
+  //       $this->assertInstanceOf(
+  //           MutationScaffolder::class,
+  //           $list->findByName('myMutation1')
+  //       );
+  //       $this->assertFalse($list->findByName('myMutation3'));
+
+  //       $list->removeByName('myMutation2');
+  //       $this->assertEquals(1, $list->count());
+
+  //       $list->removeByName('nothing');
+  //       $this->assertEquals(1, $list->count());
+
+  //       $this->setExpectedException(InvalidArgumentException::class);
+  //       $list->push(new OperationList());
+  //   }
+
+  //   protected function createOperationCreator($resolver = null)
+  //   {
+  //       return new MutationOperationCreator(
+  //           new Manager(),
+  //           'testOperation',
+  //           'testType',
+  //           $resolver,
+  //           ['foo' => 'bar']
+  //       );
+  //   }
 
 }

From cd2956cc6e61cfd31a86a70fd55781fa2159aa8a Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 10 Jan 2017 11:57:12 +1300
Subject: [PATCH 18/66] Expose nested queries through public api

---
 src/Scaffolding/Scaffolders/DataObjectScaffolder.php | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
index 17d264bb8..cff6e4090 100644
--- a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -172,6 +172,14 @@ public function getOperations()
         return $this->operations;
     }
 
+    /**
+     * @return OperationList
+     */
+    public function getNestedQueries()
+    {
+    	return $this->nestedQueries;
+    }
+
     /**
      * Removes an operation.
      *

From 7cec89a626de379d6d709d5aff89ddf6e4308e95 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 10 Jan 2017 11:57:31 +1300
Subject: [PATCH 19/66] Move operation() method, allow removal by identifier

---
 .../Scaffolders/DataObjectScaffolder.php      | 38 ++++++++++++++++++-
 1 file changed, 36 insertions(+), 2 deletions(-)

diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
index cff6e4090..030c67d62 100644
--- a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -188,12 +188,46 @@ public function getNestedQueries()
      * @return $this
      */
     public function removeOperation($identifier)
-    {
-        $this->operations->removeByName($identifier);
+    {        
+        $this->operations->removeByIdentifier($identifier);
 
         return $this;
     }
 
+    /**
+     * Find or make an operation.
+     *
+     * @param string $operation
+     *
+     * @return OperationScaffolder
+     */
+    public function operation($operation)
+    {	
+        $scaffoldClass = OperationScaffolder::getOperationScaffoldFromIdentifier($operation);
+
+        if (!$scaffoldClass) {
+            throw new InvalidArgumentException(sprintf(
+                'Invalid operation: %s added to %s',
+                $operation,
+                $this->dataObjectClass
+            ));
+        }
+
+        $scaffolder = new $scaffoldClass($this->dataObjectClass);
+        $existing = $this->operations->findByIdentifier($operation);
+
+        if ($existing) {        
+            return $existing;
+        }
+
+        $this->operations->push(
+            $scaffolder->setChainableParent($this)
+        );
+
+        return $scaffolder;
+    }
+
+
     /**
      * Finds or adds a nested query, e.g. has_many/many_many relation.
      *

From 8068dd9adc99f61571429266c0a57eff8d1f282a Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 10 Jan 2017 12:03:02 +1300
Subject: [PATCH 20/66] Allow allFieldsExcept to take a string

---
 src/Scaffolding/Scaffolders/DataObjectScaffolder.php | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
index 030c67d62..bfc4076e5 100644
--- a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -117,13 +117,16 @@ public function addAllFields($includeHasOne = false)
     /**
      * Adds fields against a blacklist.
      *
-     * @param array $exclusions
+     * @param array|string $exclusions
      * @param bool  $includeHasOne
      *
      * @return $this
      */
-    public function addAllFieldsExcept(array $exclusions, $includeHasOne = false)
+    public function addAllFieldsExcept($exclusions, $includeHasOne = false)
     {
+        if(!is_array($exclusions)) {
+        	$exclusions = [$exclusions];
+        }
         $fields = $this->allFieldsFromDataObject($includeHasOne);
         $filteredFields = array_diff($fields, $exclusions);
 

From 11c4c444629946a19d4588309faef4ddaa3f33a4 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 10 Jan 2017 12:03:27 +1300
Subject: [PATCH 21/66] Move operation() method

---
 .../Scaffolders/DataObjectScaffolder.php      | 33 -------------------
 1 file changed, 33 deletions(-)

diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
index bfc4076e5..5301f2f9e 100644
--- a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -271,39 +271,6 @@ function ($obj) use ($fieldName) {
         return $queryScaffolder;
     }
 
-    /**
-     * Find or make an operation.
-     *
-     * @param string $operation
-     *
-     * @return OperationScaffolder
-     */
-    public function operation($operation)
-    {
-        $scaffoldClass = OperationScaffolder::getOperationScaffoldFromIdentifier($operation);
-
-        if (!$scaffoldClass) {
-            throw new InvalidArgumentException(sprintf(
-                'Invalid operation: %s added to %s',
-                $operation,
-                $this->dataObjectClass
-            ));
-        }
-
-        $operation = new $scaffoldClass($this->dataObjectClass);
-        $existing = $this->operations->findByType(get_class($operation));
-
-        if ($existing) {
-            return $existing;
-        }
-
-        $this->operations->push(
-            $operation->setChainableParent($this)
-        );
-
-        return $operation;
-    }
-
     /**
      * Gets types for all ancestors of this class that will need to be added.
      *

From 7ccb104496747e6650e3187fb4c087ecc007a502 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 10 Jan 2017 12:03:45 +1300
Subject: [PATCH 22/66] Omit data object class from ancestry

---
 src/Scaffolding/Scaffolders/DataObjectScaffolder.php | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
index 5301f2f9e..69bda9dc9 100644
--- a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -295,6 +295,9 @@ public function getAncestralClasses()
         $ancestry = array_reverse(ClassInfo::ancestry($this->dataObjectClass));
 
         foreach ($ancestry as $class) {
+            if($class === $this->dataObjectClass) {
+            	continue;
+            }
             if ($class == DataObject::class) {
                 break;
             }

From ee2798ae6aa15b092d267de3da51cfee1f055bc3 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 10 Jan 2017 12:04:11 +1300
Subject: [PATCH 23/66] Allow fieldsExcept or fields to be defined in config,
 not just fields

---
 .../Scaffolders/DataObjectScaffolder.php         | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
index 69bda9dc9..196791616 100644
--- a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -309,13 +309,23 @@ public function getAncestralClasses()
 
     public function applyConfig(array $config)
     {
-        if (empty($config['fields']) || !is_array($config['fields'])) {
+        $dataObjectClass = $this->dataObjectClass;
+        if (empty($config['fields']) && empty($config['fieldsExcept'])) {
             throw new \Exception(
                 "No array of fields defined for $dataObjectClass"
             );
         }
-
-        $this->addFields($config['fields']);
+        if(isset($config['fields'])) {
+	        if($config['fields'] === '*')  {        	
+	        	$this->addAllFields();
+	        } else if(is_array($config['fields'])) {
+	        	$this->addFields($config['fields']);	
+	        } else {
+	    		throw new \Exception(
+	    			"Fields must be an array, or '*' for all fields in $dataObjectClass"
+	    		);        	
+	        }
+    	}		
 
         if (isset($config['fieldsExcept'])) {
             if (!is_array($config['fieldsExcept'])) {

From 566623cd96016eb5aae2c86c3b4e1e78e5f8177a Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 10 Jan 2017 12:04:27 +1300
Subject: [PATCH 24/66] Bugfix: missing use statement

---
 src/Scaffolding/Scaffolders/CRUD/Delete.php | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Scaffolding/Scaffolders/CRUD/Delete.php b/src/Scaffolding/Scaffolders/CRUD/Delete.php
index cde53a8a3..e8268ecfe 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Delete.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Delete.php
@@ -7,6 +7,7 @@
 use SilverStripe\ORM\DataList;
 use GraphQL\Type\Definition\Type;
 use SilverStripe\GraphQL\Scaffolding\Interfaces\CRUDInterface;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
 use Exception;
 
 /**

From beafd24ef6b132c3a5992c457c2fd78e3aa2bd0f Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 10 Jan 2017 12:04:46 +1300
Subject: [PATCH 25/66] Bugfix: missing use statement

---
 src/Scaffolding/Scaffolders/CRUD/Update.php | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Scaffolding/Scaffolders/CRUD/Update.php b/src/Scaffolding/Scaffolders/CRUD/Update.php
index 79db2fcc2..e4770072d 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Update.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Update.php
@@ -11,6 +11,7 @@
 use SilverStripe\GraphQL\Manager;
 use GraphQL\Type\Definition\Type;
 use SilverStripe\GraphQL\Scaffolding\Interfaces\CRUDInterface;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
 use Exception;
 
 /**

From 11d4ce4eb43872dce64c5641a69dae10e5c0ae45 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 10 Jan 2017 12:05:17 +1300
Subject: [PATCH 26/66] New public api, allowing find and remove by identifier

---
 src/Scaffolding/Util/OperationList.php | 62 ++++++++++++++++++--------
 1 file changed, 44 insertions(+), 18 deletions(-)

diff --git a/src/Scaffolding/Util/OperationList.php b/src/Scaffolding/Util/OperationList.php
index b4642812f..22335c59c 100644
--- a/src/Scaffolding/Util/OperationList.php
+++ b/src/Scaffolding/Util/OperationList.php
@@ -52,38 +52,50 @@ public function push($item)
      */
     public function findByName($name)
     {
-        foreach ($this->items as $key => $value) {
-            if ($name === $value->getName()) {
-                return $value;
-            }
-        }
-
-        return false;
+    	return $this->findItemByCallback(function ($item) use ($name) {
+    		return $name === $item->getName();
+    	});
     }
 
     /**
-     * @param  string $class
+     * @param  string $id
      * @return bool|OperationScaffold
      */
-    public function findByType($class)
+    public function findByIdentifier($id)
     {
-    	foreach ($this->items as $key => $value) {
-    		if($class === get_class($value)) {
-    			return $value;
-    		}
-    	}
-
-    	return false;
+    	return $this->findItemByCallback(function ($item) use ($id) {
+    		return $id === $item->getIdentifier();
+    	});
     }
 
     /**
      * @param $name
      */
     public function removeByName($name)
+    {
+        $this->removeItemByCallback(function ($operation) use ($name) {
+        	return $operation->getName() === $name;
+        });
+    }
+
+    /**
+     * @param $name
+     */
+    public function removeByIdentifier($id)
+    {
+        $this->removeItemByCallback(function ($operation) use ($id) {
+        	return $operation->getIdentifier() === $id;
+        });
+    }
+
+    /**
+     * @param \Closure
+     */
+    public function removeItemByCallback($callback)
     {
         $renumberKeys = false;
-        foreach ($this->items as $key => $value) {
-            if ($name === $value->getName()) {
+        foreach ($this->items as $key => $value) {        	
+            if ($callback($value)) {
                 $renumberKeys = true;
                 unset($this->items[$key]);
             }
@@ -93,4 +105,18 @@ public function removeByName($name)
             $this->items = array_values($this->items);
         }
     }
+
+    /**
+     * @param \Closure
+     */
+    public function findItemByCallback($callback) {
+    	foreach ($this->items as $key => $value) {
+    		if($callback($value)) {
+    			return $value;
+    		}
+    	}
+
+    	return false;
+
+    }
 }
\ No newline at end of file

From 253065f89c495dfd6efc88812fad7f389f295c5b Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Wed, 11 Jan 2017 13:49:03 +1300
Subject: [PATCH 27/66] Change conditional block to not return too early

---
 .../Scaffolders/DataObjectScaffolder.php      | 46 +++++++++----------
 1 file changed, 22 insertions(+), 24 deletions(-)

diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
index 196791616..54ece115e 100644
--- a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -338,33 +338,31 @@ public function applyConfig(array $config)
             $this->addAllFieldsExcept($config['fieldsExcept']);
         }
 
-        if (!isset($config['operations'])) {
-            return $this;
-        }
-
-        if ($config['operations'] === '*') {
-            $config['operations'] = [
-                GraphQLScaffolder::CREATE => true,
-                GraphQLScaffolder::READ => true,
-                GraphQLScaffolder::UPDATE => true,
-                GraphQLScaffolder::DELETE => true,
-            ];
-        }
+        if (isset($config['operations'])) {            
+	        if ($config['operations'] === '*') {
+	            $config['operations'] = [
+	                GraphQLScaffolder::CREATE => true,
+	                GraphQLScaffolder::READ => true,
+	                GraphQLScaffolder::UPDATE => true,
+	                GraphQLScaffolder::DELETE => true,
+	            ];
+	        }
 
-        if (!ArrayLib::is_associative($config['operations'])) {
-            throw new \Exception(
-                'Operations field must be a map of operation names to a map of settings, or true/false'
-            );
-        }
+	        if (!ArrayLib::is_associative($config['operations'])) {
+	            throw new \Exception(
+	                'Operations field must be a map of operation names to a map of settings, or true/false'
+	            );
+	        }
 
-        foreach ($config['operations'] as $opID => $opSettings) {
-            if ($opSettings === false) {
-                continue;
-            }
+	        foreach ($config['operations'] as $opID => $opSettings) {
+	            if ($opSettings === false) {
+	                continue;
+	            }
 
-            $this->operation($opID)
-                ->applyConfig((array) $opSettings);
-        }
+	            $this->operation($opID)
+	                ->applyConfig((array) $opSettings);
+	        }
+    	}
 
         if (isset($config['nestedQueries'])) {
             if (!ArrayLib::is_associative($config['nestedQueries'])) {

From 6e4d784feb1e8e45ab794e97bf71e2721ad61ee7 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Wed, 11 Jan 2017 13:49:28 +1300
Subject: [PATCH 28/66] Change "scaffolds" to "types"

---
 .../Scaffolders/GraphQLScaffolder.php         | 34 ++++++++++++++++---
 1 file changed, 29 insertions(+), 5 deletions(-)

diff --git a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
index 38dff6703..fc45dbc06 100644
--- a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
+++ b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
@@ -27,7 +27,7 @@ class GraphQLScaffolder implements ManagerMutatorInterface
     /**
      * @var array
      */
-    protected $scaffolds = [];
+    protected $types = [];
 
     /**
      * @var OperationList
@@ -114,7 +114,7 @@ public function __construct()
      */
     public function type($class)
     {
-        foreach ($this->scaffolds as $scaffold) {
+        foreach ($this->types as $scaffold) {
             if ($scaffold->getDataObjectClass() == $class) {
                 return $scaffold;
             }
@@ -122,7 +122,7 @@ public function type($class)
 
         $scaffold = (new DataObjectScaffolder($class))
                 ->setChainableParent($this);
-        $this->scaffolds[] = $scaffold;
+        $this->types[] = $scaffold;
 
         return $scaffold;
     }
@@ -211,6 +211,30 @@ public function removeQuery($name)
         return $this;
     }
 
+    /**
+     * @return array
+     */
+    public function getTypes()
+    {
+    	return $this->types;
+    }
+
+    /**
+     * @return OperationList
+     */
+    public function getQueries()
+    {
+    	return $this->queries;
+    }
+
+    /**
+     * @return OperationList
+     */
+    public function getMutations()
+    {
+    	return $this->mutations;
+    }
+
     /**
      * Adds every DataObject and its dependencies to the Manager.
      *
@@ -218,7 +242,7 @@ public function removeQuery($name)
      */
     public function addToManager(Manager $manager)
     {
-        foreach ($this->scaffolds as $scaffold) {
+        foreach ($this->types as $scaffold) {
             // Add dependent classes, e.g has_one, has_many nested queries
             foreach ($scaffold->getDependentClasses() as $class) {
                 $this->type($class);
@@ -243,7 +267,7 @@ public function addToManager(Manager $manager)
         }
 
         // Add all DataObjects to the manager
-        foreach ($this->scaffolds as $scaffold) {
+        foreach ($this->types as $scaffold) {
             $scaffold->addToManager($manager);
         }
 

From 7a83af4d9786eb018607c75d80da8ed2f7dcb013 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Wed, 11 Jan 2017 13:50:33 +1300
Subject: [PATCH 29/66] Use injector get instead of create

---
 src/Scaffolding/Scaffolders/GraphQLScaffolder.php | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
index fc45dbc06..203008c36 100644
--- a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
+++ b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
@@ -50,7 +50,7 @@ class GraphQLScaffolder implements ManagerMutatorInterface
      */
     public static function createFromConfig($config)
     {
-        $scaffolder = Injector::inst()->create(self::class);
+        $scaffolder = Injector::inst()->get(self::class);
         if (isset($config['types'])) {
             if (!ArrayLib::is_associative($config['types'])) {
                 throw new InvalidArgumentException(

From f5b0a38701ecb6d28aa2f60fb44909759aa565c9 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Wed, 11 Jan 2017 13:50:43 +1300
Subject: [PATCH 30/66] Remove debug

---
 src/Scaffolding/Scaffolders/OperationScaffolder.php | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Scaffolding/Scaffolders/OperationScaffolder.php b/src/Scaffolding/Scaffolders/OperationScaffolder.php
index 72df3961c..da70cca7f 100644
--- a/src/Scaffolding/Scaffolders/OperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/OperationScaffolder.php
@@ -118,7 +118,6 @@ public function setResolver($resolver)
             if (is_subclass_of($resolver, ResolverInterface::class)) {
                 $this->resolver = Injector::inst()->create($resolver);
             } else {
-                var_dump($resolver);
                 throw new InvalidArgumentException(sprintf(
                     '%s::setResolver() accepts closures, instances of %s or names of resolver subclasses.',
                     __CLASS__,

From b241d0def2c354c3654a33a0485f916fe05613a3 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Wed, 11 Jan 2017 13:50:52 +1300
Subject: [PATCH 31/66] Expose args to public api

---
 src/Scaffolding/Scaffolders/OperationScaffolder.php | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/Scaffolding/Scaffolders/OperationScaffolder.php b/src/Scaffolding/Scaffolders/OperationScaffolder.php
index da70cca7f..04293a983 100644
--- a/src/Scaffolding/Scaffolders/OperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/OperationScaffolder.php
@@ -103,6 +103,14 @@ public function getName()
         return $this->operationName;
     }
 
+    /**
+     * @return array
+     */
+    public function getArgs()
+    {
+    	return $this->args;
+    }
+
     /**
      * @param $resolver
      *

From fb5cd0db56fae8b3e5a93afd009a9419793bd32f Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Wed, 11 Jan 2017 14:20:07 +1300
Subject: [PATCH 32/66] Add new tests

---
 tests/Fake/FakeResolver.php            |    2 +-
 tests/Fake/OperationScaffolderFake.php |    7 +
 tests/ScaffoldingTest.php              | 1624 ++++++++++++------------
 3 files changed, 855 insertions(+), 778 deletions(-)
 create mode 100644 tests/Fake/OperationScaffolderFake.php

diff --git a/tests/Fake/FakeResolver.php b/tests/Fake/FakeResolver.php
index f0c7477fc..30a62346d 100644
--- a/tests/Fake/FakeResolver.php
+++ b/tests/Fake/FakeResolver.php
@@ -2,7 +2,7 @@
 
 namespace SilverStripe\GraphQL\Tests\Fake;
 
-use SilverStripe\GraphQL\Scaffolding\ResolverInterface;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ResolverInterface;
 
 class FakeResolver implements ResolverInterface
 {
diff --git a/tests/Fake/OperationScaffolderFake.php b/tests/Fake/OperationScaffolderFake.php
new file mode 100644
index 000000000..75b4b99c9
--- /dev/null
+++ b/tests/Fake/OperationScaffolderFake.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace SilverStripe\GraphQL\Tests\Fake;
+
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\OperationScaffolder;
+
+class OperationScaffolderFake extends OperationScaffolder {}
\ No newline at end of file
diff --git a/tests/ScaffoldingTest.php b/tests/ScaffoldingTest.php
index a01210d66..c980ff531 100644
--- a/tests/ScaffoldingTest.php
+++ b/tests/ScaffoldingTest.php
@@ -3,787 +3,857 @@
 namespace SilverStripe\GraphQL;
 
 use SilverStripe\Dev\SapphireTest;
-// use GraphQL\Type\Definition\Type;
-// use GraphQL\Type\Definition\NonNull;
-// use GraphQL\Type\Definition\InputObjectType;
-// use SilverStripe\GraphQL\Scaffolding\Creators\DataObjectTypeCreator;
-// use SilverStripe\GraphQL\Manager;
-// use GraphQL\Type\Definition\ResolveInfo;
-// use GraphQL\Type\Definition\ObjectType;
-// use GraphQL\Type\Definition\ListOfType;
-// use GraphQL\Type\Definition\StringType;
-// use GraphQL\Type\Definition\IntType;
-// use SilverStripe\GraphQL\Tests\Fake\DataObjectFake;
-// use SilverStripe\GraphQL\Scaffolding\Creators\MutationOperationCreator;
-// use SilverStripe\GraphQL\Scaffolding\Creators\QueryOperationCreator;
-// use SilverStripe\GraphQL\Scaffolding\Creators\PaginatedQueryOperationCreator;
-// use SilverStripe\GraphQL\Tests\Fake\FakeResolver;
-// use SilverStripe\GraphQL\Scaffolding\Scaffolders\MutationScaffolder;
-// use SilverStripe\GraphQL\Scaffolding\Scaffolders\OperationScaffolder;
-// use SilverStripe\GraphQL\Scaffolding\Scaffolders\DataObjectScaffolder;
-// use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
-// use SilverStripe\GraphQL\Scaffolding\Scaffolders\QueryScaffolder;
-// use SilverStripe\GraphQL\Scaffolding\Scaffolders\CreateOperationScaffolder;
-// use SilverStripe\GraphQL\Scaffolding\Scaffolders\UpdateOperationScaffolder;
-// use SilverStripe\GraphQL\Scaffolding\Scaffolders\DeleteOperationScaffolder;
-// use SilverStripe\GraphQL\Scaffolding\Scaffolders\ReadOperationScaffolder;
-// use Doctrine\Instantiator\Exception\InvalidArgumentException;
-// use SilverStripe\GraphQL\Scaffolding\OperationList;
-// use SilverStripe\Core\Config\Config;
-// use SilverStripe\Security\Member;
-// use SilverStripe\Assets\File;
-// use ReflectionClass;
-// use SilverStripe\GraphQL\Scaffolding\Util\ArgsParser;
-// use SilverStripe\GraphQL\Scaffolding\Util\TypeParser;
-// use SilverStripe\GraphQL\Pagination\Connection;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\DataObjectScaffolder;
+use SilverStripe\GraphQL\Tests\Fake\DataObjectFake;
+use SilverStripe\GraphQL\Tests\Fake\OperationScaffolderFake;
+use SilverStripe\GraphQL\Tests\Fake\FakeResolver;
+use Doctrine\Instantiator\Exception\InvalidArgumentException;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\OperationScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\QueryScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\MutationScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\CRUD\Create;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\CRUD\Read;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\CRUD\Update;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\CRUD\Delete;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\CRUDInterface;
+use SilverStripe\GraphQL\Scaffolding\Util\ArgsParser;
+use SilverStripe\GraphQL\Scaffolding\Util\TypeParser;
+use SilverStripe\GraphQL\Scaffolding\Util\OperationList;
+use SilverStripe\GraphQL\Manager;
+use GraphQL\Type\Definition\ObjectType;
+use GraphQL\Type\Definition\StringType;
+use GraphQL\Type\Definition\NonNull;
+use GraphQL\Type\Definition\Type;
+use SilverStripe\CMS\Model\RedirectorPage;
+use SilverStripe\CMS\Model\SiteTree;
+use SilverStripe\Security\Member;
+use SilverStripe\Assets\File;
+use SilverStripe\Core\Config\Config;
+use SilverStripe\Core\Injector\Injector;
+use Exception;
+use Page;
 
 class ScaffoldingTest extends SapphireTest
 {
 
-  //   public function testDataObjectTypeCreator()
-  //   {
-  //       $creator = new DataObjectTypeCreator(new Manager, 'test', ['Foo' => 'Bar']);
-
-  //       $this->assertEquals(['name' => 'test'], $creator->attributes());
-  //       $this->assertEquals(['Foo' => 'Bar'], $creator->fields());
-
-  //       $fake = new DataObjectFake([
-  //           'MyField' => 'test'
-  //       ]);
-  //       $info = new ResolveInfo(['fieldName' => 'MyField']);
-
-  //       $result = $creator->resolveField($fake, [], null, $info);
-
-  //       $this->assertInstanceOf('SilverStripe\ORM\FieldType\DBVarchar', $result);
-  //       $this->assertEquals('test', $result->getValue());
-  //   }
-
-  //   public function testMutationOperationCreator()
-  //   {
-  //       $managerMock = $this->getMockBuilder(Manager::class)
-  //           ->setMethods(['getType'])
-  //           ->getMock();
-  //       $managerMock
-  //           ->method('getType')
-  //           ->will($this->returnArgument(0));
-
-  //       $mutationCreator = new MutationOperationCreator($managerMock, 'testOperation', 'testType', 'testResolver');
-  //       $result = $mutationCreator->type();
-
-  //       $this->assertInstanceOf('\Closure', $result);
-  //       $this->assertEquals('testType', $result());
-
-  //   }
-
-  //   public function testQueryOperationCreator()
-  //   {
-  //       $managerMock = $this->getMockBuilder(Manager::class)
-  //           ->setMethods(['getType'])
-  //           ->getMock();
-  //       $managerMock
-  //           ->method('getType')
-  //           ->willReturn(new ObjectType(['name' => 'test']));
-
-  //       $mutationCreator = new QueryOperationCreator($managerMock, 'testOperation', 'testType','testResolver');
-  //       $result = $mutationCreator->type();
-
-  //       $this->assertInstanceOf('\Closure', $result);
-  //       $this->assertInstanceOf(ListOfType::class, $result());
-  //       $this->assertInstanceOf(ObjectType::class, $result()->getWrappedType());
-  //       $this->assertEquals('test', $result()->getWrappedType()->config['name']);
-
-  //   }
-
-  //   public function testOperationCreatorConstuctor()
-  //   {
-  //       $mutationCreator = $this->createOperationCreator();
-  //       $this->assertEquals(['name' => 'testOperation'], $mutationCreator->attributes());
-  //       $this->assertEquals(['foo' => 'bar'], $mutationCreator->args());
-
-  //       $this->assertInstanceOf('\Closure', $mutationCreator->toArray()['resolve']);
-  //   }
-
-  //   public function testOperationCreatorAcceptsClosureAsResolver()
-  //   {
-  //       // test resolvers
-  //       $mutationCreator = $this->createOperationCreator(function () {
-  //           return 'abc';
-  //       });
-  //       $field = $mutationCreator->toArray();
-  //       $this->assertEquals('abc', $field['resolve'](null, [], null, null));
-  //   }
-
-  //   public function testOperationCreatorAcceptsResolverInterfaceInstanceAsResolver()
-  //   {
-  //       $mutationCreator = $this->createOperationCreator(new FakeResolver());
-  //       $field = $mutationCreator->toArray();
-  //       $this->assertEquals('resolved', $field['resolve'](null, [], null, null));
-  //   }
-
-  //   public function testExceptionThrownOnBadResolver()
-  //   {
-  //       $this->setExpectedException(\Exception::class);
-  //       $mutationCreator = $this->createOperationCreator(FakeResolver::class);
-  //       $field = $mutationCreator->toArray();
-  //       $field['resolve'](null, [], null, null);
-  //   }
-
-  //   public function testMutationOperationScaffolderCore()
-  //   {
-  //       $scaffolder = new MutationScaffolder(
-  //           'testOperation',
-  //           'testType'
-  //       );
-
-  //       $this->assertEquals('testOperation', $scaffolder->getName());
-
-  //       $creator = $scaffolder->getCreator(new Manager());
-  //       $this->assertInstanceOf(MutationOperationCreator::class, $creator);
-  //       $this->assertEquals(['name' => 'testOperation'], $creator->attributes());
-  //   }
-
-  //   public function testQueryOperationScaffolderCore()
-  //   {
-  //       $scaffolder = new QueryScaffolder(
-  //           'testOperation',
-  //           'testType'
-  //       );
-
-  //       $this->assertEquals('testOperation', $scaffolder->getName());
-
-  //       $creator = $scaffolder->getCreator(new Manager());
-  //       $this->assertInstanceOf(PaginatedQueryOperationCreator::class, $creator);
-  //       $this->assertEquals(['name' => 'testOperation'], $creator->attributes());
-
-  //       $scaffolder->setUsePagination(false);
-  //       $creator = $scaffolder->getCreator(new Manager());
-  //       $this->assertInstanceOf(QueryOperationCreator::class, $creator);
-		// $this->assertEquals(['name' => 'testOperation'], $creator->attributes());        
-  //   }
-
-  //   public function testOperationScaffolderCreator()
-  //   {
-  //       $scaffolder = new MutationScaffolder(
-  //           'testOperation',
-  //           'testType'
-  //       );
-
-  //       $scaffolder->addArgs(['foo' => 'String']);
-  //       $creator = $scaffolder->getCreator(new Manager());
-  //       // only test the keys to isolate testing of ArgsParser
-  //       $this->assertEquals(['foo'], array_keys($creator->args()));
-  //       $scaffolder->addArgs(['qux' => 'Int']);
-  //       $creator = $scaffolder->getCreator(new Manager());
-  //       $this->assertEquals(['foo', 'qux'], array_keys($creator->args()));
-
-  //       $scaffolder->setResolver(function () {
-  //       });
-  //   }
-
-  //   public function testOperationScaffolderRejectsInvalidResolvers()
-  //   {
-  //       $this->setExpectedException(InvalidArgumentException::class);
-  //       $scaffolder = new MutationScaffolder(
-  //           'testOperation',
-  //           'testType',
-  //           'notAValidResover'
-  //       );
-  //   }
-
-  //   public function testOperationScaffolderAcceptsValidResolvers()
-  //   {
-  //       $m = new Manager();
-  //       $resolver = $this->getMockBuilder(FakeResolver::class)
-  //           ->setMethods(['resolve'])
-  //           ->getMock();
-  //       $resolver->expects($this->once())
-  //           ->method('resolve');
-
-
-  //       $scaffolder = new MutationScaffolder(
-  //           'testOperation',
-  //           'testType',
-  //           $resolver
-  //       );
-
-  //       $resolveMethod = $scaffolder->getCreator($m)->toArray()['resolve'];
-  //       $resolveMethod(null, null, null, null);
-
-  //       $scaffolder = new MutationScaffolder(
-  //           'testOperation',
-  //           'testType',
-  //           function () {
-  //           }
-  //       );
-
-  //       $this->assertInstanceOf('\Closure', $scaffolder->getCreator($m)->toArray()['resolve']);
-  //   }
-
-
-  //   public function testOperationScaffolderCreateFromConfig()
-  //   {
-  //       $exception = null;
-  //       $mockManager = $this->getMockBuilder(Manager::class)
-  //           ->setMethods(['getType'])
-  //           ->getMock();
-  //       $mockManager
-  //           ->expects($this->once())
-  //           ->method('getType')
-  //           ->willReturn('abc');
-
-  //       try {
-  //           MutationScaffolder::createFromConfig('test', []);
-  //       } catch (\Exception $e) {
-  //           $exception = $e;
-  //       }
-  //       $this->assertInstanceOf('\Exception', $e);
-
-  //       try {
-  //           MutationScaffolder::createFromConfig('test', [
-  //               'name' => 'testOperation',
-  //               'resolver' => 'not a resolver'
-  //           ]);
-  //       } catch (\Exception $e) {
-  //           $exception = $e;
-  //       }
-
-  //       $this->assertInstanceOf('\Exception', $e);
-
-  //       $result = MutationScaffolder::createFromConfig('test', [
-  //           'name' => 'testOperation',
-  //           'resolver' => FakeResolver::class
-  //       ]);
-
-  //       $this->assertInstanceOf(MutationScaffolder::class, $result);
-
-  //       $creator = $result->getCreator($mockManager);
-  //       $typeCreator = $creator->type();
-  //       $type = $typeCreator();
-  //       $this->assertEquals('abc', $type);
-  //   }
-
-  //   public function testDataObjectScaffolderConstructor()
-  //   {
-  //       $this->setExpectedException(InvalidArgumentException::class);
-  //       $scaffolder = new DataObjectScaffolder('Not\A\Real\Thing');
-  //   }
-
-  //   public function testDataObjectScaffolderQueriesAndMutations()
-  //   {
-  //       $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
-
-  //       $this->assertInstanceOf(OperationList::class, $scaffolder->getQueries());
-  //       $this->assertInstanceOf(OperationList::class, $scaffolder->getMutations());
-
-  //       $query = $scaffolder->query('test');
-
-  //       $this->assertInstanceOf(QueryScaffolder::class, $query);
-  //       $this->assertEquals('test', $query->getName());
-
-  //       $mutation = $scaffolder->mutation('test');
-
-  //       $this->assertInstanceOf(MutationScaffolder::class, $mutation);
-  //       $this->assertEquals('test', $mutation->getName());
-
-  //       $query2 = $scaffolder->query('test');
-  //       $this->assertEquals(1, $scaffolder->getQueries()->count());
-
-  //       $mutation2 = $scaffolder->mutation('test');
-  //       $this->assertEquals(1, $scaffolder->getMutations()->count());
-
-  //       $this->assertSame($query, $query2);
-  //       $this->assertSame($mutation, $mutation2);
-
-  //       $query3 = $scaffolder->query('abc');
-  //       $mutation3 = $scaffolder->mutation('abc');
-
-  //       $this->assertEquals(2, $scaffolder->getQueries()->count());
-  //       $this->assertEquals(2, $scaffolder->getMutations()->count());
+	public function testDataObjectScaffolderConstructor()
+	{
+		$scaffolder = $this->getFakeScaffolder();
+		$this->assertEquals(DataObjectFake::class, $scaffolder->getDataObjectClass());
+		$this->assertInstanceOf(DataObjectFake::class, $scaffolder->getDataObjectInstance());
+
+		$this->setExpectedExceptionRegExp(
+			InvalidArgumentException::class,
+			'/non-existent classname/'
+		);
+		$scaffolder = new DataObjectScaffolder('fail');
+	}
+
+	public function testDataObjectScaffolderFields()
+	{
+		$scaffolder = $this->getFakeScaffolder();
+		
+		$scaffolder->addField('MyField');
+		$this->assertEquals(['MyField'], $scaffolder->getFields()->toArray());
+		
+		$scaffolder->addFields(['MyField','MyInt']);
+		$this->assertEquals(['MyField', 'MyInt'], $scaffolder->getFields()->toArray());
+
+		$scaffolder = $this->getFakeScaffolder();
+		$scaffolder->addAllFields();
+		$this->assertEquals(['ID','ClassName','LastEdited','Created','MyField','MyInt'], $scaffolder->getFields()->toArray());
+
+		$scaffolder = $this->getFakeScaffolder();
+		$scaffolder->addAllFields(true);
+		$this->assertEquals(['ID','ClassName','LastEdited','Created','MyField','MyInt', 'Author'], $scaffolder->getFields()->toArray());
+
+		$scaffolder = $this->getFakeScaffolder();
+		$scaffolder->addAllFieldsExcept('MyInt');
+		$this->assertEquals(['ID','ClassName','LastEdited','Created','MyField'], $scaffolder->getFields()->toArray());
+
+		$scaffolder = $this->getFakeScaffolder();
+		$scaffolder->addAllFieldsExcept('MyInt', true);
+		$this->assertEquals(['ID','ClassName','LastEdited','Created','MyField','Author'], $scaffolder->getFields()->toArray());
+
+		$scaffolder->removeField('ClassName');
+		$this->assertEquals(['ID','LastEdited','Created','MyField','Author'], $scaffolder->getFields()->toArray());
+		$scaffolder->removeFields(['LastEdited','Created']);
+		$this->assertEquals(['ID','MyField','Author'], $scaffolder->getFields()->toArray());
+	}
+
+
+	public function testDataObjectScaffolderOperations()
+	{
+		$scaffolder = $this->getFakeScaffolder();
+		$op = $scaffolder->operation(GraphQLScaffolder::CREATE);
+
+		$this->assertInstanceOf(CRUDInterface::class, $op);
+
+		// Ensure we get back the same reference
+		$op->Test = true;
+		$op = $scaffolder->operation(GraphQLScaffolder::CREATE);
+		$this->assertEquals(true, $op->Test);
+
+		// Ensure duplicates aren't created
+		$scaffolder->operation(GraphQLScaffolder::DELETE);
+		$this->assertEquals(2, $scaffolder->getOperations()->count());
+
+		$scaffolder->removeOperation(GraphQLScaffolder::DELETE);
+		$this->assertEquals(1, $scaffolder->getOperations()->count());
+
+		$this->setExpectedExceptionRegExp(
+			InvalidArgumentException::class,
+			'/Invalid operation/'
+		);
+		$scaffolder = $this->getFakeScaffolder();
+		$scaffolder->operation('fail');
+	}
+
+	public function testDataObjectScaffolderNestedQueries()
+	{
+		$scaffolder = $this->getFakeScaffolder();
+		$query = $scaffolder->nestedQuery('Files');
+
+		$this->assertInstanceOf(QueryScaffolder::class, $query);
+
+		// Ensure we get back the same reference
+		$query->Test = true;
+		$query = $scaffolder->nestedQuery('Files');
+		$this->assertEquals(true, $query->Test);
+
+		// Ensure duplicates aren't created
+		$this->assertEquals(1, $scaffolder->getNestedQueries()->count());
+
+		$this->setExpectedExceptionRegExp(
+			InvalidArgumentException::class,
+			'/returns a DataList or ArrayList/'
+		);
+		$scaffolder = $this->getFakeScaffolder();
+		$scaffolder->nestedQuery('MyField');
+
+	}
+
+	public function testDataObjectScaffolderDependentClasses()
+	{
+		$scaffolder = $this->getFakeScaffolder();
+		$this->assertEquals([], $scaffolder->getDependentClasses());
+		$scaffolder->nestedQuery('Files');
+		$this->assertEquals(
+			[$scaffolder->getDataObjectInstance()->Files()->dataClass()],
+			$scaffolder->getDependentClasses()
+		);
+
+		$scaffolder->addField('Author');
+		$this->assertEquals(
+			[
+				$scaffolder->getDataObjectInstance()->Author()->class,
+				$scaffolder->getDataObjectInstance()->Files()->dataClass()
+			],
+			$scaffolder->getDependentClasses()
+		);
+	}
+
+	public function testDataObjectScaffolderAncestralClasses()
+	{
+		$scaffolder = new DataObjectScaffolder(RedirectorPage::class);
+		$classes = $scaffolder->getAncestralClasses();
+
+		$this->assertEquals([
+			'Page','SilverStripe\CMS\Model\SiteTree'
+		], $classes);
+
+	}
+
+	public function testDataObjectScaffolderApplyConfig()
+	{
+		$observer = $this->getMockBuilder(DataObjectScaffolder::class)
+			->setConstructorArgs([DataObjectFake::class])
+			->setMethods(['addFields','addAllFieldsExcept','operation','nestedQuery'])
+			->getMock();
+
+		$observer->expects($this->once())
+			->method('addFields')
+			->with($this->equalTo(['MyField']));
+
+		$observer->expects($this->once())
+			->method('addAllFieldsExcept')
+			->with($this->equalTo(['MyField']));
+
+		$observer->expects($this->exactly(2))
+			->method('operation')
+			->withConsecutive(
+				[$this->equalTo(GraphQLScaffolder::CREATE)],
+				[$this->equalTo(GraphQLScaffolder::READ)]
+			)
+			->will($this->returnValue(
+				$this->getMockBuilder(Create::class)
+					->disableOriginalConstructor()
+					->getMock()
+			));
+
+		$observer->expects($this->once())
+			->method('nestedQuery')
+			->with($this->equalTo('Files'))
+			->will($this->returnValue(
+				$this->getMockBuilder(QueryScaffolder::class)
+					->disableOriginalConstructor()
+					->getMock()
+			));
+
+
+		$observer->applyConfig([
+			'fields' => ['MyField'],
+			'fieldsExcept' => ['MyField'],
+			'operations' => ['create' => true,'read' => true],
+			'nestedQueries' => ['Files' => true]
+		]);
+
+	}
+
+	public function testDataObjectScaffolderApplyConfigNoFieldsException()
+	{
+		$scaffolder = $this->getFakeScaffolder();
+
+		// Must have "fields" defined
+		$this->setExpectedExceptionRegExp(
+			Exception::class,
+			'/No array of fields/'
+		);
+		$scaffolder->applyConfig([
+			'operations' => ['create' => true]
+		]);
+	}
+
+	public function testDataObjectScaffolderApplyConfigInvalidFieldsException()
+	{
+		$scaffolder = $this->getFakeScaffolder();
+
+		// Invalid fields
+		$this->setExpectedExceptionRegExp(
+			Exception::class,
+			'/Fields must be an array/'
+		);
+		$scaffolder->applyConfig([
+			'fields' => 'fail'
+		]);
+	}
+
+	public function testDataObjectScaffolderApplyConfigInvalidFieldsExceptException()
+	{
+		$scaffolder = $this->getFakeScaffolder();
+
+		// Invalid fieldsExcept
+		$this->setExpectedExceptionRegExp(
+			InvalidArgumentException::class,
+			'/"fieldsExcept" must be an array/'
+		);
+		$scaffolder->applyConfig([
+			'fieldsExcept' => 'fail'
+		]);
+	}
+
+	public function testDataObjectScaffolderApplyConfigInvalidOperationsException()
+	{
+		$scaffolder = $this->getFakeScaffolder();
+
+		// Invalid operations
+		$this->setExpectedExceptionRegExp(
+			Exception::class,
+			'/Operations field must be a map/'
+		);
+		$scaffolder->applyConfig([
+			'fieldsExcept' => ['MyField'],
+			'operations' => ['create']
+		]);
+	}
+
+	public function testDataObjectScaffolderApplyConfigInvalidNestedQueriesException()
+	{
+		$scaffolder = $this->getFakeScaffolder();
+
+		// Invalid nested queries
+		$this->setExpectedExceptionRegExp(
+			Exception::class,
+			'/"nestedQueries" must be a map of relation name/'
+		);
+		$scaffolder->applyConfig([
+			'fields' => ['MyField'],
+			'nestedQueries' => ['Files']
+		]);
+	}
+
+
+
+	public function testDataObjectScaffolderWildcards()
+	{
+		$scaffolder = $this->getFakeScaffolder();
+		$scaffolder->applyConfig([
+			'fields' => '*',
+			'operations' => '*'
+		]);
+		$ops = $scaffolder->getOperations();
+
+		$this->assertInstanceOf(Create::class, $ops->findByIdentifier(GraphQLScaffolder::CREATE));
+		$this->assertInstanceOf(Delete::class, $ops->findByIdentifier(GraphQLScaffolder::DELETE));
+		$this->assertInstanceOf(Read::class, $ops->findByIdentifier(GraphQLScaffolder::READ));
+		$this->assertInstanceOf(Update::class, $ops->findByIdentifier(GraphQLScaffolder::UPDATE));
+
+		$this->assertEquals(
+			['ID','ClassName','LastEdited','Created','MyField','MyInt'],
+			$scaffolder->getFields()->toArray()
+		);
+	}
+
+	public function testDataObjectScaffolderScaffold()
+	{
+		$scaffolder = $this->getFakeScaffolder();
+		$scaffolder->addFields(['MyField', 'Author'])
+				   ->nestedQuery('Files');
+
+		$objectType = $scaffolder->scaffold(new Manager());
+
+		$this->assertInstanceof(ObjectType::class, $objectType);
+		$config = $objectType->config;
+
+		$this->assertEquals($scaffolder->typeName(), $config['name']);
+		$this->assertEquals(['MyField', 'Author', 'Files'], array_keys($config['fields']));
+	}
+
+	public function testDataObjectScaffolderScaffoldFieldException()
+	{
+		$this->setExpectedExceptionRegExp(
+			InvalidArgumentException::class,
+			'/Invalid field/'
+		);
+		$scaffolder = $this->getFakeScaffolder()
+			->addFields(['not a field'])
+			->scaffold(new Manager());		
+	}
+
+	public function testDataObjectScaffolderScaffoldNestedQueryException()
+	{
+		$this->setExpectedExceptionRegExp(
+			InvalidArgumentException::class,
+			'/returns a list/'
+		);
+		$scaffolder = $this->getFakeScaffolder()
+			->addFields(['Files'])
+			->scaffold(new Manager());
+	}
+
+	public function testDataObjectScaffolderAddToManager()
+	{
+		$manager = new Manager();
+		$scaffolder = $this->getFakeScaffolder()
+			->addFields(['MyField'])
+			->operation(GraphQLScaffolder::CREATE)
+				->end()
+			->operation(GraphQLScaffolder::READ)
+				->end();
+
+		$scaffolder->addToManager($manager);
+
+		$schema = $manager->schema();
+		$queryConfig = $schema->getQueryType()->config;
+		$mutationConfig = $schema->getMutationType()->config;
+		$types = $schema->getTypeMap();
+
+		$this->assertArrayHasKey(
+			(new Read(DataObjectFake::class))->getName(),
+			$queryConfig['fields']
+		);
+
+		$this->assertArrayHasKey(
+			(new Create(DataObjectFake::class))->getName(),
+			$mutationConfig['fields']
+		);
+
+		$this->assertTrue($manager->hasType($scaffolder->typeName()));
+
+	}
+
+
+	public function testGraphQLScaffolderTypes()
+	{
+
+		$scaffolder = new GraphQLScaffolder();
+		$type = $scaffolder->type(DataObjectFake::class);
+		$type->Test = true;
+		$type2 = $scaffolder->type(DataObjectFake::class);
+
+		$query = $scaffolder->query('testQuery', DataObjectFake::class);
+		$query->Test = true;
+		$query2 = $scaffolder->query('testQuery', DataObjectFake::class);
+
+		$mutation = $scaffolder->mutation('testMutation', DataObjectFake::class);
+		$mutation->Test = true;
+		$mutation2 = $scaffolder->mutation('testMutation', DataObjectFake::class);
+
+		$this->assertEquals(1, count($scaffolder->getTypes()));
+		$this->assertTrue($type2->Test);
+
+		$this->assertEquals(1, $scaffolder->getQueries()->count());
+		$this->assertTrue($query2->Test);
+
+		$this->assertEquals(1, $scaffolder->getMutations()->count());
+		$this->assertTrue($mutation2->Test);
+
+		$scaffolder->removeQuery('testQuery');
+		$this->assertEquals(0, $scaffolder->getQueries()->count());
+
+		$scaffolder->removeMutation('testMutation');
+		$this->assertEquals(0, $scaffolder->getMutations()->count());
+
+	}
+
+	public function testGraphQLScaffolderAddToManager()
+	{
+		Config::inst()->update('Page','db', [
+			'TestPageField' => 'Varchar'
+		]);
+
+		$manager = new Manager();
+		$scaffolder = (new GraphQLScaffolder())
+			->type(RedirectorPage::class)
+				->addFields(['Created','TestPageField', 'RedirectionType'])
+				->operation(GraphQLScaffolder::CREATE)
+					->end()
+				->operation(GraphQLScaffolder::READ)
+					->end()
+				->end()
+			->type(DataObjectFake::class)
+				->addFields(['Author'])
+				->nestedQuery('Files')
+					->end()
+				->end()
+			->query('testQuery', DataObjectFake::class)
+				->end()
+			->mutation('testMutation', DataObjectFake::class)
+				->end();
+
+		$scaffolder->addToManager($manager);
+		$queries = $scaffolder->getQueries();
+		$mutations = $scaffolder->getMutations();
+		$types = $scaffolder->getTypes();
+
+		$classNames = array_map(function($scaffold) {
+			return $scaffold->getDataObjectClass();
+		}, $types);
+
+		$this->assertEquals([
+			RedirectorPage::class,			
+			DataObjectFake::class,			
+			Page::class,
+			SiteTree::class,
+			Member::class,
+			File::class
+		], $classNames);
+
+		$this->assertEquals([
+			'Created', 'TestPageField', 'RedirectionType'
+		], $scaffolder->type(RedirectorPage::class)->getFields()->toArray());
+
+		$this->assertEquals([
+			'Created', 'TestPageField'
+		], $scaffolder->type(Page::class)->getFields()->toArray());
+
+		$this->assertEquals([
+			'Created'
+		], $scaffolder->type(SiteTree::class)->getFields()->toArray());
+
+
+		$this->assertEquals('testQuery', $scaffolder->getQueries()->first()->getName());
+		$this->assertEquals('testMutation', $scaffolder->getMutations()->first()->getName());
+
+		$this->assertInstanceof(
+			Read::class,			
+			$scaffolder->type(RedirectorPage::class)->getOperations()->findByIdentifier(GraphQLScaffolder::READ)
+		);
+		$this->assertInstanceof(
+			Read::class,			
+			$scaffolder->type(Page::class)->getOperations()->findByIdentifier(GraphQLScaffolder::READ)
+		);
+		$this->assertInstanceof(
+			Read::class,			
+			$scaffolder->type(SiteTree::class)->getOperations()->findByIdentifier(GraphQLScaffolder::READ)
+		);
+
+		$this->assertInstanceof(
+			Create::class,			
+			$scaffolder->type(RedirectorPage::class)->getOperations()->findByIdentifier(GraphQLScaffolder::CREATE)
+		);
+		$this->assertInstanceof(
+			Create::class,			
+			$scaffolder->type(Page::class)->getOperations()->findByIdentifier(GraphQLScaffolder::CREATE)
+		);
+		$this->assertInstanceof(
+			Create::class,			
+			$scaffolder->type(SiteTree::class)->getOperations()->findByIdentifier(GraphQLScaffolder::CREATE)
+		);
+	}
+
+	public function testGraphQLScaffolderCreateFromConfigThrowsIfBadTypes()
+	{
+		$this->setExpectedExceptionRegExp(
+			InvalidArgumentException::class,
+			'/"types" must be a map of class name to settings/'
+		);
+		GraphQLScaffolder::createFromConfig([
+			'types' => ['fail']
+		]);
+	}
+
+	public function testGraphQLScaffolderCreateFromConfigThrowsIfBadQueries()
+	{
+		$this->setExpectedExceptionRegExp(
+			InvalidArgumentException::class,
+			'/must be a map of operation name to settings/'
+		);
+		GraphQLScaffolder::createFromConfig([
+			'types' => [
+				DataObjectFake::class => [
+					'fields' => '*'
+				]
+			],
+			'queries' => ['fail']
+		]);
+	}
+
+	public function testGraphQLScaffolderCreateFromConfig()
+	{
+		$observer = $this->getMockBuilder(GraphQLScaffolder::class)
+			->setMethods(['query','mutation','type'])
+			->getMock();
+
+		$observer->expects($this->once())
+			->method('query')
+			->will($this->returnValue(new QueryScaffolder('test','test')));
+
+		$observer->expects($this->once())
+			->method('mutation')
+			->will($this->returnValue(new MutationScaffolder('test','test')));
+
+		$observer->expects($this->once())
+			->method('type')
+			->willReturn(
+				new DataObjectScaffolder(DataObjectFake::class)
+			);
+
+		Injector::inst()->registerService($observer, GraphQLScaffolder::class);
+
+		GraphQLScaffolder::createFromConfig([
+			'types' => [
+				DataObjectFake::class => [
+					'fields' => ['MyField']
+				]
+			],
+			'queries' => [
+				'testQuery' => [
+					'type' => DataObjectFake::class,
+					'resolver' => FakeResolver::class
+				]
+			],
+			'mutations' => [
+				'testMutation' => [
+					'type' => DataObjectFake::class,
+					'resolver' => FakeResolver::class
+				]
+			]
+		]);
+	}
+
+	public function testOperationIdentifiers()
+	{
+		$this->assertEquals(
+			Read::class, 
+			OperationScaffolder::getOperationScaffoldFromIdentifier(GraphQLScaffolder::READ)
+		);
+		$this->assertEquals(
+			Update::class, 
+			OperationScaffolder::getOperationScaffoldFromIdentifier(GraphQLScaffolder::UPDATE)
+		);
+		$this->assertEquals(
+			Delete::class, 
+			OperationScaffolder::getOperationScaffoldFromIdentifier(GraphQLScaffolder::DELETE)
+		);
+		$this->assertEquals(
+			Create::class, 
+			OperationScaffolder::getOperationScaffoldFromIdentifier(GraphQLScaffolder::CREATE)
+		);
+
+	}
+
+	public function testOperationScaffolderArgs()
+	{
+		$scaffolder = new OperationScaffolderFake('testOperation','testType');
+		
+		$this->assertEquals('testOperation', $scaffolder->getName());
+		$scaffolder->addArgs([
+			'One' => 'String',
+			'Two' => 'Boolean'
+		]);
+		$scaffolder->addArgs([
+			'One' => 'String'
+		]);
+
+		$this->assertEquals(['One','Two'], array_keys($scaffolder->getArgs()));
+	}
+
+	public function testOperationScaffolderResolver()
+	{
+		$scaffolder = new OperationScaffolderFake('testOperation','testType');
+
+		try {
+			$scaffolder->setResolver(function() {});
+			$scaffolder->setResolver(FakeResolver::class);
+			$scaffolder->setResolver(new FakeResolver());
+			$success = true;
+		} catch (Exception $e) {
+			$success = false;
+		}
+
+		$this->assertTrue($success);
+
+		$this->setExpectedExceptionRegExp(
+			InvalidArgumentException::class,
+			'/closures, instances of/'
+		);
+		$scaffolder->setResolver('fail');
+	}
+
+	public function testOperationScaffolderAppliesConfig()
+	{
+		$scaffolder = new OperationScaffolderFake('testOperation','testType');
+		
+		try {
+			$scaffolder->applyConfig([
+				'args' => [
+					'One' => 'String',
+					'Two' => 'Boolean'
+				],
+				'resolver' => FakeResolver::class
+			]);
+			$success = true;
+		} catch (Exception $e) {
+			$success = false;
+		}
+
+		$this->assertTrue($success);
+		$this->assertEquals(['One','Two'], array_keys($scaffolder->getArgs()));
+	}
+
+	public function testMutationScaffolder()
+	{
+		$observer = $this->getMockBuilder(Manager::class)
+			->setMethods(['addMutation'])
+			->getMock();
+		$scaffolder = new MutationScaffolder('testMutation', 'test');
+		$scaffolder->addArgs(['Test' => 'String']);
+		$scaffold = $scaffolder->scaffold($manager = new Manager());
+		$manager->addType($o = new ObjectType([
+			'name' => 'test',
+			'fields' => []
+		]));
+		$o->Test = true;
+
+		$this->assertEquals('testMutation', $scaffold['name']);
+		$this->assertArrayHasKey('Test', $scaffold['args']);
+		$this->assertTrue(is_callable($scaffold['resolve']));
+		$this->assertTrue($scaffold['type']()->Test);
+
+		$observer->expects($this->once())
+			->method('addMutation')
+			->with(
+				$this->equalTo($scaffold),
+				$this->equalTo('testMutation')
+			);
+
+		$scaffolder->addToManager($observer);
+	}
+
+	public function testQueryScaffolderUnpaginated()
+	{
+		$observer = $this->getMockBuilder(Manager::class)
+			->setMethods(['addQuery'])
+			->getMock();
+		$scaffolder = new QueryScaffolder('testQuery', 'test');
+		$scaffolder->setUsePagination(false);
+		$scaffolder->addArgs(['Test' => 'String']);
+		$scaffold = $scaffolder->scaffold($manager = new Manager());
+		
+		$manager->addType($o = new ObjectType([
+			'name' => 'test',
+			'fields' => []
+		]));
+		$o->Test = true;
+
+		$this->assertEquals('testQuery', $scaffold['name']);
+		$this->assertArrayHasKey('Test', $scaffold['args']);
+		$this->assertTrue(is_callable($scaffold['resolve']));
+		$this->assertTrue($scaffold['type']()->Test);
+
+		$observer->expects($this->once())
+			->method('addQuery')
+			->with(
+				$this->equalTo($scaffold),
+				$this->equalTo('testQuery')
+			);
+
+		$scaffolder->addToManager($observer);
+	}
+
+	public function testQueryScaffolderPaginated()
+	{
+		$scaffolder = new QueryScaffolder('testQuery', 'test');
+		$scaffolder->setUsePagination(true);
+		$scaffolder->addArgs(['Test' => 'String']);
+		$scaffolder->addSortableFields(['test']);
+		$scaffold = $scaffolder->scaffold($manager = new Manager());
+		$manager->addType($o = new ObjectType([
+			'name' => 'test',
+			'fields' => []
+		]));
+		$o->Test = true;
+		$config = $scaffold['type']()->config;
+
+		$this->assertEquals('testQueryConnection', $config['name']);
+		$this->assertArrayHasKey('pageInfo', $config['fields']);
+		$this->assertArrayHasKey('edges', $config['fields']);
+	}
+
+	public function testQueryScaffolderApplyConfig()
+	{
+		$mock = $this->getMockBuilder(QueryScaffolder::class)
+			->setConstructorArgs(['testQuery', 'testType'])
+			->setMethods(['addSortableFields','setUsePagination'])
+			->getMock();
+		$mock->expects($this->once())
+			->method('addSortableFields')
+			->with(['Test1','Test2']);
+		$mock->expects($this->once())
+			->method('setUsePagination')
+			->with(false);
+
+		$mock->applyConfig([
+			'sortableFields' => ['Test1','Test2'],
+			'paginate' => false
+		]);
+	}
+
+	public function testQueryScaffolderApplyConfigThrowsOnBadSortableFields()
+	{
+		$scaffolder = new QueryScaffolder('testQuery','testType');
+		$this->setExpectedExceptionRegExp(
+			InvalidArgumentException::class,
+			'/sortableFields must be an array/'
+		);
+		$scaffolder->applyConfig([
+			'sortableFields' => 'fail'			
+		]);
+	}
+
+    public function testTypeParser()
+    {
+        $parser = new TypeParser('String!=Test');
+        $this->assertTrue($parser->isRequired());
+        $this->assertEquals('String', $parser->getArgTypeName());
+        $this->assertEquals('Test', $parser->getDefaultValue());
+        $this->assertTrue(is_string($parser->toArray()['defaultValue']));
+
+        $parser = new TypeParser('String! = Test');
+        $this->assertTrue($parser->isRequired());
+        $this->assertEquals('String', $parser->getArgTypeName());
+        $this->assertEquals('Test', $parser->getDefaultValue());
+
+        $parser = new TypeParser('Int!');
+        $this->assertTrue($parser->isRequired());
+        $this->assertEquals('Int', $parser->getArgTypeName());
+        $this->assertNull($parser->getDefaultValue());
+
+        $parser = new TypeParser('Int!=23');
+        $this->assertTrue($parser->isRequired());
+        $this->assertEquals('Int', $parser->getArgTypeName());
+        $this->assertEquals('23', $parser->getDefaultValue());
+		$this->assertTrue(is_int($parser->toArray()['defaultValue']));
+
+        $parser = new TypeParser('Boolean');
+        $this->assertFalse($parser->isRequired());
+        $this->assertEquals('Boolean', $parser->getArgTypeName());
+        $this->assertNull($parser->getDefaultValue());
+
+        $parser = new TypeParser('Boolean=1');
+        $this->assertFalse($parser->isRequired());
+        $this->assertEquals('Boolean', $parser->getArgTypeName());
+        $this->assertEquals('1', $parser->getDefaultValue());
+		$this->assertTrue(is_bool($parser->toArray()['defaultValue']));
+
+        $parser = new TypeParser('String!=Test');
+        $arr = $parser->toArray();
+        $this->assertInstanceOf(NonNull::class, $arr['type']);
+        $this->assertInstanceOf(StringType::class, $arr['type']->getWrappedType());
+        $this->assertEquals('Test', $arr['defaultValue']);
+
+        $this->setExpectedException(InvalidArgumentException::class);
+        $parser = new TypeParser('  ... Nothing');
+
+        $this->setExpectedException(InvalidArgumentException::class);
+        $parser = (new TypeParser('Nothing'))->toArray();
+    }
+
+    public function testArgsParser()
+    {
+        $parsers = [
+            new ArgsParser([
+                'Test' => 'String'
+            ]),
+            new ArgsParser([
+                'Test' => Type::string()
+            ]),
+            new ArgsParser([
+                'Test' => ['type' => Type::string()]
+            ])
+        ];
+
+        foreach ($parsers as $parser) {
+            $arr = $parser->toArray();
+            $this->assertArrayHasKey('Test', $arr);
+            $this->assertArrayHasKey('type', $arr['Test']);
+            $this->assertInstanceOf(StringType::class, $arr['Test']['type']);
+        }
+    }
+
+
+    public function testOperationList()
+    {
+        $list = new OperationList();
+
+        $list->push(new MutationScaffolder('myMutation1', 'test1'));
+        $list->push(new MutationScaffolder('myMutation2', 'test2'));
+
+        $this->assertInstanceOf(
+            MutationScaffolder::class,
+            $list->findByName('myMutation1')
+        );
+        $this->assertFalse($list->findByName('myMutation3'));
+
+        $list->removeByName('myMutation2');
+        $this->assertEquals(1, $list->count());
+
+        $list->removeByName('nothing');
+        $this->assertEquals(1, $list->count());
+
+        $this->setExpectedExceptionRegExp(
+        	InvalidArgumentException::class,
+        	'/only accepts instances of/'
+        );
+        $list->push(new OperationList());
+    }
+
+	protected function getFakeScaffolder()
+	{
+		return new DataObjectScaffolder(DataObjectFake::class);
+	}
 
-  //       $scaffolder->removeQuery('test');
-  //       $scaffolder->removeMutation('test');
-
-  //       $this->assertEquals(1, $scaffolder->getQueries()->count());
-  //       $this->assertEquals(1, $scaffolder->getMutations()->count());
-
-  //   }
-
-
-  //   public function testDataObjectScaffolderThrowsIfNotDataObject()
-  //   {
-  //       $this->setExpectedException(InvalidArgumentException::class);
-  //       $scaffolder = new DataObjectScaffolder(Config::class);
-  //   }
-
-  //   public function testStockOperations()
-  //   {
-  //       // Create
-  //       $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
-  //       $scaffolder->mutation(GraphQLScaffolder::CREATE);
-  //       $this->assertInstanceOf(CreateOperationScaffolder::class, $scaffolder->getMutations()->first());
-
-  //       // Read
-  //       $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
-  //       $scaffolder->query(GraphQLScaffolder::READ);
-  //       $this->assertInstanceOf(ReadOperationScaffolder::class, $scaffolder->getQueries()->first());
-
-  //       // Update
-  //       $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
-  //       $scaffolder->mutation(GraphQLScaffolder::UPDATE);
-  //       $this->assertInstanceOf(UpdateOperationScaffolder::class, $scaffolder->getMutations()->first());
-
-  //       // Delete
-  //       $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
-  //       $scaffolder->mutation(GraphQLScaffolder::DELETE);
-  //       $this->assertInstanceOf(DeleteOperationScaffolder::class, $scaffolder->getMutations()->first());
-
-
-  //   }
-
-  //   public function testDataObjectScaffolderFields()
-  //   {
-  //       $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
-  //       $scaffolder->addFields(['One', 'Two']);
-
-  //       $this->assertEquals(['One', 'Two'], $scaffolder->getFields()->toArray());
-
-  //       $scaffolder->addFields(['One', 'Two', 'Three']);
-
-  //       $this->assertCount(3, $scaffolder->getFields());
-  //       $this->assertEquals(['One', 'Two', 'Three'], $scaffolder->getFields()->toArray());
-
-  //       $scaffolder->removeField('Nothing');
-  //       $this->assertCount(3, $scaffolder->getFields());
-  //       $scaffolder->removeField('One');
-  //       $this->assertCount(2, $scaffolder->getFields());
-
-  //       $scaffolder->removeFields(['Two', 'Three']);
-  //       $this->assertCount(0, $scaffolder->getFields());
-  //   }
-
-  //   public function testDataObjectScaffolderUsesDefaultFields()
-  //   {
-  //   	Config::inst()->update(DataObjectScaffolder::class, 'default_fields', ['ID' => 'ID']);
-  //   	$scaffolder = new DataObjectScaffolder(DataObjectFake::class);
-  //   	$creator = $scaffolder->getCreator(new Manager());
-    	
-  //   	$this->assertEquals(
-  //   		['ID'],
-  //   		array_keys($creator->fields())
-  //   	);
-  //   }
-
-  //   public function testDataObjectTrait()
-  //   {
-  //       Config::inst()->update(DataObjectFake::class, 'table_name', 'Some\Namespaced\Table');
-  //       $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
-  //       $inst = $scaffolder->getDataObjectInstance();
-  //       $this->assertInstanceOf(DataObjectFake::class, $inst);
-
-  //       $this->assertEquals('Some_Namespaced_Table', $scaffolder->typeName());
-
-  //       $scaffolder->setDataObjectClass('test');
-  //       $this->assertEquals('test', $scaffolder->getDataObjectClass());
-  //   }
-
-  //   public function testDataObjectScaffolderCreator()
-  //   {
-  //       $scaffolder = (new DataObjectScaffolder(DataObjectFake::class))
-  //           ->addFields(['MyField', 'NonExistentField', 'Author', 'Files']);
-
-  //       $extraDataObjects = $scaffolder->getExtraDataObjects();
-  //       $this->assertArrayHasKey('Author', $extraDataObjects);
-  //       $this->assertArrayHasKey('Files', $extraDataObjects);
-
-  //       $this->assertEquals($extraDataObjects['Author'], 'SilverStripe\Security\Member');
-  //       $this->assertEquals($extraDataObjects['Files'], 'SilverStripe\Assets\File');
-
-  //       $creator = $scaffolder->getCreator(new Manager());
-
-  //       $this->assertEquals($scaffolder->typeName(), $creator->attributes()['name']);
-  //       $fields = array_keys($creator->fields());
-  //       $this->assertEquals(['MyField', 'NonExistentField', 'Author', 'Files'], $fields);
-  //   }
-
-
-  //   public function testDataObjectScaffolderAddToManager()
-  //   {
-  //       $scaffolder = new DataObjectScaffolder(DataObjectFake::class);
-  //       $scaffolder->addFields(['MyField', 'NonExistentField', 'Author', 'Files']);
-  //       $scaffolder->mutation('myMutation', new FakeResolver());
-  //       $scaffolder->query('myQuery', new FakeResolver());
-
-  //       $managerMock = $this->getMockBuilder(Manager::class)
-  //           ->setMethods(['getType', 'addType', 'addQuery', 'addMutation'])
-  //           ->getMock();
-  //       $managerMock->expects($this->once())
-  //           ->method('addType')
-  //           ->with($scaffolder->typeName());
-  //       $managerMock->expects($this->once())
-  //           ->method('addMutation')
-  //           ->with(
-  //               $this->callback(function ($subject) {                	
-  //                   return (
-  //                       is_array($subject) && $subject['name'] == 'myMutation'
-  //                   );
-  //               }),
-  //               $this->equalTo('myMutation')
-  //           );
-
-  //       $managerMock->expects($this->once())
-  //           ->method('addQuery')
-  //           ->with(
-  //               $this->callback(function ($subject) {                
-  //                   return (
-  //                       is_array($subject) && $subject['name'] == 'myQuery'
-  //                   );
-  //               }),
-  //               $this->equalTo('myQuery')
-  //           );
-
-  //       $scaffolder->addToManager($managerMock);
-  //   }
-
-  //   public function testGraphQLScaffolderAddToManager()
-  //   {
-  //       $resolver = new FakeResolver();
-  //       $scaffolder = new GraphQLScaffolder();
-  //       $scaffolder->dataObject(DataObjectFake::class)
-  //           ->addFields(['MyField', 'MyInt', 'Author', 'Files'])
-  //           ->mutation('testMutation', $resolver)
-  //           ->addArgs(['Test' => 'String']);
-  //       $scaffolder->dataObject(DataObjectFake::class)
-  //           ->query('testQuery', $resolver)
-  //           ->addArgs(['Test' => 'String']);
-  //       $scaffolder->dataObject(DataObjectFake::class)
-  //           ->query('testQueryUnpaginated', $resolver)
-  //           ->addArgs(['Test' => 'String'])
-  //           ->setUsePagination(false);
-  //       $scaffolder->dataObject(Member::class)
-  //           ->addFields(['Surname']);
-  //       $scaffolder->dataObject(File::class)
-  //           ->addFields(['Filename']);
-  //       $managerMock = $this->getMockBuilder(Manager::class)
-  //           ->setMethods(['addType', 'addQuery', 'addMutation'])
-  //           ->getMock();
-
-  //       $doTypeName = $scaffolder->dataObject(DataObjectFake::class)->typeName();
-  //       $memberTypeName = $scaffolder->dataObject(Member::class)->typeName();
-  //       $fileTypeName = $scaffolder->dataObject(File::class)->typeName();
-
-  //       $createFieldCheckCallback = function ($fields, $typeName) {
-  //           return function ($subject) use ($fields, $typeName) {
-  //               if ($subject instanceof ObjectType) {
-  //                   $fieldFunc = $subject->config['fields'];
-  //                   $typeFields = $fieldFunc();
-  //                   return (
-  //                       ($subject->config['name'] == $typeName) &&
-  //                       (array_keys($typeFields) == $fields)
-  //                   );
-  //               }
-
-  //               return false;
-  //           };
-  //       };
-
-  //       $managerMock->expects($this->exactly(3))
-  //           ->method('addType')
-  //           ->withConsecutive(
-  //               [
-  //                   $this->callback($createFieldCheckCallback(
-  //                       ['MyField', 'MyInt', 'Author', 'Files'],
-  //                       $doTypeName
-  //                   )),
-  //                   $doTypeName
-  //               ],
-  //               [
-  //                   $this->callback($createFieldCheckCallback(['Surname'], $memberTypeName)),
-  //                   $memberTypeName
-  //               ],
-  //               [
-  //                   $this->callback($createFieldCheckCallback(['Filename'], $fileTypeName)),
-  //                   $fileTypeName
-  //               ]
-
-  //           );
-
-  //       $managerMock->expects($this->exactly(2))
-  //           ->method('addQuery')
-  //           ->withConsecutive(
-  //           	[
-  //           		$this->callback(function ($subject) {
-  //           			$connectionKeys = array_keys(Connection::create('dummy')->args());
-  //               		return (
-  //               			is_array($subject) &&
-  //               			$subject['name'] == 'testQuery' &&
-  //               			array_keys($subject['args']) == array_merge(['Test'], $connectionKeys)
-  //               		);
-  //           		})
-  //           	],
-  //           	[
-  //           		$this->callback(function ($subject) {
-  //               		return (
-  //               			is_array($subject) &&
-  //               			$subject['name'] == 'testQueryUnpaginated' &&
-  //               			array_keys($subject['args']) == ['Test']
-  //               		);
-  //           		})            	
-  //           	]
-  //           );
-
-  //       $managerMock->expects($this->once())
-  //           ->method('addMutation')
-  //           ->with($this->callback(function ($subject) {
-  //               return is_array($subject) &&
-  //               $subject['name'] == 'testMutation' &&
-  //               array_keys($subject['args']) == ['Test'];
-  //           }));
-
-  //       $scaffolder->addToManager($managerMock);
-  //   }
-
-  //   public function testGraphQLScaffolderCreateFromConfig()
-  //   {
-  //       $scaffolder = GraphQLScaffolder::createFromConfig([
-  //           DataObjectFake::class => [
-  //               'fields' => [
-  //                   'MyField',
-  //                   'MyInt',
-  //                   'Author',
-  //                   'Files'
-  //               ],
-  //               'operations' => ['CREATE', 'READ', 'UPDATE', 'DELETE']
-  //           ],
-
-  //           Member::class => [
-  //               'fields' => ['Surname'],
-  //               'operations' => 'all',
-  //               'queries' => [
-  //                   'myQuery' => [
-  //                       'args' => [
-  //                           'Test' => 'String'
-  //                       ],
-  //                       'resolver' => FakeResolver::class
-  //                   ],
-  //                   'myQueryUnpaginated' => [
-  //                   	'args' => [
-  //                   		'Test' => 'String'
-  //                   	],
-  //                   	'resolver' => FakeResolver::class
-  //                   ]
-  //               ]
-  //           ],
-
-  //           File::class => [
-  //               'fields' => ['Surname'],
-  //               'mutations' => [
-  //                   'myMutation' => [
-  //                       'args' => [
-  //                           'Test' => 'String'
-  //                       ],
-  //                       'resolver' => FakeResolver::class
-  //                   ]
-  //               ]
-  //           ]
-  //       ]);
-
-  //       $reflection = new ReflectionClass($scaffolder);
-  //       $property = $reflection->getProperty('scaffolds');
-  //       $property->setAccessible(true);
-  //       $scaffolds = $property->getValue($scaffolder);
-
-  //       $dataObjectClasses = [
-  //           DataObjectFake::class => true,
-  //           Member::class => true,
-  //           File::class => true
-  //       ];
-
-  //       foreach ($scaffolds as $scaffold) {
-  //           $name = $scaffold->getDataObjectClass();
-  //           $typeName = ucfirst($scaffold->typeName());
-  //           $pluralTypeName = $scaffold->getDataObjectInstance()->plural_name();
-  //           $pluralTypeName = str_replace(' ', '', $pluralTypeName);
-  //           $pluralTypeName = ucfirst($pluralTypeName);
-
-  //           $this->assertArrayHasKey($name, $dataObjectClasses);
-  //           unset($dataObjectClasses[$name]);
-            
-  //           if (in_array($name, [DataObjectFake::class, Member::class])) {
-  //               $this->assertInstanceOf(
-  //                   CreateOperationScaffolder::class,
-  //                   $scaffold->getMutations()->findByName('create' . $typeName)
-  //               );
-  //               $this->assertInstanceOf(
-  //                   UpdateOperationScaffolder::class,
-  //                   $scaffold->getMutations()->findByName('update' . $typeName)
-  //               );
-  //               $this->assertInstanceOf(
-  //                   DeleteOperationScaffolder::class,
-  //                   $scaffold->getMutations()->findByName('delete' . $typeName)
-  //               );
-  //               $this->assertInstanceOf(
-  //                   ReadOperationScaffolder::class,
-  //                   $scaffold->getQueries()->findByName('read' . $pluralTypeName)
-  //               );
-  //               if ($name == Member::class) {
-  //                   $op = $scaffold->getQueries()->findByName('myQuery');
-  //                   $this->assertInstanceOf(
-  //                       QueryScaffolder::class,
-  //                       $op
-  //                   );
-  //                   $args = $op->getCreator(new Manager())->args();
-  //                   foreach(Connection::create('dummy')->args() as $a => $config) {
-  //                   	$this->assertArrayHasKey($a, $args);
-  //                   }
-  //                   $this->assertArrayHasKey('Test', $args);
-
-  //                   $op = $scaffold->getQueries()->findByName('myQueryUnpaginated');
-  //                   $this->assertInstanceOf(
-  //                       QueryScaffolder::class,
-  //                       $op
-  //                   );
-  //                   $this->assertArrayHasKey('Test', $op->getCreator(new Manager())->args());
-
-  //               }
-
-  //           } else {
-  //               if ($name == File::class) {
-  //                   $op = $scaffold->getMutations()->findByName('myMutation');
-  //                   $this->assertInstanceOf(
-  //                       MutationScaffolder::class,
-  //                       $op
-  //                   );
-  //                   $this->assertArrayHasKey('Test', $op->getCreator(new Manager())->args());
-  //               }
-  //           }
-  //       }
-  //   }
-
-  //   public function testInputTypesAreCreated()
-  //   {
-  //       $create = (new CreateOperationScaffolder(DataObjectFake::class))
-  //           ->addArgs(['Test' => 'String']);
-  //       $creator = $create->getCreator(new Manager());
-
-  //       $this->assertArrayHasKey('Input', $creator->args());
-  //       $type = $creator->args()['Input']['type'];
-  //       $this->assertInstanceOf(NonNull::class, $type);
-  //       $this->assertInstanceOf(InputObjectType::class, $type->getWrappedType());
-
-  //       $create = (new UpdateOperationScaffolder(DataObjectFake::class))
-  //           ->addArgs(['Test' => 'String']);
-  //       $creator = $create->getCreator(new Manager());
-
-  //       $this->assertArrayHasKey('Input', $creator->args());
-  //       $this->assertArrayHasKey('ID', $creator->args());
-  //       $type = $creator->args()['Input']['type'];
-  //       $this->assertInstanceOf(NonNull::class, $type);
-  //       $this->assertInstanceOf(InputObjectType::class, $type->getWrappedType());
-  //   }
-
-  //   public function testTypeParser()
-  //   {
-  //       $parser = new TypeParser('String!=Test');
-  //       $this->assertTrue($parser->isRequired());
-  //       $this->assertEquals('String', $parser->getArgTypeName());
-  //       $this->assertEquals('Test', $parser->getDefaultValue());
-  //       $this->assertTrue(is_string($parser->toArray()['defaultValue']));
-
-  //       $parser = new TypeParser('String! = Test');
-  //       $this->assertTrue($parser->isRequired());
-  //       $this->assertEquals('String', $parser->getArgTypeName());
-  //       $this->assertEquals('Test', $parser->getDefaultValue());
-
-  //       $parser = new TypeParser('Int!');
-  //       $this->assertTrue($parser->isRequired());
-  //       $this->assertEquals('Int', $parser->getArgTypeName());
-  //       $this->assertNull($parser->getDefaultValue());
-
-  //       $parser = new TypeParser('Int!=23');
-  //       $this->assertTrue($parser->isRequired());
-  //       $this->assertEquals('Int', $parser->getArgTypeName());
-  //       $this->assertEquals('23', $parser->getDefaultValue());
-		// $this->assertTrue(is_int($parser->toArray()['defaultValue']));
-
-  //       $parser = new TypeParser('Boolean');
-  //       $this->assertFalse($parser->isRequired());
-  //       $this->assertEquals('Boolean', $parser->getArgTypeName());
-  //       $this->assertNull($parser->getDefaultValue());
-
-  //       $parser = new TypeParser('Boolean=1');
-  //       $this->assertFalse($parser->isRequired());
-  //       $this->assertEquals('Boolean', $parser->getArgTypeName());
-  //       $this->assertEquals('1', $parser->getDefaultValue());
-		// $this->assertTrue(is_bool($parser->toArray()['defaultValue']));
-
-  //       $parser = new TypeParser('String!=Test');
-  //       $arr = $parser->toArray();
-  //       $this->assertInstanceOf(NonNull::class, $arr['type']);
-  //       $this->assertInstanceOf(StringType::class, $arr['type']->getWrappedType());
-  //       $this->assertEquals('Test', $arr['defaultValue']);
-
-  //       $this->setExpectedException(InvalidArgumentException::class);
-  //       $parser = new TypeParser('  ... Nothing');
-
-  //       $this->setExpectedException(InvalidArgumentException::class);
-  //       $parser = (new TypeParser('Nothing'))->toArray();
-  //   }
-
-  //   public function testArgsParser()
-  //   {
-  //       $parsers = [
-  //           new ArgsParser([
-  //               'Test' => 'String'
-  //           ]),
-  //           new ArgsParser([
-  //               'Test' => Type::string()
-  //           ]),
-  //           new ArgsParser([
-  //               'Test' => ['type' => Type::string()]
-  //           ])
-  //       ];
-
-  //       foreach ($parsers as $parser) {
-  //           $arr = $parser->toArray();
-  //           $this->assertArrayHasKey('Test', $arr);
-  //           $this->assertArrayHasKey('type', $arr['Test']);
-  //           $this->assertInstanceOf(StringType::class, $arr['Test']['type']);
-  //       }
-  //   }
-
-
-  //   public function testOperationList()
-  //   {
-  //       $list = new OperationList();
-
-  //       $list->push(new MutationScaffolder('myMutation1', 'test1'));
-  //       $list->push(new MutationScaffolder('myMutation2', 'test2'));
-
-  //       $this->assertInstanceOf(
-  //           MutationScaffolder::class,
-  //           $list->findByName('myMutation1')
-  //       );
-  //       $this->assertFalse($list->findByName('myMutation3'));
-
-  //       $list->removeByName('myMutation2');
-  //       $this->assertEquals(1, $list->count());
-
-  //       $list->removeByName('nothing');
-  //       $this->assertEquals(1, $list->count());
-
-  //       $this->setExpectedException(InvalidArgumentException::class);
-  //       $list->push(new OperationList());
-  //   }
-
-  //   protected function createOperationCreator($resolver = null)
-  //   {
-  //       return new MutationOperationCreator(
-  //           new Manager(),
-  //           'testOperation',
-  //           'testType',
-  //           $resolver,
-  //           ['foo' => 'bar']
-  //       );
-  //   }
 
 }

From 554d5e8e3ecee32f47421d06c1865ce8f59cfe88 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 12 Jan 2017 12:34:26 +1300
Subject: [PATCH 33/66] format PSR2

---
 .../Interfaces/ManagerMutatorInterface.php    |  2 +-
 .../Interfaces/ResolverInterface.php          |  3 +-
 .../Interfaces/ScaffolderInterface.php        |  2 +-
 .../Interfaces/ScaffoldingProvider.php        |  2 +-
 .../Scaffolders/DataObjectScaffolder.php      | 88 +++++++++----------
 .../Scaffolders/GraphQLScaffolder.php         |  6 +-
 .../Scaffolders/OperationScaffolder.php       |  2 +-
 .../Scaffolders/PaginationScaffolder.php      | 20 ++---
 src/Scaffolding/Traits/Chainable.php          | 22 ++---
 .../Traits/DataObjectTypeTrait.php            |  3 +-
 src/Scaffolding/Util/ArgsParser.php           |  2 +-
 src/Scaffolding/Util/OperationList.php        | 35 ++++----
 src/Scaffolding/Util/ScaffoldingUtil.php      |  5 +-
 src/Scaffolding/Util/TypeParser.php           |  2 +-
 14 files changed, 96 insertions(+), 98 deletions(-)

diff --git a/src/Scaffolding/Interfaces/ManagerMutatorInterface.php b/src/Scaffolding/Interfaces/ManagerMutatorInterface.php
index 42a3ce9fb..f837c90d7 100644
--- a/src/Scaffolding/Interfaces/ManagerMutatorInterface.php
+++ b/src/Scaffolding/Interfaces/ManagerMutatorInterface.php
@@ -14,4 +14,4 @@ interface ManagerMutatorInterface
      * @return mixed
      */
     public function addToManager(Manager $manager);
-}
\ No newline at end of file
+}
diff --git a/src/Scaffolding/Interfaces/ResolverInterface.php b/src/Scaffolding/Interfaces/ResolverInterface.php
index 00cbb7a29..ac7ecdd65 100644
--- a/src/Scaffolding/Interfaces/ResolverInterface.php
+++ b/src/Scaffolding/Interfaces/ResolverInterface.php
@@ -15,5 +15,4 @@ interface ResolverInterface
      * @return mixed
      */
     public function resolve($object, $args, $context, $info);
-
-}
\ No newline at end of file
+}
diff --git a/src/Scaffolding/Interfaces/ScaffolderInterface.php b/src/Scaffolding/Interfaces/ScaffolderInterface.php
index a6bfaa060..3141f19ec 100644
--- a/src/Scaffolding/Interfaces/ScaffolderInterface.php
+++ b/src/Scaffolding/Interfaces/ScaffolderInterface.php
@@ -14,4 +14,4 @@ interface ScaffolderInterface
      * @return mixed
      */
     public function scaffold(Manager $manager);
-}
\ No newline at end of file
+}
diff --git a/src/Scaffolding/Interfaces/ScaffoldingProvider.php b/src/Scaffolding/Interfaces/ScaffoldingProvider.php
index 085cabeed..561b9924a 100644
--- a/src/Scaffolding/Interfaces/ScaffoldingProvider.php
+++ b/src/Scaffolding/Interfaces/ScaffoldingProvider.php
@@ -13,4 +13,4 @@ interface ScaffoldingProvider
      * @return mixed
      */
     public function provideGraphQLScaffolding(GraphQLScaffolder $scaffolder);
-}
\ No newline at end of file
+}
diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
index 54ece115e..a195035ba 100644
--- a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -124,8 +124,8 @@ public function addAllFields($includeHasOne = false)
      */
     public function addAllFieldsExcept($exclusions, $includeHasOne = false)
     {
-        if(!is_array($exclusions)) {
-        	$exclusions = [$exclusions];
+        if (!is_array($exclusions)) {
+            $exclusions = [$exclusions];
         }
         $fields = $this->allFieldsFromDataObject($includeHasOne);
         $filteredFields = array_diff($fields, $exclusions);
@@ -180,7 +180,7 @@ public function getOperations()
      */
     public function getNestedQueries()
     {
-    	return $this->nestedQueries;
+        return $this->nestedQueries;
     }
 
     /**
@@ -191,7 +191,7 @@ public function getNestedQueries()
      * @return $this
      */
     public function removeOperation($identifier)
-    {        
+    {
         $this->operations->removeByIdentifier($identifier);
 
         return $this;
@@ -205,7 +205,7 @@ public function removeOperation($identifier)
      * @return OperationScaffolder
      */
     public function operation($operation)
-    {	
+    {
         $scaffoldClass = OperationScaffolder::getOperationScaffoldFromIdentifier($operation);
 
         if (!$scaffoldClass) {
@@ -219,7 +219,7 @@ public function operation($operation)
         $scaffolder = new $scaffoldClass($this->dataObjectClass);
         $existing = $this->operations->findByIdentifier($operation);
 
-        if ($existing) {        
+        if ($existing) {
             return $existing;
         }
 
@@ -295,8 +295,8 @@ public function getAncestralClasses()
         $ancestry = array_reverse(ClassInfo::ancestry($this->dataObjectClass));
 
         foreach ($ancestry as $class) {
-            if($class === $this->dataObjectClass) {
-            	continue;
+            if ($class === $this->dataObjectClass) {
+                continue;
             }
             if ($class == DataObject::class) {
                 break;
@@ -315,17 +315,17 @@ public function applyConfig(array $config)
                 "No array of fields defined for $dataObjectClass"
             );
         }
-        if(isset($config['fields'])) {
-	        if($config['fields'] === '*')  {        	
-	        	$this->addAllFields();
-	        } else if(is_array($config['fields'])) {
-	        	$this->addFields($config['fields']);	
-	        } else {
-	    		throw new \Exception(
-	    			"Fields must be an array, or '*' for all fields in $dataObjectClass"
-	    		);        	
-	        }
-    	}		
+        if (isset($config['fields'])) {
+            if ($config['fields'] === '*') {
+                $this->addAllFields();
+            } elseif (is_array($config['fields'])) {
+                $this->addFields($config['fields']);
+            } else {
+                throw new \Exception(
+                    "Fields must be an array, or '*' for all fields in $dataObjectClass"
+                );
+            }
+        }
 
         if (isset($config['fieldsExcept'])) {
             if (!is_array($config['fieldsExcept'])) {
@@ -338,31 +338,31 @@ public function applyConfig(array $config)
             $this->addAllFieldsExcept($config['fieldsExcept']);
         }
 
-        if (isset($config['operations'])) {            
-	        if ($config['operations'] === '*') {
-	            $config['operations'] = [
-	                GraphQLScaffolder::CREATE => true,
-	                GraphQLScaffolder::READ => true,
-	                GraphQLScaffolder::UPDATE => true,
-	                GraphQLScaffolder::DELETE => true,
-	            ];
-	        }
-
-	        if (!ArrayLib::is_associative($config['operations'])) {
-	            throw new \Exception(
-	                'Operations field must be a map of operation names to a map of settings, or true/false'
-	            );
-	        }
-
-	        foreach ($config['operations'] as $opID => $opSettings) {
-	            if ($opSettings === false) {
-	                continue;
-	            }
-
-	            $this->operation($opID)
-	                ->applyConfig((array) $opSettings);
-	        }
-    	}
+        if (isset($config['operations'])) {
+            if ($config['operations'] === '*') {
+                $config['operations'] = [
+                    GraphQLScaffolder::CREATE => true,
+                    GraphQLScaffolder::READ => true,
+                    GraphQLScaffolder::UPDATE => true,
+                    GraphQLScaffolder::DELETE => true,
+                ];
+            }
+
+            if (!ArrayLib::is_associative($config['operations'])) {
+                throw new \Exception(
+                    'Operations field must be a map of operation names to a map of settings, or true/false'
+                );
+            }
+
+            foreach ($config['operations'] as $opID => $opSettings) {
+                if ($opSettings === false) {
+                    continue;
+                }
+
+                $this->operation($opID)
+                    ->applyConfig((array) $opSettings);
+            }
+        }
 
         if (isset($config['nestedQueries'])) {
             if (!ArrayLib::is_associative($config['nestedQueries'])) {
diff --git a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
index 203008c36..d26151bf1 100644
--- a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
+++ b/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
@@ -216,7 +216,7 @@ public function removeQuery($name)
      */
     public function getTypes()
     {
-    	return $this->types;
+        return $this->types;
     }
 
     /**
@@ -224,7 +224,7 @@ public function getTypes()
      */
     public function getQueries()
     {
-    	return $this->queries;
+        return $this->queries;
     }
 
     /**
@@ -232,7 +232,7 @@ public function getQueries()
      */
     public function getMutations()
     {
-    	return $this->mutations;
+        return $this->mutations;
     }
 
     /**
diff --git a/src/Scaffolding/Scaffolders/OperationScaffolder.php b/src/Scaffolding/Scaffolders/OperationScaffolder.php
index 04293a983..4ba1bcb6c 100644
--- a/src/Scaffolding/Scaffolders/OperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/OperationScaffolder.php
@@ -108,7 +108,7 @@ public function getName()
      */
     public function getArgs()
     {
-    	return $this->args;
+        return $this->args;
     }
 
     /**
diff --git a/src/Scaffolding/Scaffolders/PaginationScaffolder.php b/src/Scaffolding/Scaffolders/PaginationScaffolder.php
index 37c75f0a8..bf08c65f6 100644
--- a/src/Scaffolding/Scaffolders/PaginationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/PaginationScaffolder.php
@@ -9,14 +9,14 @@
 class PaginationScaffolder extends PaginatedQueryCreator
 {
 
-	public function __construct(Manager $manager, Connection $connection)
-	{
-		$this->manager = $manager;
-		$this->connection = $connection;
-	}
+    public function __construct(Manager $manager, Connection $connection)
+    {
+        $this->manager = $manager;
+        $this->connection = $connection;
+    }
 
-	public function connection()
-	{
-		return $this->connection;
-	}
-}
\ No newline at end of file
+    public function connection()
+    {
+        return $this->connection;
+    }
+}
diff --git a/src/Scaffolding/Traits/Chainable.php b/src/Scaffolding/Traits/Chainable.php
index 2370b5a27..fb5ec1660 100644
--- a/src/Scaffolding/Traits/Chainable.php
+++ b/src/Scaffolding/Traits/Chainable.php
@@ -4,17 +4,17 @@
 
 trait Chainable
 {
-	protected $chainableParent;
+    protected $chainableParent;
 
-	public function setChainableParent($parent)
-	{
-		$this->chainableParent = $parent;
+    public function setChainableParent($parent)
+    {
+        $this->chainableParent = $parent;
 
-		return $this;
-	}
+        return $this;
+    }
 
-	public function end()
-	{
-		return $this->chainableParent;
-	}
-}
\ No newline at end of file
+    public function end()
+    {
+        return $this->chainableParent;
+    }
+}
diff --git a/src/Scaffolding/Traits/DataObjectTypeTrait.php b/src/Scaffolding/Traits/DataObjectTypeTrait.php
index 0350d7bb6..bbf3c382a 100644
--- a/src/Scaffolding/Traits/DataObjectTypeTrait.php
+++ b/src/Scaffolding/Traits/DataObjectTypeTrait.php
@@ -65,5 +65,4 @@ public function setDataObjectClass($class)
 
         return $this;
     }
-
-}
\ No newline at end of file
+}
diff --git a/src/Scaffolding/Util/ArgsParser.php b/src/Scaffolding/Util/ArgsParser.php
index afca6765e..eaff8b8d4 100644
--- a/src/Scaffolding/Util/ArgsParser.php
+++ b/src/Scaffolding/Util/ArgsParser.php
@@ -52,4 +52,4 @@ public function toArray()
 
         return $args;
     }
-}
\ No newline at end of file
+}
diff --git a/src/Scaffolding/Util/OperationList.php b/src/Scaffolding/Util/OperationList.php
index 22335c59c..6d0713ef2 100644
--- a/src/Scaffolding/Util/OperationList.php
+++ b/src/Scaffolding/Util/OperationList.php
@@ -52,9 +52,9 @@ public function push($item)
      */
     public function findByName($name)
     {
-    	return $this->findItemByCallback(function ($item) use ($name) {
-    		return $name === $item->getName();
-    	});
+        return $this->findItemByCallback(function ($item) use ($name) {
+            return $name === $item->getName();
+        });
     }
 
     /**
@@ -63,9 +63,9 @@ public function findByName($name)
      */
     public function findByIdentifier($id)
     {
-    	return $this->findItemByCallback(function ($item) use ($id) {
-    		return $id === $item->getIdentifier();
-    	});
+        return $this->findItemByCallback(function ($item) use ($id) {
+            return $id === $item->getIdentifier();
+        });
     }
 
     /**
@@ -74,7 +74,7 @@ public function findByIdentifier($id)
     public function removeByName($name)
     {
         $this->removeItemByCallback(function ($operation) use ($name) {
-        	return $operation->getName() === $name;
+            return $operation->getName() === $name;
         });
     }
 
@@ -84,7 +84,7 @@ public function removeByName($name)
     public function removeByIdentifier($id)
     {
         $this->removeItemByCallback(function ($operation) use ($id) {
-        	return $operation->getIdentifier() === $id;
+            return $operation->getIdentifier() === $id;
         });
     }
 
@@ -94,7 +94,7 @@ public function removeByIdentifier($id)
     public function removeItemByCallback($callback)
     {
         $renumberKeys = false;
-        foreach ($this->items as $key => $value) {        	
+        foreach ($this->items as $key => $value) {
             if ($callback($value)) {
                 $renumberKeys = true;
                 unset($this->items[$key]);
@@ -109,14 +109,15 @@ public function removeItemByCallback($callback)
     /**
      * @param \Closure
      */
-    public function findItemByCallback($callback) {
-    	foreach ($this->items as $key => $value) {
-    		if($callback($value)) {
-    			return $value;
-    		}
-    	}
+    public function findItemByCallback($callback)
+    {
+        foreach ($this->items as $key => $value) {
+            if ($callback($value)) {
+                return $value;
+            }
+        }
 
-    	return false;
+        return false;
 
     }
-}
\ No newline at end of file
+}
diff --git a/src/Scaffolding/Util/ScaffoldingUtil.php b/src/Scaffolding/Util/ScaffoldingUtil.php
index 3e8f2f915..bc5d653c6 100644
--- a/src/Scaffolding/Util/ScaffoldingUtil.php
+++ b/src/Scaffolding/Util/ScaffoldingUtil.php
@@ -12,7 +12,7 @@ class ScaffoldingUtil
     /**
      * Given a DataObject subclass name, transform it into a sanitised (and implicitly unique) type
      * name suitable for the GraphQL schema
-     * 
+     *
      * @param $class
      * @return mixed
      */
@@ -29,5 +29,4 @@ public static function isValidFieldName(DataObjectInterface $instance, $fieldNam
     {
         return ($instance->hasMethod($fieldName) || $instance->hasField($fieldName));
     }
-
-}
\ No newline at end of file
+}
diff --git a/src/Scaffolding/Util/TypeParser.php b/src/Scaffolding/Util/TypeParser.php
index 7f599fcb7..526282b6d 100644
--- a/src/Scaffolding/Util/TypeParser.php
+++ b/src/Scaffolding/Util/TypeParser.php
@@ -120,4 +120,4 @@ public function toArray()
             'defaultValue' => $defaultValue
         ];
     }
-}
\ No newline at end of file
+}

From d69a48218f71bfb9afd310213210b9fd47b264dc Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 12 Jan 2017 12:41:29 +1300
Subject: [PATCH 34/66] rename graphqlscaffolder to schemascaffolder

---
 src/Manager.php                               |  8 +-
 .../Interfaces/ScaffoldingProvider.php        |  4 +-
 src/Scaffolding/Scaffolders/CRUD/Create.php   |  4 +-
 src/Scaffolding/Scaffolders/CRUD/Delete.php   |  4 +-
 src/Scaffolding/Scaffolders/CRUD/Read.php     |  4 +-
 src/Scaffolding/Scaffolders/CRUD/Update.php   |  4 +-
 .../Scaffolders/DataObjectScaffolder.php      |  8 +-
 .../Scaffolders/OperationScaffolder.php       |  8 +-
 ...hQLScaffolder.php => SchemaScaffolder.php} |  2 +-
 tests/ScaffoldingTest.php                     | 74 +++++++++----------
 10 files changed, 60 insertions(+), 60 deletions(-)
 rename src/Scaffolding/Scaffolders/{GraphQLScaffolder.php => SchemaScaffolder.php} (99%)

diff --git a/src/Manager.php b/src/Manager.php
index 8b6beb244..831f6d749 100644
--- a/src/Manager.php
+++ b/src/Manager.php
@@ -12,7 +12,7 @@
 use GraphQL\Type\Definition\Type;
 use SilverStripe\Security\Member;
 use SilverStripe\GraphQL\Scaffolding\Interfaces\ScaffoldingProvider;
-use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
 
 class Manager
 {
@@ -53,10 +53,10 @@ public static function createFromConfig($config)
         /** @var Manager $manager */
         $manager = Injector::inst()->create(self::class);
 
-        if (isset($config['scaffolding'])) {
-            $scaffolder = GraphQLScaffolder::createFromConfig($config['scaffolding']);
+        if(isset($config['scaffolding'])) {
+        	$scaffolder = SchemaScaffolder::createFromConfig($config['scaffolding']);
         } else {
-            $scaffolder = new GraphQLScaffolder();
+        	$scaffolder = new SchemaScaffolder();
         }
 
         if (isset($config['scaffolding_providers'])) {
diff --git a/src/Scaffolding/Interfaces/ScaffoldingProvider.php b/src/Scaffolding/Interfaces/ScaffoldingProvider.php
index 561b9924a..80d141b72 100644
--- a/src/Scaffolding/Interfaces/ScaffoldingProvider.php
+++ b/src/Scaffolding/Interfaces/ScaffoldingProvider.php
@@ -2,7 +2,7 @@
 
 namespace SilverStripe\GraphQL\Scaffolding\Interfaces;
 
-use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
 
 /**
  * Use on classes that update the GraphQL scaffolder
@@ -12,5 +12,5 @@ interface ScaffoldingProvider
     /**
      * @return mixed
      */
-    public function provideGraphQLScaffolding(GraphQLScaffolder $scaffolder);
+    public function provideGraphQLScaffolding(SchemaScaffolder $scaffolder);
 }
diff --git a/src/Scaffolding/Scaffolders/CRUD/Create.php b/src/Scaffolding/Scaffolders/CRUD/Create.php
index bdeeb3dce..8e8b8203f 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Create.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Create.php
@@ -10,7 +10,7 @@
 use SilverStripe\Core\Config\Config;
 use SilverStripe\GraphQL\Scaffolding\Util\TypeParser;
 use SilverStripe\GraphQL\Scaffolding\Interfaces\CRUDInterface;
-use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
 use Exception;
 
 /**
@@ -55,7 +55,7 @@ public function __construct($dataObjectClass)
      */
     public function getIdentifier()
     {
-        return GraphQLScaffolder::CREATE;
+        return SchemaScaffolder::CREATE;
     }
 
     /**
diff --git a/src/Scaffolding/Scaffolders/CRUD/Delete.php b/src/Scaffolding/Scaffolders/CRUD/Delete.php
index e8268ecfe..47fc0c714 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Delete.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Delete.php
@@ -7,7 +7,7 @@
 use SilverStripe\ORM\DataList;
 use GraphQL\Type\Definition\Type;
 use SilverStripe\GraphQL\Scaffolding\Interfaces\CRUDInterface;
-use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
 use Exception;
 
 /**
@@ -54,7 +54,7 @@ public function __construct($dataObjectClass)
      */
     public function getIdentifier()
     {
-        return GraphQLScaffolder::DELETE;
+        return SchemaScaffolder::DELETE;
     }
 
     /**
diff --git a/src/Scaffolding/Scaffolders/CRUD/Read.php b/src/Scaffolding/Scaffolders/CRUD/Read.php
index 23e494ec4..8b4f5ac42 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Read.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Read.php
@@ -6,7 +6,7 @@
 use SilverStripe\GraphQL\Scaffolding\Traits\DataObjectTypeTrait;
 use SilverStripe\ORM\DataList;
 use SilverStripe\GraphQL\Scaffolding\Interfaces\CRUDInterface;
-use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
 
 /**
  * Scaffolds a generic read operation for DataObjects.
@@ -43,6 +43,6 @@ public function __construct($dataObjectClass)
      */
     public function getIdentifier()
     {
-        return GraphQLScaffolder::READ;
+        return SchemaScaffolder::READ;
     }
 }
diff --git a/src/Scaffolding/Scaffolders/CRUD/Update.php b/src/Scaffolding/Scaffolders/CRUD/Update.php
index e4770072d..8b51fde86 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Update.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Update.php
@@ -11,7 +11,7 @@
 use SilverStripe\GraphQL\Manager;
 use GraphQL\Type\Definition\Type;
 use SilverStripe\GraphQL\Scaffolding\Interfaces\CRUDInterface;
-use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
 use Exception;
 
 /**
@@ -66,7 +66,7 @@ public function __construct($dataObjectClass)
      */
     public function getIdentifier()
     {
-        return GraphQLScaffolder::UPDATE;
+        return SchemaScaffolder::UPDATE;
     }
 
     /**
diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
index a195035ba..007c91ea8 100644
--- a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -341,10 +341,10 @@ public function applyConfig(array $config)
         if (isset($config['operations'])) {
             if ($config['operations'] === '*') {
                 $config['operations'] = [
-                    GraphQLScaffolder::CREATE => true,
-                    GraphQLScaffolder::READ => true,
-                    GraphQLScaffolder::UPDATE => true,
-                    GraphQLScaffolder::DELETE => true,
+                    SchemaScaffolder::CREATE => true,
+                    SchemaScaffolder::READ => true,
+                    SchemaScaffolder::UPDATE => true,
+                    SchemaScaffolder::DELETE => true,
                 ];
             }
 
diff --git a/src/Scaffolding/Scaffolders/OperationScaffolder.php b/src/Scaffolding/Scaffolders/OperationScaffolder.php
index 4ba1bcb6c..6b5f7ed01 100644
--- a/src/Scaffolding/Scaffolders/OperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/OperationScaffolder.php
@@ -47,13 +47,13 @@ abstract class OperationScaffolder implements Configurable
     public static function getOperationScaffoldFromIdentifier($name)
     {
         switch ($name) {
-            case GraphQLScaffolder::CREATE:
+            case SchemaScaffolder::CREATE:
                 return Create::class;
-            case GraphQLScaffolder::READ:
+            case SchemaScaffolder::READ:
                 return Read::class;
-            case GraphQLScaffolder::UPDATE:
+            case SchemaScaffolder::UPDATE:
                 return Update::class;
-            case GraphQLScaffolder::DELETE:
+            case SchemaScaffolder::DELETE:
                 return Delete::class;
         }
 
diff --git a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php b/src/Scaffolding/Scaffolders/SchemaScaffolder.php
similarity index 99%
rename from src/Scaffolding/Scaffolders/GraphQLScaffolder.php
rename to src/Scaffolding/Scaffolders/SchemaScaffolder.php
index d26151bf1..383cbf736 100644
--- a/src/Scaffolding/Scaffolders/GraphQLScaffolder.php
+++ b/src/Scaffolding/Scaffolders/SchemaScaffolder.php
@@ -14,7 +14,7 @@
  * The entry point for a GraphQL scaffolding definition. Holds DataObject type definitions,
  * and their nested Mutation/Query definitions.
  */
-class GraphQLScaffolder implements ManagerMutatorInterface
+class SchemaScaffolder implements ManagerMutatorInterface
 {
     const CREATE = 'create';
 
diff --git a/tests/ScaffoldingTest.php b/tests/ScaffoldingTest.php
index c980ff531..4d6168cdb 100644
--- a/tests/ScaffoldingTest.php
+++ b/tests/ScaffoldingTest.php
@@ -8,7 +8,7 @@
 use SilverStripe\GraphQL\Tests\Fake\OperationScaffolderFake;
 use SilverStripe\GraphQL\Tests\Fake\FakeResolver;
 use Doctrine\Instantiator\Exception\InvalidArgumentException;
-use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\OperationScaffolder;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\QueryScaffolder;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\MutationScaffolder;
@@ -86,20 +86,20 @@ public function testDataObjectScaffolderFields()
 	public function testDataObjectScaffolderOperations()
 	{
 		$scaffolder = $this->getFakeScaffolder();
-		$op = $scaffolder->operation(GraphQLScaffolder::CREATE);
+		$op = $scaffolder->operation(SchemaScaffolder::CREATE);
 
 		$this->assertInstanceOf(CRUDInterface::class, $op);
 
 		// Ensure we get back the same reference
 		$op->Test = true;
-		$op = $scaffolder->operation(GraphQLScaffolder::CREATE);
+		$op = $scaffolder->operation(SchemaScaffolder::CREATE);
 		$this->assertEquals(true, $op->Test);
 
 		// Ensure duplicates aren't created
-		$scaffolder->operation(GraphQLScaffolder::DELETE);
+		$scaffolder->operation(SchemaScaffolder::DELETE);
 		$this->assertEquals(2, $scaffolder->getOperations()->count());
 
-		$scaffolder->removeOperation(GraphQLScaffolder::DELETE);
+		$scaffolder->removeOperation(SchemaScaffolder::DELETE);
 		$this->assertEquals(1, $scaffolder->getOperations()->count());
 
 		$this->setExpectedExceptionRegExp(
@@ -183,8 +183,8 @@ public function testDataObjectScaffolderApplyConfig()
 		$observer->expects($this->exactly(2))
 			->method('operation')
 			->withConsecutive(
-				[$this->equalTo(GraphQLScaffolder::CREATE)],
-				[$this->equalTo(GraphQLScaffolder::READ)]
+				[$this->equalTo(SchemaScaffolder::CREATE)],
+				[$this->equalTo(SchemaScaffolder::READ)]
 			)
 			->will($this->returnValue(
 				$this->getMockBuilder(Create::class)
@@ -294,10 +294,10 @@ public function testDataObjectScaffolderWildcards()
 		]);
 		$ops = $scaffolder->getOperations();
 
-		$this->assertInstanceOf(Create::class, $ops->findByIdentifier(GraphQLScaffolder::CREATE));
-		$this->assertInstanceOf(Delete::class, $ops->findByIdentifier(GraphQLScaffolder::DELETE));
-		$this->assertInstanceOf(Read::class, $ops->findByIdentifier(GraphQLScaffolder::READ));
-		$this->assertInstanceOf(Update::class, $ops->findByIdentifier(GraphQLScaffolder::UPDATE));
+		$this->assertInstanceOf(Create::class, $ops->findByIdentifier(SchemaScaffolder::CREATE));
+		$this->assertInstanceOf(Delete::class, $ops->findByIdentifier(SchemaScaffolder::DELETE));
+		$this->assertInstanceOf(Read::class, $ops->findByIdentifier(SchemaScaffolder::READ));
+		$this->assertInstanceOf(Update::class, $ops->findByIdentifier(SchemaScaffolder::UPDATE));
 
 		$this->assertEquals(
 			['ID','ClassName','LastEdited','Created','MyField','MyInt'],
@@ -347,9 +347,9 @@ public function testDataObjectScaffolderAddToManager()
 		$manager = new Manager();
 		$scaffolder = $this->getFakeScaffolder()
 			->addFields(['MyField'])
-			->operation(GraphQLScaffolder::CREATE)
+			->operation(SchemaScaffolder::CREATE)
 				->end()
-			->operation(GraphQLScaffolder::READ)
+			->operation(SchemaScaffolder::READ)
 				->end();
 
 		$scaffolder->addToManager($manager);
@@ -374,10 +374,10 @@ public function testDataObjectScaffolderAddToManager()
 	}
 
 
-	public function testGraphQLScaffolderTypes()
+	public function testSchemaScaffolderTypes()
 	{
 
-		$scaffolder = new GraphQLScaffolder();
+		$scaffolder = new SchemaScaffolder();
 		$type = $scaffolder->type(DataObjectFake::class);
 		$type->Test = true;
 		$type2 = $scaffolder->type(DataObjectFake::class);
@@ -407,19 +407,19 @@ public function testGraphQLScaffolderTypes()
 
 	}
 
-	public function testGraphQLScaffolderAddToManager()
+	public function testSchemaScaffolderAddToManager()
 	{
 		Config::inst()->update('Page','db', [
 			'TestPageField' => 'Varchar'
 		]);
 
 		$manager = new Manager();
-		$scaffolder = (new GraphQLScaffolder())
+		$scaffolder = (new SchemaScaffolder())
 			->type(RedirectorPage::class)
 				->addFields(['Created','TestPageField', 'RedirectionType'])
-				->operation(GraphQLScaffolder::CREATE)
+				->operation(SchemaScaffolder::CREATE)
 					->end()
-				->operation(GraphQLScaffolder::READ)
+				->operation(SchemaScaffolder::READ)
 					->end()
 				->end()
 			->type(DataObjectFake::class)
@@ -468,49 +468,49 @@ public function testGraphQLScaffolderAddToManager()
 
 		$this->assertInstanceof(
 			Read::class,			
-			$scaffolder->type(RedirectorPage::class)->getOperations()->findByIdentifier(GraphQLScaffolder::READ)
+			$scaffolder->type(RedirectorPage::class)->getOperations()->findByIdentifier(SchemaScaffolder::READ)
 		);
 		$this->assertInstanceof(
 			Read::class,			
-			$scaffolder->type(Page::class)->getOperations()->findByIdentifier(GraphQLScaffolder::READ)
+			$scaffolder->type(Page::class)->getOperations()->findByIdentifier(SchemaScaffolder::READ)
 		);
 		$this->assertInstanceof(
 			Read::class,			
-			$scaffolder->type(SiteTree::class)->getOperations()->findByIdentifier(GraphQLScaffolder::READ)
+			$scaffolder->type(SiteTree::class)->getOperations()->findByIdentifier(SchemaScaffolder::READ)
 		);
 
 		$this->assertInstanceof(
 			Create::class,			
-			$scaffolder->type(RedirectorPage::class)->getOperations()->findByIdentifier(GraphQLScaffolder::CREATE)
+			$scaffolder->type(RedirectorPage::class)->getOperations()->findByIdentifier(SchemaScaffolder::CREATE)
 		);
 		$this->assertInstanceof(
 			Create::class,			
-			$scaffolder->type(Page::class)->getOperations()->findByIdentifier(GraphQLScaffolder::CREATE)
+			$scaffolder->type(Page::class)->getOperations()->findByIdentifier(SchemaScaffolder::CREATE)
 		);
 		$this->assertInstanceof(
 			Create::class,			
-			$scaffolder->type(SiteTree::class)->getOperations()->findByIdentifier(GraphQLScaffolder::CREATE)
+			$scaffolder->type(SiteTree::class)->getOperations()->findByIdentifier(SchemaScaffolder::CREATE)
 		);
 	}
 
-	public function testGraphQLScaffolderCreateFromConfigThrowsIfBadTypes()
+	public function testSchemaScaffolderCreateFromConfigThrowsIfBadTypes()
 	{
 		$this->setExpectedExceptionRegExp(
 			InvalidArgumentException::class,
 			'/"types" must be a map of class name to settings/'
 		);
-		GraphQLScaffolder::createFromConfig([
+		SchemaScaffolder::createFromConfig([
 			'types' => ['fail']
 		]);
 	}
 
-	public function testGraphQLScaffolderCreateFromConfigThrowsIfBadQueries()
+	public function testSchemaScaffolderCreateFromConfigThrowsIfBadQueries()
 	{
 		$this->setExpectedExceptionRegExp(
 			InvalidArgumentException::class,
 			'/must be a map of operation name to settings/'
 		);
-		GraphQLScaffolder::createFromConfig([
+		SchemaScaffolder::createFromConfig([
 			'types' => [
 				DataObjectFake::class => [
 					'fields' => '*'
@@ -520,9 +520,9 @@ public function testGraphQLScaffolderCreateFromConfigThrowsIfBadQueries()
 		]);
 	}
 
-	public function testGraphQLScaffolderCreateFromConfig()
+	public function testSchemaScaffolderCreateFromConfig()
 	{
-		$observer = $this->getMockBuilder(GraphQLScaffolder::class)
+		$observer = $this->getMockBuilder(SchemaScaffolder::class)
 			->setMethods(['query','mutation','type'])
 			->getMock();
 
@@ -540,9 +540,9 @@ public function testGraphQLScaffolderCreateFromConfig()
 				new DataObjectScaffolder(DataObjectFake::class)
 			);
 
-		Injector::inst()->registerService($observer, GraphQLScaffolder::class);
+		Injector::inst()->registerService($observer, SchemaScaffolder::class);
 
-		GraphQLScaffolder::createFromConfig([
+		SchemaScaffolder::createFromConfig([
 			'types' => [
 				DataObjectFake::class => [
 					'fields' => ['MyField']
@@ -567,19 +567,19 @@ public function testOperationIdentifiers()
 	{
 		$this->assertEquals(
 			Read::class, 
-			OperationScaffolder::getOperationScaffoldFromIdentifier(GraphQLScaffolder::READ)
+			OperationScaffolder::getOperationScaffoldFromIdentifier(SchemaScaffolder::READ)
 		);
 		$this->assertEquals(
 			Update::class, 
-			OperationScaffolder::getOperationScaffoldFromIdentifier(GraphQLScaffolder::UPDATE)
+			OperationScaffolder::getOperationScaffoldFromIdentifier(SchemaScaffolder::UPDATE)
 		);
 		$this->assertEquals(
 			Delete::class, 
-			OperationScaffolder::getOperationScaffoldFromIdentifier(GraphQLScaffolder::DELETE)
+			OperationScaffolder::getOperationScaffoldFromIdentifier(SchemaScaffolder::DELETE)
 		);
 		$this->assertEquals(
 			Create::class, 
-			OperationScaffolder::getOperationScaffoldFromIdentifier(GraphQLScaffolder::CREATE)
+			OperationScaffolder::getOperationScaffoldFromIdentifier(SchemaScaffolder::CREATE)
 		);
 
 	}

From c4d95446d508a869b918a55e0d347beff24b995f Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 12 Jan 2017 12:47:01 +1300
Subject: [PATCH 35/66] namespace updates to README

---
 README.md | 84 +++++++++++++++++++++++++++----------------------------
 1 file changed, 42 insertions(+), 42 deletions(-)

diff --git a/README.md b/README.md
index eba3509e1..5472de05a 100644
--- a/README.md
+++ b/README.md
@@ -513,7 +513,7 @@ The example code will show demonstrate both methods for each section.
 For these examples, we'll imagine we have the following model:
 
 ```php
-namespace MyProject\GraphQL;
+namespace MyProject;
 
 class Post extends DataObject {
 
@@ -527,7 +527,7 @@ class Post extends DataObject {
   ];
 
   private static $has_many = [
-  	'Comments' => 'MyProject\GraphQL\Comment'
+  	'Comments' => 'MyProject\Comment'
   ];
 
   private static $many_many = [
@@ -560,13 +560,13 @@ bootstrap itself with any scaffolders that are registered in its config. These s
 As a `ScaffoldingProvider`, the class must now offer the `provideGraphQLScaffolding()` method.
 
 ```php
-namespace MyProject\GraphQL;
+namespace MyProject;
 use SilverStripe\GraphQL\Scaffolding\Interfaces\ScaffoldingProvider;
-use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
 
 class Post extends DataObject implements ScaffoldingProvider {
 	//...
-    public function provideGraphQLScaffolding(GraphQLScaffolder $scaffolder)
+    public function provideGraphQLScaffolding(SchemaScaffolder $scaffolder)
     {
     	// update the scaffolder here
 	}
@@ -579,7 +579,7 @@ In order to register the scaffolding provider with the manager, we'll need to ma
 SilverStripe\GraphQL:
   schema:
     scaffolding_providers:
-      - MyProject\GraphQL\Post
+      - MyProject\Post
 ```
 
 
@@ -595,7 +595,7 @@ SilverStripe\GraphQL:
   schema:
     scaffolding:
       types:
-        MyProject\GraphQL\Post:
+        MyProject\Post:
           fields: [ID, Title, Content]
           operations:
             read: true
@@ -622,18 +622,18 @@ mutation UpdatePost($ID: ID!, $Input: PostUpdateInputType!)
 
 **...Or with code**:
 ```php
-namespace MyProject\GraphQL;
+namespace MyProject;
 
 class Post extends DataObject implements ScaffoldingProvider {
 	//...
-    public function provideGraphQLScaffolding(GraphQLScaffolder $scaffolder)
+    public function provideGraphQLScaffolding(SchemaScaffolder $scaffolder)
     {
     	$scaffolder
     		->type(Post::class)
 	    		->addFields(['ID','Title','Content'])
-	    		->operation(GraphQLScaffolder::READ)
+	    		->operation(SchemaScaffolder::READ)
 	    			->end()
-	    		->operation(GraphQLScaffolder::UPDATE)
+	    		->operation(SchemaScaffolder::UPDATE)
 	    			->end()
 	    		->end();
 
@@ -655,13 +655,13 @@ SilverStripe\GraphQL:
   schema:
     scaffolding:
       types:
-        MyProject\GraphQL\Post:
+        MyProject\Post:
           fields: [ID, Title, Content]
           operations:
             read:
               args:
                 StartingWith: String
-              resolver: MyProject\GraphQL\ReadPostResolver
+              resolver: MyProject\ReadPostResolver
             create: true
 ```
 
@@ -670,7 +670,7 @@ SilverStripe\GraphQL:
 	$scaffolder
 		->type(Post::class)
     		->addFields(['ID','Title','Content'])
-    		->operation(GraphQLScaffolder::READ)
+    		->operation(SchemaScaffolder::READ)
     			->addArgs([
     				'StartingWith' => 'String'
     			])
@@ -683,7 +683,7 @@ SilverStripe\GraphQL:
         			return $list;
         		})         	
     			->end()
-    		->operation(GraphQLScaffolder::UPDATE)
+    		->operation(SchemaScaffolder::UPDATE)
     			->end()
     		->end();
 ```
@@ -735,7 +735,7 @@ This resolver class may now be assigned as either an instance, or a string to th
 ```php
 	$scaffolder
 		->type(Post::class)
-			->operation(GraphQLScaffolder::UPDATE)
+			->operation(SchemaScaffolder::UPDATE)
 				->setResolver(MyResolver::class)
 				->end();
 ```
@@ -743,7 +743,7 @@ Or...
 ```php
 	$scaffolder
 		->type(Post::class)
-			->operation(GraphQLScaffolder::UPDATE)
+			->operation(SchemaScaffolder::UPDATE)
 				->setResolver(new MyResolver())
 				->end();
 ```
@@ -758,16 +758,16 @@ SilverStripe\GraphQL:
   schema:
     scaffolding:
       types:
-        MyProject\GraphQL\Post:
+        MyProject\Post:
           fields: [ID, Title, Content]
           operations:
             read:
               args:
                 StartingWith: String
-              resolver: MyProject\GraphQL\ReadPostResolver
+              resolver: MyProject\ReadPostResolver
               sortableFields: [Title]            
             create: true
-        MyProject\GraphQL\Comment:
+        MyProject\Comment:
           fields: [Comment, Author]
           operations:
             read:
@@ -779,7 +779,7 @@ SilverStripe\GraphQL:
 	$scaffolder
 		->type(Post::class)
     		->addFields(['ID','Title','Content'])
-    		->operation(GraphQLScaffolder::READ)
+    		->operation(SchemaScaffolder::READ)
     			->addArgs([
     				'StartingWith' => 'String'
     			])
@@ -793,12 +793,12 @@ SilverStripe\GraphQL:
         		})
         		->addSortableFields(['Title'])         	
     			->end()
-    		->operation(GraphQLScaffolder::UPDATE)
+    		->operation(SchemaScaffolder::UPDATE)
     			->end()
     		->end()
     	->type(Comment::class)
     		->addFields(['Comment','Author'])
-    		->operation(GraphQLScaffolder::READ)
+    		->operation(SchemaScaffolder::READ)
     			->setUsePagination(false)
     			->end();
 ```
@@ -836,19 +836,19 @@ SilverStripe\GraphQL:
   schema:
     scaffolding:
       types:
-        MyProject\GraphQL\Post:
+        MyProject\Post:
           fields: [ID, Title, Content, Author]
           operations:
             read:
               args:
                 StartingWith: String
-              resolver: MyProject\GraphQL\ReadPostResolver
+              resolver: MyProject\ReadPostResolver
               sortableFields: [Title]            
             create: true
           nestedQueries:
             Comments: true
             Files: true
-        MyProject\GraphQL\Comment:
+        MyProject\Comment:
           fields: [Comment, Author]
           operations:
             read:
@@ -861,7 +861,7 @@ SilverStripe\GraphQL:
 	$scaffolder
 		->type(Post::class)
     		->addFields(['ID','Title','Content', 'Author'])
-    		->operation(GraphQLScaffolder::READ)
+    		->operation(SchemaScaffolder::READ)
     			->addArgs([
     				'StartingWith' => 'String'
     			])
@@ -875,7 +875,7 @@ SilverStripe\GraphQL:
         		})
         		->addSortableFields(['Title'])         	
     			->end()    			
-    		->operation(GraphQLScaffolder::UPDATE)
+    		->operation(SchemaScaffolder::UPDATE)
     			->end()
     		->nestedQuery('Comments')
     			->end()
@@ -884,7 +884,7 @@ SilverStripe\GraphQL:
     		->end()
     	->type(Comment::class)
     		->addFields(['Comment','Author'])
-    		->operation(GraphQLScaffolder::READ)
+    		->operation(SchemaScaffolder::READ)
     			->setUsePagination(false)
     			->end();
 
@@ -936,9 +936,9 @@ SilverStripe\GraphQL:
   schema:
     scaffolding:
       types:
-        MyProject\GraphQL\Post:
+        MyProject\Post:
           ## ...
-        MyProject\GraphQL\Comment:
+        MyProject\Comment:
           ## ...
         SilverStripe\Security\Member
           fields: [FirstName, Surname, Name, Email]
@@ -969,13 +969,13 @@ SilverStripe\GraphQL:
   schema:
     scaffolding:
       types:
-        MyProject\GraphQL\Post:
+        MyProject\Post:
           ## ...
           nestedQueries:
             Comments:
               args:
                 OnlyToday: Boolean
-                resolver: MyProject\GraphQL\CommentResolver
+                resolver: MyProject\CommentResolver
           ##...
         ##...
 ```
@@ -1049,7 +1049,7 @@ SilverStripe\GraphQL:
   schema:
     scaffolding:
       types:
-        MyProject\GraphQL\Post:
+        MyProject\Post:
           fieldsExcept: [SecretThing]
 ```
 
@@ -1071,20 +1071,20 @@ SilverStripe\GraphQL:
   schema:
     scaffolding:
       types:
-        MyProject\GraphQL\Post:
+        MyProject\Post:
           ##...
       mutations:
         updatePostTitle:
-          type: MyProject\GraphQL\Post
+          type: MyProject\Post
           args:
             ID: ID!
             NewTitle: String!
-          resolver: MyProject\GraphQL\UpdatePostResolver
+          resolver: MyProject\UpdatePostResolver
       queries:
         latestPost:
-          type: MyProject\GraphQL\Post
+          type: MyProject\Post
           paginate: false
-          resolver: MyProject\GraphQL\LatestPostResolver
+          resolver: MyProject\LatestPostResolver
 ```
 
 **... Or with code**:
@@ -1140,7 +1140,7 @@ SilverStripe\GraphQL:
   schema:
     scaffolding:
       types:
-        MyProject\GraphQL\Post:
+        MyProject\Post:
           ##...
         SilverStripe\CMS\Model\RedirectorPage:
           fields: [ExternalURL, Content]
@@ -1156,9 +1156,9 @@ SilverStripe\GraphQL:
 	$scaffolder
         ->type('SilverStripe\CMS\Model\RedirectorPage')
         	->addFields(['ExternalURL','Content'])
-        	->operation(GraphQLScaffolder::READ)
+        	->operation(SchemaScaffolder::READ)
         		->end()
-        	->operation(GraphQLScaffolder::CREATE)
+        	->operation(SchemaScaffolder::CREATE)
         		->end()
         	->end()
         ->type('Page')

From 5f65e5083ace2b4294659a0369e598aeccc7fd69 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 12 Jan 2017 12:58:19 +1300
Subject: [PATCH 36/66] README updates

---
 README.md | 30 ++++++++++++++++++++----------
 1 file changed, 20 insertions(+), 10 deletions(-)

diff --git a/README.md b/README.md
index 5472de05a..421ea525a 100644
--- a/README.md
+++ b/README.md
@@ -590,7 +590,7 @@ resolve queries and mutations, we'll need to specify the name of a resolver clas
 must implement the `SilverStripe\GraphQL\Scaffolding\ResolverInterface`. (More on this below).
 
 **Via YAML**:
-```
+```yaml
 SilverStripe\GraphQL:
   schema:
     scaffolding:
@@ -602,7 +602,10 @@ SilverStripe\GraphQL:
             create: true
 ```
 
-We can now access the posts via GraphQL.
+By declaring these two operations, we have automatically added a new query and 
+mutation to the GraphQL schema, using naming naming conventions derived from
+the operation type and the `singular_name` or `plural_name` of the DataObject.
+
 ```
 query {
 	readPosts {
@@ -613,11 +616,15 @@ query {
 ```
 
 ```
-mutation UpdatePost($ID: ID!, $Input: PostUpdateInputType!)
-	updatePost(ID:$ID, Input: { Title: "Some new Title" }) {
+mutation CreatePost($Input: PostCreateInputType!)
+	createPost(Input: $Input) {
 		Title
 	}
 }
+
+{
+	"Input": {Title: "My Title"}
+}
 ```
 
 **...Or with code**:
@@ -660,7 +667,7 @@ SilverStripe\GraphQL:
           operations:
             read:
               args:
-                StartingWith: String
+                Title: String
               resolver: MyProject\ReadPostResolver
             create: true
 ```
@@ -672,12 +679,15 @@ SilverStripe\GraphQL:
     		->addFields(['ID','Title','Content'])
     		->operation(SchemaScaffolder::READ)
     			->addArgs([
-    				'StartingWith' => 'String'
+    				'Title' => 'String'
     			])
-        		->setResolver(function($obj, $args) {
+        		->setResolver(function($obj, $args, $context) {
+        			if(!singleton(Post::class)->canView($context['currentMember'])) {
+        				throw new \Exception('Cannot view Post');
+        			}
         			$list = Post::get();
-        			if(isset($args['StartingWith'])) {
-        				$list = $list->filter('Title:StartsWith', $args['StartingWith']);
+        			if(isset($args['Title'])) {
+        				$list = $list->filter('Title:PartialMatch', $args['Title']);
         			}
 
         			return $list;
@@ -831,7 +841,7 @@ and any custom getter that returns a `DataList`, we can set up a nested query.
 
 
 **Via YAML**:
-```
+```yaml
 SilverStripe\GraphQL:
   schema:
     scaffolding:

From a823b2029f8589583b62d7bc01afd214341b18f3 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 12 Jan 2017 13:10:27 +1300
Subject: [PATCH 37/66] Use non-matching group for type parser

---
 src/Scaffolding/Util/TypeParser.php | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/Scaffolding/Util/TypeParser.php b/src/Scaffolding/Util/TypeParser.php
index 526282b6d..789978698 100644
--- a/src/Scaffolding/Util/TypeParser.php
+++ b/src/Scaffolding/Util/TypeParser.php
@@ -37,7 +37,7 @@ class TypeParser
      */
     public function __construct($rawArg)
     {
-        if (!preg_match('/^([A-Za-z]+)(!?)(\s*=\s*(.*))?/', $rawArg, $matches)) {
+        if (!preg_match('/^([A-Za-z]+)(!?)(?:\s*=\s*(.*))?/', $rawArg, $matches)) {
             throw new InvalidArgumentException(
                 "Invalid argument: $rawArg"
             );
@@ -46,8 +46,8 @@ public function __construct($rawArg)
         $this->rawArg = $rawArg;
         $this->argType = $matches[1];
         $this->required = isset($matches[2]) && $matches[2] == '!';
-        if (isset($matches[4])) {
-            $this->defaultValue = $matches[4];
+        if (isset($matches[3])) {
+            $this->defaultValue = $matches[3];
         }
 
     }

From 28d8fd90ac583ece133cb97f512ff6bd7d3e9c58 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 12 Jan 2017 13:14:05 +1300
Subject: [PATCH 38/66] More README updates

---
 README.md | 34 ++++++++++++++++++++--------------
 1 file changed, 20 insertions(+), 14 deletions(-)

diff --git a/README.md b/README.md
index 421ea525a..a7082260b 100644
--- a/README.md
+++ b/README.md
@@ -701,7 +701,7 @@ SilverStripe\GraphQL:
 **GraphQL**
 ```
 query {
-  readPosts(StartingWith: "o") {
+  readPosts(Title: "Barcelona") {
     edges {
       node {
         Title
@@ -773,7 +773,7 @@ SilverStripe\GraphQL:
           operations:
             read:
               args:
-                StartingWith: String
+                Title: String
               resolver: MyProject\ReadPostResolver
               sortableFields: [Title]            
             create: true
@@ -791,12 +791,15 @@ SilverStripe\GraphQL:
     		->addFields(['ID','Title','Content'])
     		->operation(SchemaScaffolder::READ)
     			->addArgs([
-    				'StartingWith' => 'String'
+    				'Title' => 'String'
     			])
-        		->setResolver(function($obj, $args) {
+        		->setResolver(function($obj, $args, $context) {
+        			if(!singleton(Post::class)->canView($context['currentMember'])) {
+        				throw new \Exception('Cannot view Post');
+        			}
         			$list = Post::get();
-        			if(isset($args['StartingWith'])) {
-        				$list = $list->filter('Title:StartsWith', $args['StartingWith']);
+        			if(isset($args['Title'])) {
+        				$list = $list->filter('Title:PartialMatch', $args['Title']);
         			}
 
         			return $list;
@@ -815,7 +818,7 @@ SilverStripe\GraphQL:
 
 **GraphQL**
 ```
-query readPosts(StartingWith: "a", sortBy: [{field:Title, direction:DESC}]) {
+query readPosts(Title: "Japan", sortBy: [{field:Title, direction:DESC}]) {
 	edges {
 		node {
 			Title
@@ -851,7 +854,7 @@ SilverStripe\GraphQL:
           operations:
             read:
               args:
-                StartingWith: String
+                Title: String
               resolver: MyProject\ReadPostResolver
               sortableFields: [Title]            
             create: true
@@ -873,12 +876,15 @@ SilverStripe\GraphQL:
     		->addFields(['ID','Title','Content', 'Author'])
     		->operation(SchemaScaffolder::READ)
     			->addArgs([
-    				'StartingWith' => 'String'
+    				'Title' => 'String'
     			])
-        		->setResolver(function($obj, $args) {
+        		->setResolver(function($obj, $args, $context) {
+        			if(!singleton(Post::class)->canView($context['currentMember'])) {
+        				throw new \Exception('Cannot view Post');
+        			}        		
         			$list = Post::get();
-        			if(isset($args['StartingWith'])) {
-        				$list = $list->filter('Title:StartsWith', $args['StartingWith']);
+        			if(isset($args['Title'])) {
+        				$list = $list->filter('Title:PartialMatch', $args['Title']);
         			}
 
         			return $list;
@@ -904,7 +910,7 @@ SilverStripe\GraphQL:
 
 ```
 query {
-  readPosts(StartingWith: "a") {
+  readPosts(Title: "Texas") {
     edges {
       node {
         Title
@@ -1016,7 +1022,7 @@ SilverStripe\GraphQL:
 
 ```
 query {
-  readPosts(StartingWith: "a") {
+  readPosts(Title: "Sydney") {
     edges {
       node {
         Title

From a5dbd7543955440ec15bf8339881fa6261d60755 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 12 Jan 2017 13:21:21 +1300
Subject: [PATCH 39/66] Add can* checks to examples

---
 README.md | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index a7082260b..677349c99 100644
--- a/README.md
+++ b/README.md
@@ -1005,6 +1005,9 @@ SilverStripe\GraphQL:
 					'OnlyToday' => 'Boolean'
 				])
             	->setResolver(function($obj, $args, $context) {
+            		if(!singleton(Comment::class)->canView($context['currentMember'])) {
+            			throw new \Exception('Cannot view Comment');
+            		}
             		$comments = $obj->Comments();
             		if(isset($args['OnlyToday']) && $args['OnlyToday']) {
             			$comments = $comments->where('DATE(Created) = DATE(NOW())');
@@ -1113,9 +1116,9 @@ SilverStripe\GraphQL:
                 'ID' => 'ID!',
                 'NewTitle' => 'String!'
             ])
-            ->setResolver(function($obj, $args) {
+            ->setResolver(function($obj, $args, $context) {            	
                 $post = Post::get()->byID($args['ID']);
-                if($post->canEdit()) {
+                if($post->canEdit($context['currentMember'])) {
                     $post->Title = $args['NewTitle'];
                     $post->write();
                 }
@@ -1125,8 +1128,10 @@ SilverStripe\GraphQL:
             ->end()
 	    ->query('latestPost', Post::class)
         	->setUsePagination(false)
-        	->setResolver(function($obj, $args) {
-        		return Post::get()->sort('Date', 'DESC')->first();
+        	->setResolver(function($obj, $args, $context) {
+        		if(singleton(Post::class)->canView($context['currentMember'])) {
+        			return Post::get()->sort('Date', 'DESC')->first();
+        		}
         	})
         	->end()
 ```

From 5ff2f6ba915599a98dc06565e8e0755f6738326b Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 12 Jan 2017 13:21:44 +1300
Subject: [PATCH 40/66] Add can* checks to CRUD using $context

---
 src/Scaffolding/Scaffolders/CRUD/Create.php | 2 +-
 src/Scaffolding/Scaffolders/CRUD/Delete.php | 2 +-
 src/Scaffolding/Scaffolders/CRUD/Read.php   | 8 ++++++++
 src/Scaffolding/Scaffolders/CRUD/Update.php | 2 +-
 4 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/Scaffolding/Scaffolders/CRUD/Create.php b/src/Scaffolding/Scaffolders/CRUD/Create.php
index 8e8b8203f..de80aba58 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Create.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Create.php
@@ -36,7 +36,7 @@ public function __construct($dataObjectClass)
 
         // Todo: this is totally half baked
         $this->setResolver(function ($object, array $args, $context, $info) {
-            if (singleton($this->dataObjectClass)->canCreate()) {
+            if (singleton($this->dataObjectClass)->canCreate($context['currentMember'])) {
                 $newObject = Injector::inst()->createWithArgs(
                     $this->dataObjectClass,
                     $args
diff --git a/src/Scaffolding/Scaffolders/CRUD/Delete.php b/src/Scaffolding/Scaffolders/CRUD/Delete.php
index 47fc0c714..4eb09cfdd 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Delete.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Delete.php
@@ -36,7 +36,7 @@ public function __construct($dataObjectClass)
                 ->byIDs($args['IDs']);
 
             foreach ($results as $obj) {
-                if ($obj->canDelete()) {
+                if ($obj->canDelete($context['currentMember'])) {
                     $obj->delete();
                 } else {
                     throw new Exception(sprintf(
diff --git a/src/Scaffolding/Scaffolders/CRUD/Read.php b/src/Scaffolding/Scaffolders/CRUD/Read.php
index 8b4f5ac42..05b528e56 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Read.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Read.php
@@ -7,6 +7,7 @@
 use SilverStripe\ORM\DataList;
 use SilverStripe\GraphQL\Scaffolding\Interfaces\CRUDInterface;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
+use Exception;
 
 /**
  * Scaffolds a generic read operation for DataObjects.
@@ -32,6 +33,13 @@ public function __construct($dataObjectClass)
         parent::__construct($operationName, $this->typeName());
 
         $this->setResolver(function ($object, array $args, $context, $info) {
+            if(!singleton($this->dataObjectClass)->canView($context['currentMember'])) {
+            	throw new Exception(sprintf(
+            		'Cannot create %s',
+            		$this->dataObjectClass
+            	));
+            }
+            
             $list = DataList::create($this->dataObjectClass);
 
             return $list;
diff --git a/src/Scaffolding/Scaffolders/CRUD/Update.php b/src/Scaffolding/Scaffolders/CRUD/Update.php
index 8b51fde86..9dbf288fb 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Update.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Update.php
@@ -47,7 +47,7 @@ public function __construct($dataObjectClass)
                 ));
             }
 
-            if ($obj->canEdit()) {
+            if ($obj->canEdit($context['currentMember'])) {
                 $obj->update($args['Input']);
                 $obj->write();
 

From 69dbe7b040f83a8517fe2419e8e223e0ca886994 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 12 Jan 2017 13:41:15 +1300
Subject: [PATCH 41/66] Add input type examples

---
 README.md | 99 +++++++++++++++++++++++++++++++++----------------------
 1 file changed, 59 insertions(+), 40 deletions(-)

diff --git a/README.md b/README.md
index 677349c99..eb05619d4 100644
--- a/README.md
+++ b/README.md
@@ -602,6 +602,30 @@ SilverStripe\GraphQL:
             create: true
 ```
 
+
+**...Or with code**:
+
+```php
+namespace MyProject;
+
+class Post extends DataObject implements ScaffoldingProvider {
+	//...
+    public function provideGraphQLScaffolding(SchemaScaffolder $scaffolder)
+    {
+    	$scaffolder
+    		->type(Post::class)
+	    		->addFields(['ID','Title','Content'])
+	    		->operation(SchemaScaffolder::READ)
+	    			->end()
+	    		->operation(SchemaScaffolder::UPDATE)
+	    			->end()
+	    		->end();
+
+    	return $scaffolder;
+	}
+}
+```
+
 By declaring these two operations, we have automatically added a new query and 
 mutation to the GraphQL schema, using naming naming conventions derived from
 the operation type and the `singular_name` or `plural_name` of the DataObject.
@@ -627,27 +651,8 @@ mutation CreatePost($Input: PostCreateInputType!)
 }
 ```
 
-**...Or with code**:
-```php
-namespace MyProject;
-
-class Post extends DataObject implements ScaffoldingProvider {
-	//...
-    public function provideGraphQLScaffolding(SchemaScaffolder $scaffolder)
-    {
-    	$scaffolder
-    		->type(Post::class)
-	    		->addFields(['ID','Title','Content'])
-	    		->operation(SchemaScaffolder::READ)
-	    			->end()
-	    		->operation(SchemaScaffolder::UPDATE)
-	    			->end()
-	    		->end();
-
-    	return $scaffolder;
-	}
-}
-```
+Permission constraints (in this case `canView()` and `canCreate()`) are enforced
+by the operation resovlers.
 
 #### Adding arguments
 
@@ -747,16 +752,12 @@ This resolver class may now be assigned as either an instance, or a string to th
 		->type(Post::class)
 			->operation(SchemaScaffolder::UPDATE)
 				->setResolver(MyResolver::class)
-				->end();
-```
-Or...
-```php
-	$scaffolder
-		->type(Post::class)
-			->operation(SchemaScaffolder::UPDATE)
+				/* Or...
 				->setResolver(new MyResolver())
+				*/
 				->end();
 ```
+
 #### Configuring pagination and sorting
 
 By default, all queries are paginated and have no sortable fields. Both of these settings are
@@ -1138,7 +1139,7 @@ SilverStripe\GraphQL:
 
 **GraphQL**
 ```
-mutation updatePostTitle(ID: 123, NewTitle: 'Foo') {
+mutation updatePostTitle($ID: 123, $NewTitle: 'Foo') {
 	Title
 }
 ```
@@ -1164,7 +1165,7 @@ SilverStripe\GraphQL:
         MyProject\Post:
           ##...
         SilverStripe\CMS\Model\RedirectorPage:
-          fields: [ExternalURL, Content]
+          fields: [ID, ExternalURL, Content]
           operations:
             read: true
             create: true
@@ -1176,7 +1177,7 @@ SilverStripe\GraphQL:
 ```php
 	$scaffolder
         ->type('SilverStripe\CMS\Model\RedirectorPage')
-        	->addFields(['ExternalURL','Content'])
+        	->addFields(['ID','ExternalURL','Content'])
         	->operation(SchemaScaffolder::READ)
         		->end()
         	->operation(SchemaScaffolder::CREATE)
@@ -1191,21 +1192,39 @@ We now have the following added to our schema:
 
 ```
 type RedirectorPage {
-	ID
-	ExternalURL
-	Content
-	MyCustomField
+	ID: Int
+	ExternalURL: String
+	Content: String
+	MyCustomField: String
 }
 
 type Page {
-	ID
-	Content
-	MyCustomField
+	ID: Int
+	Content: String
+	MyCustomField: String
 }
 
 type SiteTree {
-	ID
-	Content
+	ID: Int
+	Content: String
+}
+
+input RedirectorPageCreateInputType {
+	ExternalURL: String
+	RedirectionType: String
+	MyCustomField: String
+	Content: String
+	# all other fields from RedirectorPage, Page and SiteTree
+}
+
+input PageCreateInputType {
+	MyCustomField: String
+	Content: String
+	# all other fields from Page and SiteTree
+}
+
+input SiteTreeCreateInputType {
+	# all fields from SiteTree
 }
 
 query readRedirectorPages {

From 5aa031063f8a75c77bc4f4a2118249305a177ff8 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Thu, 12 Jan 2017 13:43:10 +1300
Subject: [PATCH 42/66] replace member use statement

---
 src/Manager.php | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Manager.php b/src/Manager.php
index 831f6d749..acb2ee966 100644
--- a/src/Manager.php
+++ b/src/Manager.php
@@ -13,6 +13,7 @@
 use SilverStripe\Security\Member;
 use SilverStripe\GraphQL\Scaffolding\Interfaces\ScaffoldingProvider;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
+use SilverStripe\Security\Member;
 
 class Manager
 {

From 7daee8e6d5a33d775460f71af7bdcac05449101a Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Fri, 13 Jan 2017 22:48:57 +1300
Subject: [PATCH 43/66] Add tests for CRUD operations

---
 tests/Fake/DataObjectFake.php           |   9 +
 tests/Fake/RestrictedDataObjectFake.php |  16 ++
 tests/ScaffoldingTest.php               | 237 ++++++++++++++++++++++++
 3 files changed, 262 insertions(+)
 create mode 100644 tests/Fake/RestrictedDataObjectFake.php

diff --git a/tests/Fake/DataObjectFake.php b/tests/Fake/DataObjectFake.php
index cd55b99ae..5c9b586c7 100644
--- a/tests/Fake/DataObjectFake.php
+++ b/tests/Fake/DataObjectFake.php
@@ -43,4 +43,13 @@ public function customSetterMethod($val)
     {
         $this->customSetterMethodResult = $val;
     }
+
+	public function canCreate($member = null, $context = []) { return true; }
+	
+	public function canEdit($member = null) { return true; }
+	
+	public function canView($member = null) { return true; }
+	
+	public function canDelete($member = null) { return true; }
+
 }
diff --git a/tests/Fake/RestrictedDataObjectFake.php b/tests/Fake/RestrictedDataObjectFake.php
new file mode 100644
index 000000000..920b9b3f6
--- /dev/null
+++ b/tests/Fake/RestrictedDataObjectFake.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace SilverStripe\GraphQL\Tests\Fake;
+
+use SilverStripe\Dev\TestOnly;
+
+class RestrictedDataObjectFake extends DataObjectFake implements TestOnly
+{
+	public function canCreate($member = null, $context = []) { return false; }
+	
+	public function canEdit($member = null) { return false; }
+	
+	public function canView($member = null) { return false; }
+	
+	public function canDelete($member = null) { return false; }
+}
diff --git a/tests/ScaffoldingTest.php b/tests/ScaffoldingTest.php
index 4d6168cdb..a58eac49f 100644
--- a/tests/ScaffoldingTest.php
+++ b/tests/ScaffoldingTest.php
@@ -5,6 +5,7 @@
 use SilverStripe\Dev\SapphireTest;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\DataObjectScaffolder;
 use SilverStripe\GraphQL\Tests\Fake\DataObjectFake;
+use SilverStripe\GraphQL\Tests\Fake\RestrictedDataObjectFake;
 use SilverStripe\GraphQL\Tests\Fake\OperationScaffolderFake;
 use SilverStripe\GraphQL\Tests\Fake\FakeResolver;
 use Doctrine\Instantiator\Exception\InvalidArgumentException;
@@ -24,7 +25,11 @@
 use GraphQL\Type\Definition\ObjectType;
 use GraphQL\Type\Definition\StringType;
 use GraphQL\Type\Definition\NonNull;
+use GraphQL\Type\Definition\ListOfType;
+use GraphQL\Type\Definition\IntType;
+use GraphQL\Type\Definition\IDType;
 use GraphQL\Type\Definition\Type;
+use GraphQL\Type\Definition\ResolveInfo;
 use SilverStripe\CMS\Model\RedirectorPage;
 use SilverStripe\CMS\Model\SiteTree;
 use SilverStripe\Security\Member;
@@ -37,6 +42,11 @@
 class ScaffoldingTest extends SapphireTest
 {
 
+    protected $extraDataObjects = [
+        'SilverStripe\GraphQL\Tests\Fake\DataObjectFake',
+        'SilverStripe\GraphQL\Tests\Fake\RestrictedDataObjectFake'
+    ];
+
 	public function testDataObjectScaffolderConstructor()
 	{
 		$scaffolder = $this->getFakeScaffolder();
@@ -753,6 +763,233 @@ public function testQueryScaffolderApplyConfigThrowsOnBadSortableFields()
 		]);
 	}
 
+	public function testCreateOperationResolver()
+	{
+		$create = new Create(DataObjectFake::class);
+		$scaffold = $create->scaffold(new Manager());
+
+		$newRecord = $scaffold['resolve'](
+			null,
+			[
+				'Input' => ['MyField' => '__testing__']
+			],
+			[
+				'currentMember' => Member::create()
+			],
+			new ResolveInfo([])
+		);
+
+		$this->assertGreaterThan(0, $newRecord->ID);
+		$this->assertEquals('__testing__', $newRecord->MyField);
+	}
+
+	public function testCreateOperationInputType()
+	{
+		$create = new Create(DataObjectFake::class);
+		$scaffold = $create->scaffold(new Manager());
+
+		$this->assertArrayHasKey('Input', $scaffold['args']);
+		$this->assertInstanceof(NonNull::class, $scaffold['args']['Input']['type']);
+		
+		$config = $scaffold['args']['Input']['type']->getWrappedType()->config;
+
+		$this->assertEquals('Data_Object_FakeCreateInputType', $config['name']);
+		$fieldMap = [];
+		foreach($config['fields'] as $fieldData) {
+			$fieldMap[$fieldData['name']] = $fieldData['type'];
+		}
+		$this->assertArrayHasKey('MyField', $fieldMap);
+		$this->assertArrayHasKey('MyInt', $fieldMap);
+		$this->assertArrayNotHasKey('ID', $fieldMap);
+		$this->assertInstanceOf(StringType::class, $fieldMap['MyField']);
+		$this->assertInstanceOf(IntType::class, $fieldMap['MyInt']);
+	}
+
+	public function testCreateOperationPermissionCheck()
+	{
+		$create = new Create(RestrictedDataObjectFake::class);
+		$scaffold = $create->scaffold(new Manager());		
+
+		$this->setExpectedExceptionRegExp(
+			Exception::class,
+			'/Cannot create/'
+		);
+
+		$scaffold['resolve'](
+			null, 
+			[], 
+			['currentMember' => Member::create()], 
+			new ResolveInfo([])
+		);
+	}
+
+	public function testUpdateOperationResolver()
+	{
+		$update = new Update(DataObjectFake::class);
+		$scaffold = $update->scaffold(new Manager());
+
+		$record = DataObjectFake::create([
+			'MyField' => 'old'
+		]);
+		$ID = $record->write();
+
+		$scaffold['resolve'](
+			$record,
+			[
+				'ID' => $ID,
+				'Input' => ['MyField' => 'new']
+			],
+			[
+				'currentMember' => Member::create()
+			],
+			new ResolveInfo([])
+		);
+		$updatedRecord = DataObjectFake::get()->byID($ID);	
+		$this->assertEquals('new', $updatedRecord->MyField);
+	}
+
+	public function testUpdateOperationInputType()
+	{
+		$update = new Update(DataObjectFake::class);
+		$scaffold = $update->scaffold(new Manager());
+
+		$this->assertArrayHasKey('Input', $scaffold['args']);
+		$this->assertInstanceof(NonNull::class, $scaffold['args']['Input']['type']);
+		
+		$config = $scaffold['args']['Input']['type']->getWrappedType()->config;
+
+		$this->assertEquals('Data_Object_FakeUpdateInputType', $config['name']);
+		$fieldMap = [];
+		foreach($config['fields'] as $fieldData) {
+			$fieldMap[$fieldData['name']] = $fieldData['type'];
+		}
+		$this->assertArrayHasKey('MyField', $fieldMap);
+		$this->assertArrayHasKey('MyInt', $fieldMap);
+		$this->assertArrayNotHasKey('ID', $fieldMap);
+		$this->assertInstanceOf(StringType::class, $fieldMap['MyField']);
+		$this->assertInstanceOf(IntType::class, $fieldMap['MyInt']);
+	}
+
+	public function testUpdateOperationPermissionCheck()
+	{
+		$update = new Update(RestrictedDataObjectFake::class);
+		$restrictedDataobject = RestrictedDataObjectFake::create();
+		$ID = $restrictedDataobject->write();
+
+		$scaffold = $update->scaffold(new Manager());		
+
+		$this->setExpectedExceptionRegExp(
+			Exception::class,
+			'/Cannot edit/'
+		);
+
+		$scaffold['resolve'](
+			$restrictedDataobject, 
+			['ID' => $ID], 
+			['currentMember' => Member::create()], 
+			new ResolveInfo([])
+		);
+	}
+
+
+	public function testDeleteOperationResolver()
+	{
+		$delete = new Delete(DataObjectFake::class);
+		$scaffold = $delete->scaffold(new Manager());
+
+		$record = DataObjectFake::create();
+		$ID1 = $record->write();
+
+		$record = DataObjectFake::create();
+		$ID2 = $record->write();
+
+		$record = DataObjectFake::create();
+		$ID3 = $record->write();
+
+		$scaffold['resolve'](
+			$record,
+			[			
+				'IDs' => [$ID1, $ID2]
+			],
+			[
+				'currentMember' => Member::create()
+			],
+			new ResolveInfo([])
+		);
+		
+		$this->assertNull(DataObjectFake::get()->byID($ID1));
+		$this->assertNull(DataObjectFake::get()->byID($ID2));
+		$this->assertInstanceOf(DataObjectFake::class, DataObjectFake::get()->byID($ID3));
+	}
+
+	public function testDeleteOperationArgs()
+	{
+		$delete = new Delete(DataObjectFake::class);
+		$scaffold = $delete->scaffold(new Manager());
+
+		$this->assertArrayHasKey('IDs', $scaffold['args']);
+		$this->assertInstanceof(NonNull::class, $scaffold['args']['IDs']['type']);
+		
+		$listOf = $scaffold['args']['IDs']['type']->getWrappedType();
+
+		$this->assertInstanceOf(ListOfType::class, $listOf);
+
+		$idType = $listOf->getWrappedType();
+
+		$this->assertInstanceof(IDType::class, $idType);
+	}
+
+	public function testDeleteOperationPermissionCheck()
+	{
+		$delete = new Delete(RestrictedDataObjectFake::class);
+		$restrictedDataobject = RestrictedDataObjectFake::create();
+		$ID = $restrictedDataobject->write();
+
+		$scaffold = $delete->scaffold(new Manager());		
+
+		$this->setExpectedExceptionRegExp(
+			Exception::class,
+			'/Cannot delete/'
+		);
+
+		$scaffold['resolve'](
+			$restrictedDataobject, 
+			['IDs' => [$ID]], 
+			['currentMember' => Member::create()], 
+			new ResolveInfo([])
+		);
+	}
+
+	public function testReadOperationResolver()
+	{
+		$read = new Read(DataObjectFake::class);
+		$scaffold = $read->scaffold(new Manager());
+
+		DataObjectFake::get()->removeAll();
+		
+		$record = DataObjectFake::create();
+		$ID1 = $record->write();
+
+		$record = DataObjectFake::create();
+		$ID2 = $record->write();
+
+		$record = DataObjectFake::create();
+		$ID3 = $record->write();
+
+		$response = $scaffold['resolve'](
+			null,
+			[],
+			[
+				'currentMember' => Member::create()
+			],
+			new ResolveInfo([])
+		);
+
+		$this->assertArrayHasKey('edges', $response);
+		$this->assertEquals([$ID1, $ID2, $ID3], $response['edges']->column('ID'));
+	}
+
+
     public function testTypeParser()
     {
         $parser = new TypeParser('String!=Test');

From f6a3cc3662d9f352afea8cd7eedc1df93fe45d24 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Sun, 15 Jan 2017 09:18:56 +1300
Subject: [PATCH 44/66] New addFields API, allow descriptions wildcard in yaml

---
 README.md                                     |  97 ++++++++---
 .../Scaffolders/DataObjectScaffolder.php      | 156 ++++++++++++++----
 .../Scaffolders/SchemaScaffolder.php          |   6 +-
 src/Scaffolding/Util/TypeParser.php           |   2 +-
 tests/ScaffoldingTest.php                     | 118 +++++++++----
 5 files changed, 287 insertions(+), 92 deletions(-)

diff --git a/README.md b/README.md
index eb05619d4..1bffe7f3c 100644
--- a/README.md
+++ b/README.md
@@ -654,6 +654,80 @@ mutation CreatePost($Input: PostCreateInputType!)
 Permission constraints (in this case `canView()` and `canCreate()`) are enforced
 by the operation resovlers.
 
+#### Setting field descriptions
+
+Adding field descriptions is a great way to maintain a well-documented API. To do this,
+use a map of `FieldName: 'Your description'` instead of an enumerated list of field names.
+
+**Via YAML**:
+```yaml
+SilverStripe\GraphQL:
+  schema:
+    scaffolding:
+      types:
+        MyProject\Post:
+          fields:
+            ID: The unique identifier of the post
+            Title: The title of the post
+            Content: The main body of the post (HTML)
+          operations:
+            read: true
+            create: true
+```
+
+**...Or with code**:
+
+```php
+namespace MyProject;
+
+class Post extends DataObject implements ScaffoldingProvider {
+	//...
+    public function provideGraphQLScaffolding(SchemaScaffolder $scaffolder)
+    {
+    	$scaffolder
+    		->type(Post::class)
+	    		->addFields([
+	    			'ID' => 'The unique identidier of the post',
+	    			'Title' => 'The title of the post',
+	    			'Content' => 'The main body of the post (HTML)'
+	    		])
+	    		->operation(SchemaScaffolder::READ)
+	    			->end()
+	    		->operation(SchemaScaffolder::UPDATE)
+	    			->end()
+	    		->end();
+
+    	return $scaffolder;
+	}
+}
+```
+
+#### Wildcarding and whitelisting fields
+
+If you have a type you want to be fairly well exposed, it can be tedious to add each
+field piecemeal. As a shortcut, you can use `addAllFields()` (code) or `fields: *` (yaml). 
+If you have specific fields you want omitted from that list, you can use 
+`addAllFieldsExcept()` (code) or `excludeFields` (yaml).
+
+**Via YAML**:
+```yaml
+SilverStripe\GraphQL:
+  schema:
+    scaffolding:
+      types:
+        MyProject\Post:
+          fields: *
+          excludeFields: [SecretThing]
+```
+
+**... Or with code**:
+```php
+	$scaffolder
+		->type(Post::class)
+			->addAllFieldsExcept(['SecretThing'])
+```
+
+
 #### Adding arguments
 
 You can add arguments to basic crud operations, but keep in mind you'll need to use your own
@@ -1057,29 +1131,6 @@ query {
 }
 ```
 
-
-#### Whitelisting fields in bulk
-
-If you have a type you want to be fairly well exposed, it can be tedious to add each
-field piecemeal. As a shortcut, you can use `addAllFieldsExcept()` (code) or `fieldsExcept` (yaml).
-
-**Via YAML**:
-```yaml
-SilverStripe\GraphQL:
-  schema:
-    scaffolding:
-      types:
-        MyProject\Post:
-          fieldsExcept: [SecretThing]
-```
-
-**... Or with code**:
-```php
-	$scaffolder
-		->type(Post::class)
-			->addAllFieldsExcept(['SecretThing'])
-```
-
 #### Adding arbitrary queries and mutations
 
 Not every operation maps to simple CRUD. For this, you can define custom queries and mutations
diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
index 007c91ea8..f5e3ae422 100644
--- a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -5,6 +5,7 @@
 use Doctrine\Instantiator\Exception\InvalidArgumentException;
 use SilverStripe\ORM\DataObject;
 use SilverStripe\ORM\ArrayList;
+use SilverStripe\View\ArrayData;
 use SilverStripe\ORM\DataObjectInterface;
 use SilverStripe\ORM\FieldType\DBField;
 use SilverStripe\GraphQL\Manager;
@@ -31,7 +32,7 @@ class DataObjectScaffolder implements ManagerMutatorInterface, ScaffolderInterfa
     use Chainable;
 
     /**
-     * @var array
+     * @var ArrayList
      */
     protected $fields;
 
@@ -75,29 +76,41 @@ public function __construct($dataObjectClass)
     }
 
     /**
-     * Adds visible fields.
+     * Adds visible fields, and optional descriptions.
+     *
+     * Ex:
+     * [
+     *    'MyField' => 'Some description',
+     *    'MyOtherField' // No description
+     * ]
      *
      * @param array $fields
      */
-    public function addFields(array $fields)
+    public function addFields(array $fieldData)
     {
-        // Remove duplicates
-        $this->fields = ArrayList::create(array_unique(array_merge(
-            $this->fields->toArray(),
-            $fields
-        )));
+        $fields = [];
+        foreach($fieldData as $k => $data) {
+        	$assoc = !is_numeric($k);
+        	$field = ArrayData::create([
+        		'Name' => $assoc ? $k : $data,
+        		'Description' => $assoc ? $data : null
+        	]);
+        	$this->removeField($field->Name);        	
+        	$this->fields->add($field);        	
+        }
 
         return $this;
     }
 
     /**
      * @param $field
+     * @param  $description
      *
      * @return mixed
      */
-    public function addField($field)
+    public function addField($field, $description = null)
     {
-        return $this->addFields((array) $field);
+        return $this->addFields([$field => $description]);
     }
 
     /**
@@ -140,9 +153,7 @@ public function addAllFieldsExcept($exclusions, $includeHasOne = false)
      */
     public function removeField($field)
     {
-        $this->fields->remove($field);
-
-        return $this;
+        return $this->removeFields([$field]);
     }
 
     /**
@@ -152,9 +163,7 @@ public function removeField($field)
      */
     public function removeFields(array $fields)
     {
-        foreach ($fields as $field) {
-            $this->removeField($field);
-        }
+        $this->fields = $this->fields->exclude('Name', $fields);
 
         return $this;
     }
@@ -183,6 +192,50 @@ public function getNestedQueries()
         return $this->nestedQueries;
     }
 
+    /**
+     * Sets the description to an existing field.
+     * @param string $field
+     * @param string $description
+     */
+    public function setFieldDescription($field, $description)
+    {
+    	$existing = $this->fields->find('Name', $field);
+    	if(!$existing) {
+    		throw new InvalidArgumentException(sprintf(
+    			'Cannot set description of %s. It has not been added to %s.',
+    			$field,
+    			$this->dataObjectClass
+    		));
+    	}
+    	
+    	$this->fields->replace($existing, ArrayData::create([
+    		'Name' => $field,
+    		'Description' => $description
+    	]));
+
+		return $this;
+    }
+
+    /**
+     * Gets the Description property from a field, given a name
+     * @param  string $field
+     * @return string
+     */
+    public function getFieldDescription($field)
+    {
+    	$item = $this->fields->find('Name', $field);
+
+    	if(!$item) {
+    		throw new \Exception(sprintf(
+    			'Tried to get field description for %s, but it has not been added to %s',
+    			$field,
+    			$this->dataObjectClass
+    		));
+    	}
+
+    	return $item->Description;
+    }
+
     /**
      * Removes an operation.
      *
@@ -307,35 +360,54 @@ public function getAncestralClasses()
         return $classes;
     }
 
+    /**
+     * Applies settings from an array, i.e. YAML
+     * @param  array  $config
+     * @return $this
+     */
     public function applyConfig(array $config)
     {
         $dataObjectClass = $this->dataObjectClass;
-        if (empty($config['fields']) && empty($config['fieldsExcept'])) {
+        if (empty($config['fields'])) {
             throw new \Exception(
                 "No array of fields defined for $dataObjectClass"
             );
         }
         if (isset($config['fields'])) {
-            if ($config['fields'] === '*') {
-                $this->addAllFields();
+            if ($config['fields'] === SchemaScaffolder::ALL) {
+                $this->addAllFields(true);
             } elseif (is_array($config['fields'])) {
                 $this->addFields($config['fields']);
             } else {
-                throw new \Exception(
-                    "Fields must be an array, or '*' for all fields in $dataObjectClass"
-                );
+                throw new \Exception(sprintf(
+                    "Fields must be an array, or '%s' for all fields in $dataObjectClass",
+                    SchemaScaffolder::ALL
+                ));
             }
         }
 
-        if (isset($config['fieldsExcept'])) {
-            if (!is_array($config['fieldsExcept'])) {
+        if (isset($config['excludeFields'])) {
+            if (!is_array($config['excludeFields']) || ArrayLib::is_associative($config['excludeFields'])) {
                 throw new InvalidArgumentException(sprintf(
-                    '"fieldsExcept" must be an array. See %s',
+                    '"excludeFields" must be an enumerated list of fields. See %s',
                     $this->dataObjectClass
                 ));
             }
 
-            $this->addAllFieldsExcept($config['fieldsExcept']);
+            $this->removeFields($config['excludeFields']);
+        }
+
+        if (isset($config['fieldDescriptions'])) {
+        	if(!ArrayLib::is_associative($config['fieldDescriptions'])) {
+        		throw new InvalidArgumentException(sprintf(
+        			'"fieldDescripions" must be a map of field name to description. See %s',
+        			$this->dataObjectClass
+        		));
+        	}
+
+        	foreach($config['fieldDescriptions'] as $fieldName => $description) {
+        		$this->setFieldDescription($fieldName, $description);
+        	}
         }
 
         if (isset($config['operations'])) {
@@ -448,7 +520,7 @@ protected function nestedDataObjectClasses()
     {
         $types = [];
         $instance = $this->getDataObjectInstance();
-        $fields = $this->fields->toArray();
+        $fields = $this->fields->column('Name');
 
         foreach ($fields as $fieldName) {
             $result = $instance->obj($fieldName);
@@ -460,6 +532,10 @@ protected function nestedDataObjectClasses()
         return $types;
     }
 
+    /**
+     * Gets the list of class names that are in nested queries
+     * @return array
+     */
     protected function nestedConnections()
     {
         $queries = [];
@@ -472,22 +548,31 @@ protected function nestedConnections()
         return $queries;
     }
 
+    /**
+     * Validates the raw field map and creates a map suitable for ObjectType
+     * @param  Manager $manager [description]
+     * @return array
+     */
     protected function createFields(Manager $manager)
-    {
+    {	
+
         $fieldMap = [];
         $instance = $this->getDataObjectInstance();
         $extraDataObjects = $this->nestedDataObjectClasses();
-        $fields = array_unique($this->fields->toArray());
+        $this->fields->removeDuplicates('Name');
 
-        if (empty($fields)) {
-            $fields = Config::inst()->get(self::class, 'default_fields');
+        if (!$this->fields->exists()) {
+            $this->addFields(
+            	Config::inst()->get(self::class, 'default_fields')
+            );
         }
 
         $resolver = function ($obj, $args, $context, $info) {
             return $obj->obj($info->fieldName);
         };
 
-        foreach ($fields as $fieldName) {
+        foreach ($this->fields as $fieldData) {
+        	$fieldName = $fieldData->Name;
             if (!ScaffoldingUtil::isValidFieldName($instance, $fieldName)) {
                 throw new InvalidArgumentException(sprintf(
                     'Invalid field "%s" on %s',
@@ -511,17 +596,19 @@ protected function createFields(Manager $manager)
                 $typeName = $result->config()->graphql_type;
                 $fieldMap[$fieldName] = (new TypeParser($typeName))->toArray();
                 $fieldMap[$fieldName]['resolve'] = $resolver;
+                $fieldMap[$fieldName]['description'] = $fieldData->Description;
             }
         }
 
         foreach ($extraDataObjects as $fieldName => $className) {
             $result = $instance->obj($fieldName);
             $typeName = ScaffoldingUtil::typeNameForDataObject($className);
-
+            $description = $this->getFieldDescription($fieldName);
             $fieldMap[$fieldName] = [
-                'type' => function () use ($manager, $typeName) {
+                'type' => function () use ($manager, $typeName, $description) {
                     return $manager->getType($typeName);
                 },
+                'description' => $description,
                 'resolve' => $resolver,
             ];
         }
@@ -533,4 +620,5 @@ protected function createFields(Manager $manager)
 
         return $fieldMap;
     }
+
 }
diff --git a/src/Scaffolding/Scaffolders/SchemaScaffolder.php b/src/Scaffolding/Scaffolders/SchemaScaffolder.php
index 383cbf736..102e0dce5 100644
--- a/src/Scaffolding/Scaffolders/SchemaScaffolder.php
+++ b/src/Scaffolding/Scaffolders/SchemaScaffolder.php
@@ -24,6 +24,8 @@ class SchemaScaffolder implements ManagerMutatorInterface
 
     const DELETE = 'delete';
 
+    const ALL = '*';
+
     /**
      * @var array
      */
@@ -256,8 +258,8 @@ public function addToManager(Manager $manager)
                 $ancestorType = $this->type($class);
                 $inst = $ancestorType->getDataObjectInstance();
                 foreach ($exposedFields as $field) {
-                    if (ScaffoldingUtil::isValidFieldName($inst, $field)) {
-                        $ancestorType->addField($field);
+                    if (ScaffoldingUtil::isValidFieldName($inst, $field->Name)) {
+                        $ancestorType->addField($field->Name, $field->Description);
                     }
                 }
                 foreach ($exposedOperations as $op) {
diff --git a/src/Scaffolding/Util/TypeParser.php b/src/Scaffolding/Util/TypeParser.php
index 789978698..9b0fe0356 100644
--- a/src/Scaffolding/Util/TypeParser.php
+++ b/src/Scaffolding/Util/TypeParser.php
@@ -12,7 +12,7 @@ class TypeParser
 {
 
     /**
-     * @var strign
+     * @var string
      */
     protected $rawArg;
 
diff --git a/tests/ScaffoldingTest.php b/tests/ScaffoldingTest.php
index a58eac49f..408b1c953 100644
--- a/tests/ScaffoldingTest.php
+++ b/tests/ScaffoldingTest.php
@@ -65,31 +65,72 @@ public function testDataObjectScaffolderFields()
 		$scaffolder = $this->getFakeScaffolder();
 		
 		$scaffolder->addField('MyField');
-		$this->assertEquals(['MyField'], $scaffolder->getFields()->toArray());
+		$this->assertEquals(['MyField'], $scaffolder->getFields()->column('Name'));
 		
-		$scaffolder->addFields(['MyField','MyInt']);
-		$this->assertEquals(['MyField', 'MyInt'], $scaffolder->getFields()->toArray());
+		$scaffolder->addField('MyField', 'Some description');
+		$this->assertEquals(
+			'Some description',
+			$scaffolder->getFieldDescription('MyField')
+		);
+
+		$scaffolder->addFields([
+			'MyField',
+			'MyInt' => 'Int description'
+		]);
+		
+		$this->assertEquals(['MyField', 'MyInt'], $scaffolder->getFields()->column('Name'));
+		$this->assertNull(
+			$scaffolder->getFieldDescription('MyField')
+		);
+		$this->assertEquals(
+			'Int description',
+			$scaffolder->getFieldDescription('MyInt')
+		);
+
+		$scaffolder->setFieldDescription('MyInt', 'New int description');
+		$this->assertEquals(
+			'New int description',
+			$scaffolder->getFieldDescription('MyInt')
+		);
 
 		$scaffolder = $this->getFakeScaffolder();
 		$scaffolder->addAllFields();
-		$this->assertEquals(['ID','ClassName','LastEdited','Created','MyField','MyInt'], $scaffolder->getFields()->toArray());
+		$this->assertEquals(
+			['ID','ClassName','LastEdited','Created','MyField','MyInt'],
+			$scaffolder->getFields()->column('Name')
+		);
 
 		$scaffolder = $this->getFakeScaffolder();
 		$scaffolder->addAllFields(true);
-		$this->assertEquals(['ID','ClassName','LastEdited','Created','MyField','MyInt', 'Author'], $scaffolder->getFields()->toArray());
+		$this->assertEquals(
+			['ID','ClassName','LastEdited','Created','MyField','MyInt', 'Author'],
+			$scaffolder->getFields()->column('Name')
+		);
 
 		$scaffolder = $this->getFakeScaffolder();
 		$scaffolder->addAllFieldsExcept('MyInt');
-		$this->assertEquals(['ID','ClassName','LastEdited','Created','MyField'], $scaffolder->getFields()->toArray());
+		$this->assertEquals(
+			['ID','ClassName','LastEdited','Created','MyField'],
+			$scaffolder->getFields()->column('Name')
+		);
 
 		$scaffolder = $this->getFakeScaffolder();
 		$scaffolder->addAllFieldsExcept('MyInt', true);
-		$this->assertEquals(['ID','ClassName','LastEdited','Created','MyField','Author'], $scaffolder->getFields()->toArray());
+		$this->assertEquals(
+			['ID','ClassName','LastEdited','Created','MyField','Author'],
+			$scaffolder->getFields()->column('Name')
+		);
 
 		$scaffolder->removeField('ClassName');
-		$this->assertEquals(['ID','LastEdited','Created','MyField','Author'], $scaffolder->getFields()->toArray());
+		$this->assertEquals(
+			['ID','LastEdited','Created','MyField','Author'],
+			$scaffolder->getFields()->column('Name')
+		);
 		$scaffolder->removeFields(['LastEdited','Created']);
-		$this->assertEquals(['ID','MyField','Author'], $scaffolder->getFields()->toArray());
+		$this->assertEquals(
+			['ID','MyField','Author'],
+			$scaffolder->getFields()->column('Name')
+		);
 	}
 
 
@@ -179,16 +220,16 @@ public function testDataObjectScaffolderApplyConfig()
 	{
 		$observer = $this->getMockBuilder(DataObjectScaffolder::class)
 			->setConstructorArgs([DataObjectFake::class])
-			->setMethods(['addFields','addAllFieldsExcept','operation','nestedQuery'])
+			->setMethods(['addFields','removeFields','operation','nestedQuery', 'setFieldDescription'])
 			->getMock();
 
 		$observer->expects($this->once())
 			->method('addFields')
-			->with($this->equalTo(['MyField']));
+			->with($this->equalTo(['ID','MyField','MyInt']));
 
 		$observer->expects($this->once())
-			->method('addAllFieldsExcept')
-			->with($this->equalTo(['MyField']));
+			->method('removeFields')
+			->with($this->equalTo(['ID']));
 
 		$observer->expects($this->exactly(2))
 			->method('operation')
@@ -211,12 +252,21 @@ public function testDataObjectScaffolderApplyConfig()
 					->getMock()
 			));
 
+		$observer->expects($this->once())
+			->method('setFieldDescription')
+			->with(
+				$this->equalTo('MyField'),
+				$this->equalTo('This is myfield')
+			);
 
 		$observer->applyConfig([
-			'fields' => ['MyField'],
-			'fieldsExcept' => ['MyField'],
+			'fields' => ['ID', 'MyField','MyInt'],
+			'excludeFields' => ['ID'],
 			'operations' => ['create' => true,'read' => true],
-			'nestedQueries' => ['Files' => true]
+			'nestedQueries' => ['Files' => true],
+			'fieldDescriptions' => [
+				'MyField' => 'This is myfield'
+			]
 		]);
 
 	}
@@ -256,10 +306,11 @@ public function testDataObjectScaffolderApplyConfigInvalidFieldsExceptException(
 		// Invalid fieldsExcept
 		$this->setExpectedExceptionRegExp(
 			InvalidArgumentException::class,
-			'/"fieldsExcept" must be an array/'
+			'/"excludeFields" must be an enumerated list/'
 		);
 		$scaffolder->applyConfig([
-			'fieldsExcept' => 'fail'
+			'fields' => ['MyField'],
+			'excludeFields' => 'fail'
 		]);
 	}
 
@@ -273,7 +324,7 @@ public function testDataObjectScaffolderApplyConfigInvalidOperationsException()
 			'/Operations field must be a map/'
 		);
 		$scaffolder->applyConfig([
-			'fieldsExcept' => ['MyField'],
+			'fields' => ['MyField'],
 			'operations' => ['create']
 		]);
 	}
@@ -299,8 +350,8 @@ public function testDataObjectScaffolderWildcards()
 	{
 		$scaffolder = $this->getFakeScaffolder();
 		$scaffolder->applyConfig([
-			'fields' => '*',
-			'operations' => '*'
+			'fields' => SchemaScaffolder::ALL,
+			'operations' => SchemaScaffolder::ALL
 		]);
 		$ops = $scaffolder->getOperations();
 
@@ -310,8 +361,8 @@ public function testDataObjectScaffolderWildcards()
 		$this->assertInstanceOf(Update::class, $ops->findByIdentifier(SchemaScaffolder::UPDATE));
 
 		$this->assertEquals(
-			['ID','ClassName','LastEdited','Created','MyField','MyInt'],
-			$scaffolder->getFields()->toArray()
+			['ID','ClassName','LastEdited','Created','MyField','MyInt','Author'],
+			$scaffolder->getFields()->column('Name')
 		);
 	}
 
@@ -460,17 +511,20 @@ public function testSchemaScaffolderAddToManager()
 			File::class
 		], $classNames);
 
-		$this->assertEquals([
-			'Created', 'TestPageField', 'RedirectionType'
-		], $scaffolder->type(RedirectorPage::class)->getFields()->toArray());
+		$this->assertEquals(
+			['Created', 'TestPageField', 'RedirectionType'],
+			$scaffolder->type(RedirectorPage::class)->getFields()->column('Name')
+		);
 
-		$this->assertEquals([
-			'Created', 'TestPageField'
-		], $scaffolder->type(Page::class)->getFields()->toArray());
+		$this->assertEquals(
+			['Created', 'TestPageField'],
+			$scaffolder->type(Page::class)->getFields()->column('Name')
+		);
 
-		$this->assertEquals([
-			'Created'
-		], $scaffolder->type(SiteTree::class)->getFields()->toArray());
+		$this->assertEquals(
+			['Created'],
+			$scaffolder->type(SiteTree::class)->getFields()->column('Name')
+		);
 
 
 		$this->assertEquals('testQuery', $scaffolder->getQueries()->first()->getName());

From 46c19671c4a72415e4b3fc5c1021882f9f5bced0 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Wed, 18 Jan 2017 12:57:12 +1300
Subject: [PATCH 45/66] New argument API. Descriptions/defaults allowed

---
 README.md                                     |  68 +++++-
 .../Scaffolders/ArgumentScaffolder.php        | 144 +++++++++++
 src/Scaffolding/Scaffolders/CRUD/Create.php   |   4 +-
 src/Scaffolding/Scaffolders/CRUD/Update.php   |   6 +-
 .../Scaffolders/DataObjectScaffolder.php      |   3 +-
 .../Scaffolders/OperationScaffolder.php       | 170 ++++++++++++-
 src/Scaffolding/Util/ArgsParser.php           |  55 -----
 src/Scaffolding/Util/TypeParser.php           |  80 +++----
 tests/ScaffoldingTest.php                     | 223 ++++++++++++++----
 9 files changed, 588 insertions(+), 165 deletions(-)
 create mode 100644 src/Scaffolding/Scaffolders/ArgumentScaffolder.php
 delete mode 100644 src/Scaffolding/Util/ArgsParser.php

diff --git a/README.md b/README.md
index 1bffe7f3c..3277c05ce 100644
--- a/README.md
+++ b/README.md
@@ -791,9 +791,71 @@ query {
 }
 ```
 
-> Argument definitions are expressed using a shorthand. Append `!` to the argument type to
-make it required, and `=SomeValue` to set it to a default value, e.g. `'Category' => 'String!'` or
-`'Answer' => 'Int=42'`.
+#### Argument definition shorthand
+
+You can make your scaffolding delcaration a bit more expressive by using argument shorthand.
+* `String!`: A required string
+* `Int!(50)`: A required integer with a default value of 50
+* `Boolean(0)`: A boolean defaulting to false
+* `String`: An optional string, defaulting to null
+
+#### Adding more definition to arguments
+
+To add descriptions, and to use a more granular level of control over your arguments,
+you can use a more long-form syntax.
+
+**Via YAML**
+```yaml
+SilverStripe\GraphQL:
+  schema:
+    scaffolding:
+      types:
+        MyProject\Post:
+          fields: [ID, Title, Content]
+          operations:
+            read:
+              args:
+                Title: String!
+                MinimumCommentCount:
+                  type: Int
+                  default: 5
+                  description: 'Use this parameter to specify the mimimum number of comments per post'
+              resolver: MyProject\ReadPostResolver
+            create: true
+```
+
+**... Or with code**
+```php
+	$scaffolder
+		->type(Post::class)
+    		->addFields(['ID','Title','Content'])
+    		->operation(SchemaScaffolder::READ)
+    			->addArgs([
+    				'Title' => 'String!',
+    				'MinimumCommentCount' => 'Int'
+    			])
+    			->setArgDefaults([
+    				'MinimumCommentCount' => 5
+    			])
+    			->setArgDescriptions([
+    				'MinimumCommentCount' => 'Use this parameter to specify the mimimum number of comments per post'
+    			])
+        		->setResolver(function($obj, $args, $context) {
+        			if(!singleton(Post::class)->canView($context['currentMember'])) {
+        				throw new \Exception('Cannot view Post');
+        			}
+        			$list = Post::get();
+        			if(isset($args['Title'])) {
+        				$list = $list->filter('Title:PartialMatch', $args['Title']);
+        			}
+
+        			return $list;
+        		})         	
+    			->end()
+    		->operation(SchemaScaffolder::UPDATE)
+    			->end()
+    		->end();
+```
 
 #### Using a custom resolver
 
diff --git a/src/Scaffolding/Scaffolders/ArgumentScaffolder.php b/src/Scaffolding/Scaffolders/ArgumentScaffolder.php
new file mode 100644
index 000000000..53867e62b
--- /dev/null
+++ b/src/Scaffolding/Scaffolders/ArgumentScaffolder.php
@@ -0,0 +1,144 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Scaffolders;
+
+use GraphQL\Type\Definition\Type;
+use Doctrine\Instantiator\Exception\InvalidArgumentException;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\Configurable;
+use SilverStripe\GraphQL\Scaffolding\Util\TypeParser;
+use Exception;
+
+class ArgumentScaffolder implements Configurable
+{
+
+	/**
+	 * @var string
+	 */
+	public $argName;
+
+	/**	 
+	 * @var string
+	 */
+	protected $description;
+
+	/**
+	 * @var GraphQL\Definition\Type\Type;
+	 */
+	protected $type;
+
+	/**
+	 * @var scalar
+	 */
+	protected $defaultValue;
+
+	/**
+	 * @var  boolean
+	 */
+	protected $required;
+
+	/**
+	 * ArgumentScaffolder constructor
+	 * @param string $argName      Name of the argument
+	 * @param strint $typeStr      A string describing the type (see TypeParser)
+	 */
+	public function __construct($argName, $typeStr)
+	{
+		$this->argName = $argName;
+		
+		$parser = new TypeParser($typeStr);
+		$this->defaultValue = $parser->getDefaultValue();
+		$this->type = $parser->getType();
+		$this->required = $parser->isRequired();
+	}
+
+	/**
+	 * Sets the argument as required
+	 * @param boolean $bool
+	 */
+	public function setRequired($bool)
+	{
+		$this->required = (boolean) $bool;
+
+		return $this;
+	}
+
+	/**
+	 * Sets the argument description
+	 * @param string $description 
+	 */
+	public function setDescription($description)
+	{
+		$this->description = $description;
+
+		return $this;
+	}
+
+	/**
+	 * Sets the default value of the argument
+	 * @param mixed $value
+	 */
+	public function setDefaultValue($value)
+	{
+		$this->defaultValue = $value;
+
+		return $this;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getDescription()
+	{
+		return $this->description;
+	}
+
+	/**
+	 * @return scalar
+	 */
+	public function getDefaultValue()
+	{
+		return $this->defaultValue;
+	}
+
+	/**
+	 * @return boolean
+	 */
+	public function isRequired()
+	{
+		return $this->required;
+	}
+
+	/**
+	 * Applies an array of configuration to the scaffolder
+	 * @param  array  $config 
+	 * @return void
+	 */
+	public function applyConfig(array $config)
+	{
+		if(isset($config['description'])) {
+			$this->description = $config['description'];
+		}
+
+		if(isset($config['default'])) {
+			$this->defaultValue = $config['default'];
+		}
+
+		if(isset($config['required'])) {
+			$this->required = (boolean) $config['required'];
+		}
+	}
+
+	/**
+	 * Creates an array suitable for a map of args in a field
+	 * @return array
+	 */
+	public function toArray()
+	{
+		return [
+			'description' => $this->description,
+			'type' => $this->required ? Type::nonNull($this->type) : $this->type,
+			'defaultValue' => $this->defaultValue
+		];
+	}
+
+}
\ No newline at end of file
diff --git a/src/Scaffolding/Scaffolders/CRUD/Create.php b/src/Scaffolding/Scaffolders/CRUD/Create.php
index de80aba58..e3dd2b6a3 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Create.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Create.php
@@ -90,7 +90,9 @@ protected function generateInputType()
         foreach ($db as $dbFieldName => $dbFieldType) {
             $result = $instance->obj($dbFieldName);
             $typeName = $result->config()->graphql_type;
-            $arr = (new TypeParser($typeName))->toArray();
+            $arr = [
+            	'type' => (new TypeParser($typeName))->getType()
+            ];
             $arr['name'] = $dbFieldName;
             $fields[] = $arr;
         }
diff --git a/src/Scaffolding/Scaffolders/CRUD/Update.php b/src/Scaffolding/Scaffolders/CRUD/Update.php
index 9dbf288fb..e1c138756 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Update.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Update.php
@@ -77,7 +77,7 @@ public function getIdentifier()
     protected function createArgs()
     {
         return [
-            'ID' => (new TypeParser('ID!'))->toArray(),
+            'ID' => Type::nonNull(Type::id()),
             'Input' => [
                 'type' => Type::nonNull($this->generateInputType()),
             ],
@@ -106,7 +106,9 @@ protected function generateInputType()
         foreach ($db as $dbFieldName => $dbFieldType) {
             $result = $instance->obj($dbFieldName);
             $typeName = $result->config()->graphql_type;
-            $arr = (new TypeParser($typeName))->toArray();
+            $arr = [
+            	'type' => (new TypeParser($typeName))->getType()
+            ];
             $arr['name'] = $dbFieldName;
             $fields[] = $arr;
         }
diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
index f5e3ae422..34cb8a051 100644
--- a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -594,7 +594,8 @@ protected function createFields(Manager $manager)
 
             if ($result instanceof DBField) {
                 $typeName = $result->config()->graphql_type;
-                $fieldMap[$fieldName] = (new TypeParser($typeName))->toArray();
+                $fieldMap[$fieldName] = [];
+                $fieldMap[$fieldName]['type'] = (new TypeParser($typeName))->getType();
                 $fieldMap[$fieldName]['resolve'] = $resolver;
                 $fieldMap[$fieldName]['description'] = $fieldData->Description;
             }
diff --git a/src/Scaffolding/Scaffolders/OperationScaffolder.php b/src/Scaffolding/Scaffolders/OperationScaffolder.php
index 6b5f7ed01..19c816fa4 100644
--- a/src/Scaffolding/Scaffolders/OperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/OperationScaffolder.php
@@ -12,6 +12,9 @@
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\CRUD\Update;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\CRUD\Delete;
 use SilverStripe\GraphQL\Scaffolding\Interfaces\Configurable;
+use SilverStripe\ORM\ArrayList;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\ArgumentScaffolder;
+use Exception;
 
 /**
  * Provides functionality common to both operation scaffolders. Cannot
@@ -70,6 +73,7 @@ public function __construct($operationName, $typeName, $resolver = null)
     {
         $this->operationName = $operationName;
         $this->typeName = $typeName;
+        $this->args = ArrayList::create([]);
 
         if ($resolver) {
             $this->setResolver($resolver);
@@ -77,24 +81,114 @@ public function __construct($operationName, $typeName, $resolver = null)
     }
 
     /**
-     * Adds arguments to the mutation. e.g.
+     * Adds visible fields, and optional descriptions.
+     *
+     * Ex:
      * [
-     *    'Email' => 'String!', // required
-     *    'Limit' => 'Int=10', // optional, default value of 10
-     *    'Featured' => 'Boolean'
-     * ].
+     *    'MyField' => 'Some description',
+     *    'MyOtherField' // No description
+     * ]
      *
-     * @param array $args
+     * @param array $fields
+     */
+    public function addArgs(array $argData)
+    {
+        $args = [];
+        foreach($argData as $argName => $typeStr) {
+        	$this->removeArg($argName);
+        	$this->args->add(new ArgumentScaffolder($argName, $typeStr));
+        }
+
+        return $this;
+    }
+
+    /**
+     * @param $field
+     * @param  $description
      *
-     * @return $this
+     * @return mixed
      */
-    public function addArgs($args = [])
+    public function addArg($argName, $typeStr, $description = null, $defaultValue = null)
     {
-        $this->args = array_merge($this->args, $args);
+        $this->addArgs([$argName => $typeStr]);
+        $this->setArgDescription($argName, $description);
+        $this->setArgDefault($argName, $defaultValue);
 
         return $this;
     }
 
+    /**
+     * Sets descriptions of arguments
+     * [
+     * 	'Email' => 'The email of the user'
+     * ]
+     * @param array $argData 
+     * @return  $this
+     */
+    public function setArgDescriptions(array $argData)
+    {
+    	foreach($argData as $argName => $description) {
+    		$arg = $this->args->find('argName', $argName);
+    		if(!$arg) {
+    			throw new InvalidArgumentException(sprintf(
+    				'Tried to set description for %s, but it was not added to %s',
+    				$argName,
+    				$this->operationName
+    			));
+    		}
+
+    		$arg->setDescription($description);
+    	}
+
+    	return $this;
+    }
+
+    /**
+     * Sets a single arg description
+     * @param string $argName     
+     * @param string $description 
+     */
+    public function setArgDescription($argName, $description)
+    {
+    	return $this->setArgDescriptions([$argName => $description]);
+    }
+
+    /**
+     * Sets argument defaults
+     * [
+     * 	'Featured' => true
+     * ]
+     * @param array $argData
+     * @return  $this
+     */
+    public function setArgDefaults(array $argData)
+    {
+    	foreach($argData as $argName => $default) {
+    		$arg = $this->args->find('argName', $argName);
+    		if(!$arg) {
+    			throw new InvalidArgumentException(sprintf(
+    				'Tried to set default for %s, but it was not added to %s',
+    				$argName,
+    				$this->operationName
+    			));
+    		}
+
+    		$arg->setDefaultValue($default);
+    	}
+
+    	return $this;    	
+    }
+
+    /**
+     * Sets a default for a single arg
+     * @param string $argName 
+     * @param mixed $default 
+     */
+    public function setArgDefault($argName, $default)
+    {
+    	return $this->setArgDefaults([$argName => $default]);
+    }
+
     /**
      * @return string
      */
@@ -111,6 +205,28 @@ public function getArgs()
         return $this->args;
     }
 
+    /**
+     * @param $arg
+     *
+     * @return $this
+     */
+    public function removeArg($arg)
+    {
+        return $this->removeArgs([$arg]);
+    }
+
+    /**
+     * @param array $fields
+     *
+     * @return $this
+     */
+    public function removeArgs(array $args)
+    {
+        $this->args = $this->args->exclude('argName', $args);
+
+        return $this;
+    }
+
     /**
      * @param $resolver
      *
@@ -145,7 +261,34 @@ public function setResolver($resolver)
     public function applyConfig(array $config)
     {
         if (isset($config['args'])) {
-            $this->addArgs($config['args']);
+        	if(!is_array($config['args'])) {
+        		throw new Exception(sprintf(
+        			'args must be an array on %s',
+        			$this->operationName
+        		));
+        	}
+        	foreach($config['args'] as $argName => $argData) {
+        		if(is_array($argData)) {
+					if(!isset($argData['type'])) {
+						throw new Exception(sprintf(
+							'Argument %s must have a type',
+							$argName
+						));
+					}
+
+        			$scaffolder = new ArgumentScaffolder($argName, $argData['type']);
+        			$scaffolder->applyConfig($argData);
+        			$this->removeArg($argName);
+        			$this->args->add($scaffolder);
+        		} else if(is_string($argData)) {
+        			$this->addArg($argName, $argData);
+        		} else {
+        			throw new Exception(sprintf(
+        				'Arg %s should be mapped to a string or an array',
+        				$argName
+        			));
+        		}
+        	}            
         }
         if (isset($config['resolver'])) {
             $this->setResolver($config['resolver']);
@@ -188,6 +331,11 @@ protected function createResolverFunction()
      */
     protected function createArgs()
     {
-        return (new ArgsParser($this->args))->toArray();
+        $args = [];
+        foreach($this->args as $scaffolder) {
+        	$args[$scaffolder->argName] = $scaffolder->toArray();
+        }
+
+        return $args;
     }
 }
diff --git a/src/Scaffolding/Util/ArgsParser.php b/src/Scaffolding/Util/ArgsParser.php
deleted file mode 100644
index eaff8b8d4..000000000
--- a/src/Scaffolding/Util/ArgsParser.php
+++ /dev/null
@@ -1,55 +0,0 @@
-<?php
-
-namespace SilverStripe\GraphQL\Scaffolding\Util;
-
-use Doctrine\Instantiator\Exception\InvalidArgumentException;
-use GraphQL\Type\Definition\Type;
-
-/**
- * Parses an array of args into the proper graphql-php spec, using first-class type objects in lieu of strings
- */
-class ArgsParser
-{
-
-    /**
-     * @var array
-     */
-    protected $args = [];
-
-    /**
-     * ArgsParser constructor.
-     * @param array $args
-     */
-    public function __construct(array $args)
-    {
-        $this->args = $args;
-    }
-
-    /**
-     * Gets the array of args suitable for a field creator
-     * @return array
-     */
-    public function toArray()
-    {
-        $args = [];
-        foreach ($this->args as $argName => $type) {
-            if (is_string($type)) {
-                $args[$argName] = (new TypeParser($type))->toArray();
-            } else {
-                if ($type instanceof Type) {
-                    $args[$argName] = ['type' => $type];
-                } else {
-                    if (is_array($type)) {
-                        $args[$argName] = $type;
-                    } else {
-                        throw new InvalidArgumentException(
-                            "Invalid argument type provided for $argName"
-                        );
-                    }
-                }
-            }
-        }
-
-        return $args;
-    }
-}
diff --git a/src/Scaffolding/Util/TypeParser.php b/src/Scaffolding/Util/TypeParser.php
index 9b0fe0356..1315a4151 100644
--- a/src/Scaffolding/Util/TypeParser.php
+++ b/src/Scaffolding/Util/TypeParser.php
@@ -6,7 +6,7 @@
 use Doctrine\Instantiator\Exception\InvalidArgumentException;
 
 /**
- * Parses a type, e.g. String!=20 into an array defining the arg type
+ * Parses a type, e.g. Int!(20) into an array defining the arg type
  */
 class TypeParser
 {
@@ -19,7 +19,7 @@ class TypeParser
     /**
      * @var string
      */
-    protected $argType;
+    protected $typeStr;
 
     /**
      * @var bool
@@ -30,21 +30,21 @@ class TypeParser
      * @var null
      */
     protected $defaultValue = null;
-
+    
     /**
      * TypeParser constructor.
      * @param $rawArg
      */
     public function __construct($rawArg)
     {
-        if (!preg_match('/^([A-Za-z]+)(!?)(?:\s*=\s*(.*))?/', $rawArg, $matches)) {
+        if (!preg_match('/^([A-Za-z]+)(!?)(?:\s*\(\s*(.*)\))?/', $rawArg, $matches)) {
             throw new InvalidArgumentException(
                 "Invalid argument: $rawArg"
             );
         }
 
         $this->rawArg = $rawArg;
-        $this->argType = $matches[1];
+        $this->typeStr = $matches[1];
         $this->required = isset($matches[2]) && $matches[2] == '!';
         if (isset($matches[3])) {
             $this->defaultValue = $matches[3];
@@ -65,7 +65,7 @@ public function isRequired()
      */
     public function getArgTypeName()
     {
-        return $this->argType;
+        return $this->typeStr;
     }
 
     /**
@@ -73,51 +73,43 @@ public function getArgTypeName()
      */
     public function getDefaultValue()
     {
-        return $this->defaultValue;
+        if($this->defaultValue === null) {
+        	return null;
+        }
+        
+        switch ($this->typeStr) {
+            case Type::ID:                
+                return (int) $this->defaultValue;                
+            case Type::STRING:
+                return (string) $this->defaultValue;                
+            case Type::BOOLEAN:                
+                return (boolean) $this->defaultValue;                
+            case Type::INT:                
+                return (int) $this->defaultValue;                
+            case Type::FLOAT:                
+                return (float) $this->defaultValue;               
+        }
+
+        throw new InvalidArgumentException(sprintf(
+        	'Invalid type %s',
+        	$this->typeStr
+        ));
     }
 
-    /**
-     * @return array
-     */
-    public function toArray()
+    public function getType()
     {
-        $type = null;
-        $defaultValue = null;
-        switch ($this->argType) {
+        switch ($this->typeStr) {
             case Type::ID:
-                $type = Type::id();
-                $defaultValue = (int) $this->defaultValue;
-                break;
+                return Type::id();
             case Type::STRING:
-                $type = Type::string();
-                $defaultValue = (string) $this->defaultValue;
-                break;
+                return Type::string();
             case Type::BOOLEAN:
-                $type = Type::boolean();
-                $defaultValue = (boolean) $this->defaultValue;
-                break;
+                return Type::boolean();
             case Type::INT:
-                $type = Type::int();
-                $defaultValue = (int) $this->defaultValue;
-                break;
+                return Type::int();
             case Type::FLOAT:
-                $type = Type::float();
-                $defaultValue = (float) $this->defaultValue;
-                break;
-
-        }
-
-        if ($this->required) {
-            $type = Type::nonNull($type);
-        }
-
-        if (!$type) {
-            throw new InvalidArgumentException("Invalid GraphQL type: $this->argType");
-        }
-
-        return [
-            'type' => $type,
-            'defaultValue' => $defaultValue
-        ];
+                return Type::float();
+        }    	
     }
+
 }
diff --git a/tests/ScaffoldingTest.php b/tests/ScaffoldingTest.php
index 408b1c953..2184875b8 100644
--- a/tests/ScaffoldingTest.php
+++ b/tests/ScaffoldingTest.php
@@ -11,6 +11,7 @@
 use Doctrine\Instantiator\Exception\InvalidArgumentException;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\OperationScaffolder;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\ArgumentScaffolder;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\QueryScaffolder;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\MutationScaffolder;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\CRUD\Create;
@@ -657,11 +658,74 @@ public function testOperationScaffolderArgs()
 			'One' => 'String',
 			'Two' => 'Boolean'
 		]);
-		$scaffolder->addArgs([
-			'One' => 'String'
+		$scaffolder->addArg(
+			'One', 'String', 'One description', 'One default'
+		);
+
+		$this->assertEquals([], array_diff(
+			$scaffolder->getArgs()->column('argName'),
+			['One','Two']
+		));
+
+		$argument = $scaffolder->getArgs()->find('argName', 'One');
+		$this->assertInstanceOf(ArgumentScaffolder::class, $argument);
+		$arr = $argument->toArray();
+		$this->assertEquals('One description', $arr['description']);
+		$this->assertEquals('One default', $arr['defaultValue']);
+
+		$scaffolder->setArgDescriptions([
+			'One' => 'Foo',
+			'Two' => 'Bar'
 		]);
 
-		$this->assertEquals(['One','Two'], array_keys($scaffolder->getArgs()));
+		$scaffolder->setArgDefaults([
+			'One' => 'Feijoa',
+			'Two' => 'Kiwifruit'
+		]);
+
+		$argument = $scaffolder->getArgs()->find('argName', 'One');
+		$arr = $argument->toArray();
+		$this->assertEquals('Foo', $arr['description']);
+		$this->assertEquals('Feijoa', $arr['defaultValue']);
+
+		$argument = $scaffolder->getArgs()->find('argName', 'Two');
+		$arr = $argument->toArray();
+		$this->assertEquals('Bar', $arr['description']);
+		$this->assertEquals('Kiwifruit', $arr['defaultValue']);
+
+		$scaffolder->setArgDescription('One', 'Tui')
+			->setArgDefault('One', 'Moa');
+
+		$argument = $scaffolder->getArgs()->find('argName', 'One');
+		$arr = $argument->toArray();
+		$this->assertEquals('Tui', $arr['description']);
+		$this->assertEquals('Moa', $arr['defaultValue']);
+
+		$scaffolder->removeArg('One');
+		$this->assertEquals(['Two'], $scaffolder->getArgs()->column('argName'));
+		$scaffolder->addArg('Test', 'String');
+		$scaffolder->removeArgs(['Two','Test']);
+		$this->assertFalse($scaffolder->getArgs()->exists());
+
+		$ex = null;
+		try {
+			$scaffolder->setArgDescription('Nothing', 'Test');
+		} catch (Exception $e) {
+			$ex = $e;
+		}
+
+		$this->assertInstanceOf(InvalidArgumentException::class, $ex);
+		$this->assertRegExp('/Tried to set description/', $ex->getMessage());
+
+		$ex = null;
+		try {
+			$scaffolder->setArgDefault('Nothing', 'Test');
+		} catch (Exception $e) {
+			$ex = $e;
+		}
+
+		$this->assertInstanceOf(InvalidArgumentException::class, $ex);
+		$this->assertRegExp('/Tried to set default/', $ex->getMessage());
 	}
 
 	public function testOperationScaffolderResolver()
@@ -690,21 +754,101 @@ public function testOperationScaffolderAppliesConfig()
 	{
 		$scaffolder = new OperationScaffolderFake('testOperation','testType');
 		
+		
+		$scaffolder->applyConfig([
+			'args' => [
+				'One' => 'String',
+				'Two' => [
+					'type' => 'String',
+					'default' => 'Foo',
+					'description' => 'Bar'
+				]
+			],
+			'resolver' => FakeResolver::class
+		]);
+
+		$this->assertEquals([], array_diff(
+			$scaffolder->getArgs()->column('argName'),
+			['One','Two']
+		));
+
+		$arg = $scaffolder->getArgs()->find('argName', 'Two');
+		$this->assertInstanceof(ArgumentScaffolder::class, $arg);
+		$arr = $arg->toArray();
+		$this->assertInstanceOf(StringType::class, $arr['type']);
+
+		$ex = null;
+		try {
+			$scaffolder->applyConfig([
+				'args' => 'fail'
+			]);
+		} catch (Exception $e) {
+			$ex = $e;
+		}
+
+		$this->assertInstanceof(Exception::class, $e);
+		$this->assertRegExp('/args must be an array/', $e->getMessage());
+
+		$ex = null;
 		try {
 			$scaffolder->applyConfig([
 				'args' => [
-					'One' => 'String',
-					'Two' => 'Boolean'
-				],
-				'resolver' => FakeResolver::class
+					'One' => [					
+						'default' => 'Foo',
+						'description' => 'Bar'
+					]
+				]
 			]);
-			$success = true;
 		} catch (Exception $e) {
-			$success = false;
+			$ex = $e;
 		}
 
-		$this->assertTrue($success);
-		$this->assertEquals(['One','Two'], array_keys($scaffolder->getArgs()));
+		$this->assertInstanceof(Exception::class, $e);
+		$this->assertRegExp('/must have a type/', $e->getMessage());
+
+		$ex = null;
+		try {
+			$scaffolder->applyConfig([
+				'args' => [
+					'One' => false
+				]
+			]);
+		} catch (Exception $e) {
+			$ex = $e;
+		}
+
+		$this->assertInstanceof(Exception::class, $e);
+		$this->assertRegExp('/should be mapped to a string or an array/', $e->getMessage());
+
+	}
+
+	public function testArgumentScaffolder()
+	{
+		$scaffolder = new ArgumentScaffolder('Test', 'String');
+		$scaffolder->setRequired(false)
+			->setDescription('Description')
+			->setDefaultValue('Default');
+
+		$this->assertEquals('Description', $scaffolder->getDescription());
+		$this->assertEquals('Default', $scaffolder->getDefaultValue());
+		$this->assertFalse($scaffolder->isRequired());
+
+		$scaffolder->applyConfig([
+			'description' => 'Foo',
+			'default' => 'Bar',
+			'required' => true
+		]);
+
+		$this->assertEquals('Foo', $scaffolder->getDescription());
+		$this->assertEquals('Bar', $scaffolder->getDefaultValue());
+		$this->assertTrue($scaffolder->isRequired());
+
+		$arr = $scaffolder->toArray();
+
+		$this->assertEquals('Foo', $arr['description']);
+		$this->assertEquals('Bar', $arr['defaultValue']);
+		$this->assertInstanceOf(NonNull::class, $arr['type']);
+		$this->assertInstanceOf(StringType::class, $arr['type']->getWrappedType());
 	}
 
 	public function testMutationScaffolder()
@@ -1046,13 +1190,13 @@ public function testReadOperationResolver()
 
     public function testTypeParser()
     {
-        $parser = new TypeParser('String!=Test');
+        $parser = new TypeParser('String!(Test)');
         $this->assertTrue($parser->isRequired());
         $this->assertEquals('String', $parser->getArgTypeName());
         $this->assertEquals('Test', $parser->getDefaultValue());
-        $this->assertTrue(is_string($parser->toArray()['defaultValue']));
+        $this->assertTrue(is_string($parser->getDefaultValue()));
 
-        $parser = new TypeParser('String! = Test');
+        $parser = new TypeParser('String! (Test)');
         $this->assertTrue($parser->isRequired());
         $this->assertEquals('String', $parser->getArgTypeName());
         $this->assertEquals('Test', $parser->getDefaultValue());
@@ -1062,59 +1206,42 @@ public function testTypeParser()
         $this->assertEquals('Int', $parser->getArgTypeName());
         $this->assertNull($parser->getDefaultValue());
 
-        $parser = new TypeParser('Int!=23');
+        $parser = new TypeParser('Int!(23)');
         $this->assertTrue($parser->isRequired());
         $this->assertEquals('Int', $parser->getArgTypeName());
         $this->assertEquals('23', $parser->getDefaultValue());
-		$this->assertTrue(is_int($parser->toArray()['defaultValue']));
+		$this->assertTrue(is_int($parser->getDefaultValue()));
 
         $parser = new TypeParser('Boolean');
         $this->assertFalse($parser->isRequired());
         $this->assertEquals('Boolean', $parser->getArgTypeName());
         $this->assertNull($parser->getDefaultValue());
 
-        $parser = new TypeParser('Boolean=1');
+        $parser = new TypeParser('Boolean(1)');
         $this->assertFalse($parser->isRequired());
         $this->assertEquals('Boolean', $parser->getArgTypeName());
         $this->assertEquals('1', $parser->getDefaultValue());
-		$this->assertTrue(is_bool($parser->toArray()['defaultValue']));
+		$this->assertTrue(is_bool($parser->getDefaultValue()));
 
-        $parser = new TypeParser('String!=Test');
-        $arr = $parser->toArray();
-        $this->assertInstanceOf(NonNull::class, $arr['type']);
-        $this->assertInstanceOf(StringType::class, $arr['type']->getWrappedType());
-        $this->assertEquals('Test', $arr['defaultValue']);
+        $parser = new TypeParser('String!(Test)');        
+        $this->assertInstanceOf(StringType::class, $parser->getType());
+        $this->assertEquals('Test', $parser->getDefaultValue());
 
-        $this->setExpectedException(InvalidArgumentException::class);
+        $this->setExpectedExceptionRegExp(
+        	InvalidArgumentException::class,
+        	'/Invalid argument/'
+        );
+        
         $parser = new TypeParser('  ... Nothing');
 
-        $this->setExpectedException(InvalidArgumentException::class);
-        $parser = (new TypeParser('Nothing'))->toArray();
-    }
+        $this->setExpectedExceptionRegExp(
+        	InvalidArgumentException::class,
+        	'/Invalid type/'
+        );
 
-    public function testArgsParser()
-    {
-        $parsers = [
-            new ArgsParser([
-                'Test' => 'String'
-            ]),
-            new ArgsParser([
-                'Test' => Type::string()
-            ]),
-            new ArgsParser([
-                'Test' => ['type' => Type::string()]
-            ])
-        ];
-
-        foreach ($parsers as $parser) {
-            $arr = $parser->toArray();
-            $this->assertArrayHasKey('Test', $arr);
-            $this->assertArrayHasKey('type', $arr['Test']);
-            $this->assertInstanceOf(StringType::class, $arr['Test']['type']);
-        }
+        $parser = (new TypeParser('Nothing'))->toArray();
     }
 
-
     public function testOperationList()
     {
         $list = new OperationList();

From 36302fe02e5537f14325e9e85456e7fdc8ac261d Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Fri, 20 Jan 2017 14:10:12 +1300
Subject: [PATCH 46/66] Update example code

---
 examples/code/Comment.php                     | 4 ++--
 examples/code/CommentsResolver.php            | 2 +-
 examples/code/CreateMemberMutationCreator.php | 2 +-
 examples/code/LatestPostResolver.php          | 2 +-
 examples/code/Post.php                        | 8 ++++----
 examples/code/ReadResolver.php                | 6 +++---
 examples/code/UpdatePostResolver.php          | 2 +-
 7 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/examples/code/Comment.php b/examples/code/Comment.php
index 83f045c3f..562ee4820 100644
--- a/examples/code/Comment.php
+++ b/examples/code/Comment.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace MyProject\GraphQL;
+namespace MyProject;
 
 use SilverStripe\ORM\DataObject;
 
@@ -12,7 +12,7 @@ class Comment extends DataObject
 	];
 
 	private static $has_one = [
-		'Post' => 'MyProject\GraphQL\Post'
+		'Post' => Post::class
 	];
 
 	public function canView($member = null, $context = []) { return true; }
diff --git a/examples/code/CommentsResolver.php b/examples/code/CommentsResolver.php
index e8ba64455..9856e27c2 100644
--- a/examples/code/CommentsResolver.php
+++ b/examples/code/CommentsResolver.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace MyProject\GraphQL;
+namespace MyProject;
 
 use SilverStripe\GraphQL\Scaffolding\Interfaces\ResolverInterface;
 
diff --git a/examples/code/CreateMemberMutationCreator.php b/examples/code/CreateMemberMutationCreator.php
index e89ce88f7..89ade1540 100644
--- a/examples/code/CreateMemberMutationCreator.php
+++ b/examples/code/CreateMemberMutationCreator.php
@@ -1,5 +1,5 @@
 <?php
-namespace MyProject\GraphQL;
+namespace MyProject;
 
 use GraphQL\Type\Definition\ResolveInfo;
 use GraphQL\Type\Definition\Type;
diff --git a/examples/code/LatestPostResolver.php b/examples/code/LatestPostResolver.php
index b7d0f058c..0a5efc285 100644
--- a/examples/code/LatestPostResolver.php
+++ b/examples/code/LatestPostResolver.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace MyProject\GraphQL;
+namespace MyProject;
 
 use SilverStripe\GraphQL\Scaffolding\Interfaces\ResolverInterface;
 
diff --git a/examples/code/Post.php b/examples/code/Post.php
index ebf50b6c3..52af36b9d 100644
--- a/examples/code/Post.php
+++ b/examples/code/Post.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace MyProject\GraphQL;
+namespace MyProject;
 
 use SilverStripe\ORM\DataObject;
 use SilverStripe\GraphQL\Scaffolding\Interfaces\ScaffoldingProvider;
@@ -18,15 +18,15 @@ class Post extends DataObject implements ScaffoldingProvider {
 	];
 
 	private static $has_one = [
-		'Author' => 'SilverStripe\Security\Member'
+		'Author' => Member::class
 	];
 
 	private static $many_many = [
-		'Files' => 'SilverStripe\Assets\File'
+		'Files' => File::class
 	];
 
 	private static $has_many = [
-		'Comments' => 'MyProject\GraphQL\Comment'
+		'Comments' => Comment::class
 	];
 
 	public function provideGraphQLScaffolding(GraphQLScaffolder $scaffolder)
diff --git a/examples/code/ReadResolver.php b/examples/code/ReadResolver.php
index c31b2ac40..e49a8faff 100644
--- a/examples/code/ReadResolver.php
+++ b/examples/code/ReadResolver.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace MyProject\GraphQL;
+namespace MyProject;
 
 use SilverStripe\GraphQL\Scaffolding\Interfaces\ResolverInterface;
 
@@ -10,8 +10,8 @@ public function resolve($object, $args, $context, $info)
     {
 		$list = Post::get();
 		
-		if(isset($args['StartingWith'])) {
-			$list = $list->filter('Title:StartsWith', $args['StartingWith']);
+		if(isset($args['Title'])) {
+			$list = $list->filter('Title:PartialMatch', $args['Title']);
 		}
 
 		return $list;
diff --git a/examples/code/UpdatePostResolver.php b/examples/code/UpdatePostResolver.php
index 4f14b456a..eea5ace04 100644
--- a/examples/code/UpdatePostResolver.php
+++ b/examples/code/UpdatePostResolver.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace MyProject\GraphQL;
+namespace MyProject;
 
 use SilverStripe\GraphQL\Scaffolding\Interfaces\ResolverInterface;
 

From f49759c0986274e1fdea5bf10ae12d6e039f402b Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Fri, 20 Jan 2017 14:35:41 +1300
Subject: [PATCH 47/66] BUGFIX: incorrect array shape for CRUD args

---
 src/Scaffolding/Scaffolders/CRUD/Update.php | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/Scaffolding/Scaffolders/CRUD/Update.php b/src/Scaffolding/Scaffolders/CRUD/Update.php
index e1c138756..38953dae6 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Update.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Update.php
@@ -77,7 +77,9 @@ public function getIdentifier()
     protected function createArgs()
     {
         return [
-            'ID' => Type::nonNull(Type::id()),
+            'ID' => [
+            	'type' => Type::nonNull(Type::id())
+            ],
             'Input' => [
                 'type' => Type::nonNull($this->generateInputType()),
             ],

From aeed6c72c20847dfa01de7a3d6f164cfb9e37508 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Fri, 20 Jan 2017 15:56:48 +1300
Subject: [PATCH 48/66] BUGFIX: Malformed input type fields

---
 src/Scaffolding/Scaffolders/CRUD/Create.php | 3 +--
 src/Scaffolding/Scaffolders/CRUD/Update.php | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/Scaffolding/Scaffolders/CRUD/Create.php b/src/Scaffolding/Scaffolders/CRUD/Create.php
index e3dd2b6a3..a5a8639c1 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Create.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Create.php
@@ -93,8 +93,7 @@ protected function generateInputType()
             $arr = [
             	'type' => (new TypeParser($typeName))->getType()
             ];
-            $arr['name'] = $dbFieldName;
-            $fields[] = $arr;
+            $fields[$dbFieldName] = $arr;
         }
 
         return new InputObjectType([
diff --git a/src/Scaffolding/Scaffolders/CRUD/Update.php b/src/Scaffolding/Scaffolders/CRUD/Update.php
index 38953dae6..33ebba1e5 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Update.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Update.php
@@ -111,8 +111,7 @@ protected function generateInputType()
             $arr = [
             	'type' => (new TypeParser($typeName))->getType()
             ];
-            $arr['name'] = $dbFieldName;
-            $fields[] = $arr;
+            $fields[$dbFieldName] = $arr;
         }
 
         return new InputObjectType([

From 4716387bfcef9bd8a231f2cf354dfc1895e7108c Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 31 Jan 2017 20:23:33 +1300
Subject: [PATCH 49/66] PSR2 formatting

---
 client/dist/graphiql.js                       | 54508 ----------------
 src/Controller.php                            |     2 +-
 src/FieldCreator.php                          |     2 +-
 src/Manager.php                               |    13 +-
 .../Scaffolders/ArgumentScaffolder.php        |   261 +-
 src/Scaffolding/Scaffolders/CRUD/Create.php   |     2 +-
 src/Scaffolding/Scaffolders/CRUD/Read.php     |    10 +-
 src/Scaffolding/Scaffolders/CRUD/Update.php   |     4 +-
 .../Scaffolders/DataObjectScaffolder.php      |    91 +-
 .../Scaffolders/OperationScaffolder.php       |   140 +-
 src/Scaffolding/Util/TypeParser.php           |    29 +-
 tests/ScaffoldingTest.php                     |     8 +-
 12 files changed, 279 insertions(+), 54791 deletions(-)
 delete mode 100644 client/dist/graphiql.js

diff --git a/client/dist/graphiql.js b/client/dist/graphiql.js
deleted file mode 100644
index 51fe115e3..000000000
--- a/client/dist/graphiql.js
+++ /dev/null
@@ -1,54508 +0,0 @@
-/******/ (function(modules) { // webpackBootstrap
-/******/ 	// The module cache
-/******/ 	var installedModules = {};
-
-/******/ 	// The require function
-/******/ 	function __webpack_require__(moduleId) {
-
-/******/ 		// Check if module is in cache
-/******/ 		if(installedModules[moduleId])
-/******/ 			return installedModules[moduleId].exports;
-
-/******/ 		// Create a new module (and put it into the cache)
-/******/ 		var module = installedModules[moduleId] = {
-/******/ 			exports: {},
-/******/ 			id: moduleId,
-/******/ 			loaded: false
-/******/ 		};
-
-/******/ 		// Execute the module function
-/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
-
-/******/ 		// Flag the module as loaded
-/******/ 		module.loaded = true;
-
-/******/ 		// Return the exports of the module
-/******/ 		return module.exports;
-/******/ 	}
-
-
-/******/ 	// expose the modules object (__webpack_modules__)
-/******/ 	__webpack_require__.m = modules;
-
-/******/ 	// expose the module cache
-/******/ 	__webpack_require__.c = installedModules;
-
-/******/ 	// __webpack_public_path__
-/******/ 	__webpack_require__.p = "";
-
-/******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(0);
-/******/ })
-/************************************************************************/
-/******/ ([
-/* 0 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	var _react = __webpack_require__(1);
-
-	var _react2 = _interopRequireDefault(_react);
-
-	var _reactDom = __webpack_require__(32);
-
-	var _graphiql = __webpack_require__(183);
-
-	var _graphiql2 = _interopRequireDefault(_graphiql);
-
-	var _isomorphicFetch = __webpack_require__(308);
-
-	var _isomorphicFetch2 = _interopRequireDefault(_isomorphicFetch);
-
-	__webpack_require__(310);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function graphQLFetcher(graphQLParams) {
-	  var baseURL = document.querySelector('base').href;
-	  return (0, _isomorphicFetch2.default)(baseURL + '/' + GRAPHQL_ROUTE + '/', {
-	    method: 'post',
-	    headers: { 'Content-Type': 'application/json' },
-	    body: JSON.stringify(graphQLParams),
-	    credentials: 'same-origin'
-	  }).then(function (response) {
-	    return response.json();
-	  });
-	}
-
-	document.addEventListener('DOMContentLoaded', function () {
-	  (0, _reactDom.render)(_react2.default.createElement(_graphiql2.default, { fetcher: graphQLFetcher }), document.getElementById('graphiql'));
-	});
-
-/***/ },
-/* 1 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	module.exports = __webpack_require__(2);
-
-
-/***/ },
-/* 2 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _assign = __webpack_require__(4);
-
-	var ReactChildren = __webpack_require__(5);
-	var ReactComponent = __webpack_require__(18);
-	var ReactPureComponent = __webpack_require__(21);
-	var ReactClass = __webpack_require__(22);
-	var ReactDOMFactories = __webpack_require__(24);
-	var ReactElement = __webpack_require__(9);
-	var ReactPropTypes = __webpack_require__(29);
-	var ReactVersion = __webpack_require__(30);
-
-	var onlyChild = __webpack_require__(31);
-	var warning = __webpack_require__(11);
-
-	var createElement = ReactElement.createElement;
-	var createFactory = ReactElement.createFactory;
-	var cloneElement = ReactElement.cloneElement;
-
-	if (process.env.NODE_ENV !== 'production') {
-	  var ReactElementValidator = __webpack_require__(25);
-	  createElement = ReactElementValidator.createElement;
-	  createFactory = ReactElementValidator.createFactory;
-	  cloneElement = ReactElementValidator.cloneElement;
-	}
-
-	var __spread = _assign;
-
-	if (process.env.NODE_ENV !== 'production') {
-	  var warned = false;
-	  __spread = function () {
-	    process.env.NODE_ENV !== 'production' ? warning(warned, 'React.__spread is deprecated and should not be used. Use ' + 'Object.assign directly or another helper function with similar ' + 'semantics. You may be seeing this warning due to your compiler. ' + 'See https://fb.me/react-spread-deprecation for more details.') : void 0;
-	    warned = true;
-	    return _assign.apply(null, arguments);
-	  };
-	}
-
-	var React = {
-
-	  // Modern
-
-	  Children: {
-	    map: ReactChildren.map,
-	    forEach: ReactChildren.forEach,
-	    count: ReactChildren.count,
-	    toArray: ReactChildren.toArray,
-	    only: onlyChild
-	  },
-
-	  Component: ReactComponent,
-	  PureComponent: ReactPureComponent,
-
-	  createElement: createElement,
-	  cloneElement: cloneElement,
-	  isValidElement: ReactElement.isValidElement,
-
-	  // Classic
-
-	  PropTypes: ReactPropTypes,
-	  createClass: ReactClass.createClass,
-	  createFactory: createFactory,
-	  createMixin: function (mixin) {
-	    // Currently a noop. Will be used to validate and trace mixins.
-	    return mixin;
-	  },
-
-	  // This looks DOM specific but these are actually isomorphic helpers
-	  // since they are just generating DOM strings.
-	  DOM: ReactDOMFactories,
-
-	  version: ReactVersion,
-
-	  // Deprecated hook for JSX spread, don't use this for anything.
-	  __spread: __spread
-	};
-
-	module.exports = React;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 3 */
-/***/ function(module, exports) {
-
-	// shim for using process in browser
-	var process = module.exports = {};
-
-	// cached from whatever global is present so that test runners that stub it
-	// don't break things.  But we need to wrap it in a try catch in case it is
-	// wrapped in strict mode code which doesn't define any globals.  It's inside a
-	// function because try/catches deoptimize in certain engines.
-
-	var cachedSetTimeout;
-	var cachedClearTimeout;
-
-	function defaultSetTimout() {
-	    throw new Error('setTimeout has not been defined');
-	}
-	function defaultClearTimeout () {
-	    throw new Error('clearTimeout has not been defined');
-	}
-	(function () {
-	    try {
-	        if (typeof setTimeout === 'function') {
-	            cachedSetTimeout = setTimeout;
-	        } else {
-	            cachedSetTimeout = defaultSetTimout;
-	        }
-	    } catch (e) {
-	        cachedSetTimeout = defaultSetTimout;
-	    }
-	    try {
-	        if (typeof clearTimeout === 'function') {
-	            cachedClearTimeout = clearTimeout;
-	        } else {
-	            cachedClearTimeout = defaultClearTimeout;
-	        }
-	    } catch (e) {
-	        cachedClearTimeout = defaultClearTimeout;
-	    }
-	} ())
-	function runTimeout(fun) {
-	    if (cachedSetTimeout === setTimeout) {
-	        //normal enviroments in sane situations
-	        return setTimeout(fun, 0);
-	    }
-	    // if setTimeout wasn't available but was latter defined
-	    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
-	        cachedSetTimeout = setTimeout;
-	        return setTimeout(fun, 0);
-	    }
-	    try {
-	        // when when somebody has screwed with setTimeout but no I.E. maddness
-	        return cachedSetTimeout(fun, 0);
-	    } catch(e){
-	        try {
-	            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
-	            return cachedSetTimeout.call(null, fun, 0);
-	        } catch(e){
-	            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
-	            return cachedSetTimeout.call(this, fun, 0);
-	        }
-	    }
-
-
-	}
-	function runClearTimeout(marker) {
-	    if (cachedClearTimeout === clearTimeout) {
-	        //normal enviroments in sane situations
-	        return clearTimeout(marker);
-	    }
-	    // if clearTimeout wasn't available but was latter defined
-	    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
-	        cachedClearTimeout = clearTimeout;
-	        return clearTimeout(marker);
-	    }
-	    try {
-	        // when when somebody has screwed with setTimeout but no I.E. maddness
-	        return cachedClearTimeout(marker);
-	    } catch (e){
-	        try {
-	            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
-	            return cachedClearTimeout.call(null, marker);
-	        } catch (e){
-	            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
-	            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
-	            return cachedClearTimeout.call(this, marker);
-	        }
-	    }
-
-
-
-	}
-	var queue = [];
-	var draining = false;
-	var currentQueue;
-	var queueIndex = -1;
-
-	function cleanUpNextTick() {
-	    if (!draining || !currentQueue) {
-	        return;
-	    }
-	    draining = false;
-	    if (currentQueue.length) {
-	        queue = currentQueue.concat(queue);
-	    } else {
-	        queueIndex = -1;
-	    }
-	    if (queue.length) {
-	        drainQueue();
-	    }
-	}
-
-	function drainQueue() {
-	    if (draining) {
-	        return;
-	    }
-	    var timeout = runTimeout(cleanUpNextTick);
-	    draining = true;
-
-	    var len = queue.length;
-	    while(len) {
-	        currentQueue = queue;
-	        queue = [];
-	        while (++queueIndex < len) {
-	            if (currentQueue) {
-	                currentQueue[queueIndex].run();
-	            }
-	        }
-	        queueIndex = -1;
-	        len = queue.length;
-	    }
-	    currentQueue = null;
-	    draining = false;
-	    runClearTimeout(timeout);
-	}
-
-	process.nextTick = function (fun) {
-	    var args = new Array(arguments.length - 1);
-	    if (arguments.length > 1) {
-	        for (var i = 1; i < arguments.length; i++) {
-	            args[i - 1] = arguments[i];
-	        }
-	    }
-	    queue.push(new Item(fun, args));
-	    if (queue.length === 1 && !draining) {
-	        runTimeout(drainQueue);
-	    }
-	};
-
-	// v8 likes predictible objects
-	function Item(fun, array) {
-	    this.fun = fun;
-	    this.array = array;
-	}
-	Item.prototype.run = function () {
-	    this.fun.apply(null, this.array);
-	};
-	process.title = 'browser';
-	process.browser = true;
-	process.env = {};
-	process.argv = [];
-	process.version = ''; // empty string to avoid regexp issues
-	process.versions = {};
-
-	function noop() {}
-
-	process.on = noop;
-	process.addListener = noop;
-	process.once = noop;
-	process.off = noop;
-	process.removeListener = noop;
-	process.removeAllListeners = noop;
-	process.emit = noop;
-
-	process.binding = function (name) {
-	    throw new Error('process.binding is not supported');
-	};
-
-	process.cwd = function () { return '/' };
-	process.chdir = function (dir) {
-	    throw new Error('process.chdir is not supported');
-	};
-	process.umask = function() { return 0; };
-
-
-/***/ },
-/* 4 */
-/***/ function(module, exports) {
-
-	'use strict';
-	/* eslint-disable no-unused-vars */
-	var hasOwnProperty = Object.prototype.hasOwnProperty;
-	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
-
-	function toObject(val) {
-		if (val === null || val === undefined) {
-			throw new TypeError('Object.assign cannot be called with null or undefined');
-		}
-
-		return Object(val);
-	}
-
-	function shouldUseNative() {
-		try {
-			if (!Object.assign) {
-				return false;
-			}
-
-			// Detect buggy property enumeration order in older V8 versions.
-
-			// https://bugs.chromium.org/p/v8/issues/detail?id=4118
-			var test1 = new String('abc');  // eslint-disable-line
-			test1[5] = 'de';
-			if (Object.getOwnPropertyNames(test1)[0] === '5') {
-				return false;
-			}
-
-			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
-			var test2 = {};
-			for (var i = 0; i < 10; i++) {
-				test2['_' + String.fromCharCode(i)] = i;
-			}
-			var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
-				return test2[n];
-			});
-			if (order2.join('') !== '0123456789') {
-				return false;
-			}
-
-			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
-			var test3 = {};
-			'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
-				test3[letter] = letter;
-			});
-			if (Object.keys(Object.assign({}, test3)).join('') !==
-					'abcdefghijklmnopqrst') {
-				return false;
-			}
-
-			return true;
-		} catch (e) {
-			// We don't expect any of the above to throw, but better to be safe.
-			return false;
-		}
-	}
-
-	module.exports = shouldUseNative() ? Object.assign : function (target, source) {
-		var from;
-		var to = toObject(target);
-		var symbols;
-
-		for (var s = 1; s < arguments.length; s++) {
-			from = Object(arguments[s]);
-
-			for (var key in from) {
-				if (hasOwnProperty.call(from, key)) {
-					to[key] = from[key];
-				}
-			}
-
-			if (Object.getOwnPropertySymbols) {
-				symbols = Object.getOwnPropertySymbols(from);
-				for (var i = 0; i < symbols.length; i++) {
-					if (propIsEnumerable.call(from, symbols[i])) {
-						to[symbols[i]] = from[symbols[i]];
-					}
-				}
-			}
-		}
-
-		return to;
-	};
-
-
-/***/ },
-/* 5 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var PooledClass = __webpack_require__(6);
-	var ReactElement = __webpack_require__(9);
-
-	var emptyFunction = __webpack_require__(12);
-	var traverseAllChildren = __webpack_require__(15);
-
-	var twoArgumentPooler = PooledClass.twoArgumentPooler;
-	var fourArgumentPooler = PooledClass.fourArgumentPooler;
-
-	var userProvidedKeyEscapeRegex = /\/+/g;
-	function escapeUserProvidedKey(text) {
-	  return ('' + text).replace(userProvidedKeyEscapeRegex, '$&/');
-	}
-
-	/**
-	 * PooledClass representing the bookkeeping associated with performing a child
-	 * traversal. Allows avoiding binding callbacks.
-	 *
-	 * @constructor ForEachBookKeeping
-	 * @param {!function} forEachFunction Function to perform traversal with.
-	 * @param {?*} forEachContext Context to perform context with.
-	 */
-	function ForEachBookKeeping(forEachFunction, forEachContext) {
-	  this.func = forEachFunction;
-	  this.context = forEachContext;
-	  this.count = 0;
-	}
-	ForEachBookKeeping.prototype.destructor = function () {
-	  this.func = null;
-	  this.context = null;
-	  this.count = 0;
-	};
-	PooledClass.addPoolingTo(ForEachBookKeeping, twoArgumentPooler);
-
-	function forEachSingleChild(bookKeeping, child, name) {
-	  var func = bookKeeping.func,
-	      context = bookKeeping.context;
-
-	  func.call(context, child, bookKeeping.count++);
-	}
-
-	/**
-	 * Iterates through children that are typically specified as `props.children`.
-	 *
-	 * See https://facebook.github.io/react/docs/top-level-api.html#react.children.foreach
-	 *
-	 * The provided forEachFunc(child, index) will be called for each
-	 * leaf child.
-	 *
-	 * @param {?*} children Children tree container.
-	 * @param {function(*, int)} forEachFunc
-	 * @param {*} forEachContext Context for forEachContext.
-	 */
-	function forEachChildren(children, forEachFunc, forEachContext) {
-	  if (children == null) {
-	    return children;
-	  }
-	  var traverseContext = ForEachBookKeeping.getPooled(forEachFunc, forEachContext);
-	  traverseAllChildren(children, forEachSingleChild, traverseContext);
-	  ForEachBookKeeping.release(traverseContext);
-	}
-
-	/**
-	 * PooledClass representing the bookkeeping associated with performing a child
-	 * mapping. Allows avoiding binding callbacks.
-	 *
-	 * @constructor MapBookKeeping
-	 * @param {!*} mapResult Object containing the ordered map of results.
-	 * @param {!function} mapFunction Function to perform mapping with.
-	 * @param {?*} mapContext Context to perform mapping with.
-	 */
-	function MapBookKeeping(mapResult, keyPrefix, mapFunction, mapContext) {
-	  this.result = mapResult;
-	  this.keyPrefix = keyPrefix;
-	  this.func = mapFunction;
-	  this.context = mapContext;
-	  this.count = 0;
-	}
-	MapBookKeeping.prototype.destructor = function () {
-	  this.result = null;
-	  this.keyPrefix = null;
-	  this.func = null;
-	  this.context = null;
-	  this.count = 0;
-	};
-	PooledClass.addPoolingTo(MapBookKeeping, fourArgumentPooler);
-
-	function mapSingleChildIntoContext(bookKeeping, child, childKey) {
-	  var result = bookKeeping.result,
-	      keyPrefix = bookKeeping.keyPrefix,
-	      func = bookKeeping.func,
-	      context = bookKeeping.context;
-
-
-	  var mappedChild = func.call(context, child, bookKeeping.count++);
-	  if (Array.isArray(mappedChild)) {
-	    mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, emptyFunction.thatReturnsArgument);
-	  } else if (mappedChild != null) {
-	    if (ReactElement.isValidElement(mappedChild)) {
-	      mappedChild = ReactElement.cloneAndReplaceKey(mappedChild,
-	      // Keep both the (mapped) and old keys if they differ, just as
-	      // traverseAllChildren used to do for objects as children
-	      keyPrefix + (mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey(mappedChild.key) + '/' : '') + childKey);
-	    }
-	    result.push(mappedChild);
-	  }
-	}
-
-	function mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {
-	  var escapedPrefix = '';
-	  if (prefix != null) {
-	    escapedPrefix = escapeUserProvidedKey(prefix) + '/';
-	  }
-	  var traverseContext = MapBookKeeping.getPooled(array, escapedPrefix, func, context);
-	  traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);
-	  MapBookKeeping.release(traverseContext);
-	}
-
-	/**
-	 * Maps children that are typically specified as `props.children`.
-	 *
-	 * See https://facebook.github.io/react/docs/top-level-api.html#react.children.map
-	 *
-	 * The provided mapFunction(child, key, index) will be called for each
-	 * leaf child.
-	 *
-	 * @param {?*} children Children tree container.
-	 * @param {function(*, int)} func The map function.
-	 * @param {*} context Context for mapFunction.
-	 * @return {object} Object containing the ordered map of results.
-	 */
-	function mapChildren(children, func, context) {
-	  if (children == null) {
-	    return children;
-	  }
-	  var result = [];
-	  mapIntoWithKeyPrefixInternal(children, result, null, func, context);
-	  return result;
-	}
-
-	function forEachSingleChildDummy(traverseContext, child, name) {
-	  return null;
-	}
-
-	/**
-	 * Count the number of children that are typically specified as
-	 * `props.children`.
-	 *
-	 * See https://facebook.github.io/react/docs/top-level-api.html#react.children.count
-	 *
-	 * @param {?*} children Children tree container.
-	 * @return {number} The number of children.
-	 */
-	function countChildren(children, context) {
-	  return traverseAllChildren(children, forEachSingleChildDummy, null);
-	}
-
-	/**
-	 * Flatten a children object (typically specified as `props.children`) and
-	 * return an array with appropriately re-keyed children.
-	 *
-	 * See https://facebook.github.io/react/docs/top-level-api.html#react.children.toarray
-	 */
-	function toArray(children) {
-	  var result = [];
-	  mapIntoWithKeyPrefixInternal(children, result, null, emptyFunction.thatReturnsArgument);
-	  return result;
-	}
-
-	var ReactChildren = {
-	  forEach: forEachChildren,
-	  map: mapChildren,
-	  mapIntoWithKeyPrefixInternal: mapIntoWithKeyPrefixInternal,
-	  count: countChildren,
-	  toArray: toArray
-	};
-
-	module.exports = ReactChildren;
-
-/***/ },
-/* 6 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(7);
-
-	var invariant = __webpack_require__(8);
-
-	/**
-	 * 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 threeArgumentPooler = function (a1, a2, a3) {
-	  var Klass = this;
-	  if (Klass.instancePool.length) {
-	    var instance = Klass.instancePool.pop();
-	    Klass.call(instance, a1, a2, a3);
-	    return instance;
-	  } else {
-	    return new Klass(a1, a2, a3);
-	  }
-	};
-
-	var fourArgumentPooler = function (a1, a2, a3, a4) {
-	  var Klass = this;
-	  if (Klass.instancePool.length) {
-	    var instance = Klass.instancePool.pop();
-	    Klass.call(instance, a1, a2, a3, a4);
-	    return instance;
-	  } else {
-	    return new Klass(a1, a2, a3, a4);
-	  }
-	};
-
-	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;
-	  !(instance instanceof Klass) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Trying to release an instance into a pool of a different type.') : _prodInvariant('25') : void 0;
-	  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.
-	 *
-	 * @param {Function} CopyConstructor Constructor that can be used to reset.
-	 * @param {Function} pooler Customizable pooler.
-	 */
-	var addPoolingTo = function (CopyConstructor, pooler) {
-	  // Casting as any so that flow ignores the actual implementation and trusts
-	  // it to match the type we declared
-	  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,
-	  threeArgumentPooler: threeArgumentPooler,
-	  fourArgumentPooler: fourArgumentPooler,
-	  fiveArgumentPooler: fiveArgumentPooler
-	};
-
-	module.exports = PooledClass;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 7 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-	'use strict';
-
-	/**
-	 * WARNING: DO NOT manually require this module.
-	 * This is a replacement for `invariant(...)` used by the error code system
-	 * and will _only_ be required by the corresponding babel pass.
-	 * It always throws.
-	 */
-
-	function reactProdInvariant(code) {
-	  var argCount = arguments.length - 1;
-
-	  var message = 'Minified React error #' + code + '; visit ' + 'http://facebook.github.io/react/docs/error-decoder.html?invariant=' + code;
-
-	  for (var argIdx = 0; argIdx < argCount; argIdx++) {
-	    message += '&args[]=' + encodeURIComponent(arguments[argIdx + 1]);
-	  }
-
-	  message += ' for the full message or use the non-minified dev environment' + ' for full errors and additional helpful warnings.';
-
-	  var error = new Error(message);
-	  error.name = 'Invariant Violation';
-	  error.framesToPop = 1; // we don't care about reactProdInvariant's own frame
-
-	  throw error;
-	}
-
-	module.exports = reactProdInvariant;
-
-/***/ },
-/* 8 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	/**
-	 * Use invariant() to assert state which your program assumes to be true.
-	 *
-	 * Provide sprintf-style format (only %s is supported) 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, format, a, b, c, d, e, f) {
-	  if (process.env.NODE_ENV !== 'production') {
-	    if (format === undefined) {
-	      throw new Error('invariant requires an error message argument');
-	    }
-	  }
-
-	  if (!condition) {
-	    var error;
-	    if (format === undefined) {
-	      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
-	    } else {
-	      var args = [a, b, c, d, e, f];
-	      var argIndex = 0;
-	      error = new Error(format.replace(/%s/g, function () {
-	        return args[argIndex++];
-	      }));
-	      error.name = 'Invariant Violation';
-	    }
-
-	    error.framesToPop = 1; // we don't care about invariant's own frame
-	    throw error;
-	  }
-	}
-
-	module.exports = invariant;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 9 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2014-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _assign = __webpack_require__(4);
-
-	var ReactCurrentOwner = __webpack_require__(10);
-
-	var warning = __webpack_require__(11);
-	var canDefineProperty = __webpack_require__(13);
-	var hasOwnProperty = Object.prototype.hasOwnProperty;
-
-	var REACT_ELEMENT_TYPE = __webpack_require__(14);
-
-	var RESERVED_PROPS = {
-	  key: true,
-	  ref: true,
-	  __self: true,
-	  __source: true
-	};
-
-	var specialPropKeyWarningShown, specialPropRefWarningShown;
-
-	function hasValidRef(config) {
-	  if (process.env.NODE_ENV !== 'production') {
-	    if (hasOwnProperty.call(config, 'ref')) {
-	      var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;
-	      if (getter && getter.isReactWarning) {
-	        return false;
-	      }
-	    }
-	  }
-	  return config.ref !== undefined;
-	}
-
-	function hasValidKey(config) {
-	  if (process.env.NODE_ENV !== 'production') {
-	    if (hasOwnProperty.call(config, 'key')) {
-	      var getter = Object.getOwnPropertyDescriptor(config, 'key').get;
-	      if (getter && getter.isReactWarning) {
-	        return false;
-	      }
-	    }
-	  }
-	  return config.key !== undefined;
-	}
-
-	function defineKeyPropWarningGetter(props, displayName) {
-	  var warnAboutAccessingKey = function () {
-	    if (!specialPropKeyWarningShown) {
-	      specialPropKeyWarningShown = true;
-	      process.env.NODE_ENV !== 'production' ? warning(false, '%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName) : void 0;
-	    }
-	  };
-	  warnAboutAccessingKey.isReactWarning = true;
-	  Object.defineProperty(props, 'key', {
-	    get: warnAboutAccessingKey,
-	    configurable: true
-	  });
-	}
-
-	function defineRefPropWarningGetter(props, displayName) {
-	  var warnAboutAccessingRef = function () {
-	    if (!specialPropRefWarningShown) {
-	      specialPropRefWarningShown = true;
-	      process.env.NODE_ENV !== 'production' ? warning(false, '%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName) : void 0;
-	    }
-	  };
-	  warnAboutAccessingRef.isReactWarning = true;
-	  Object.defineProperty(props, 'ref', {
-	    get: warnAboutAccessingRef,
-	    configurable: true
-	  });
-	}
-
-	/**
-	 * Factory method to create a new React element. This no longer adheres to
-	 * the class pattern, so do not use new to call it. Also, no instanceof check
-	 * will work. Instead test $$typeof field against Symbol.for('react.element') to check
-	 * if something is a React Element.
-	 *
-	 * @param {*} type
-	 * @param {*} key
-	 * @param {string|object} ref
-	 * @param {*} self A *temporary* helper to detect places where `this` is
-	 * different from the `owner` when React.createElement is called, so that we
-	 * can warn. We want to get rid of owner and replace string `ref`s with arrow
-	 * functions, and as long as `this` and owner are the same, there will be no
-	 * change in behavior.
-	 * @param {*} source An annotation object (added by a transpiler or otherwise)
-	 * indicating filename, line number, and/or other information.
-	 * @param {*} owner
-	 * @param {*} props
-	 * @internal
-	 */
-	var ReactElement = function (type, key, ref, self, source, owner, props) {
-	  var element = {
-	    // This tag allow us to uniquely identify this as a React Element
-	    $$typeof: REACT_ELEMENT_TYPE,
-
-	    // Built-in properties that belong on the element
-	    type: type,
-	    key: key,
-	    ref: ref,
-	    props: props,
-
-	    // Record the component responsible for creating this element.
-	    _owner: owner
-	  };
-
-	  if (process.env.NODE_ENV !== 'production') {
-	    // The validation flag is currently mutative. We put it on
-	    // an external backing store so that we can freeze the whole object.
-	    // This can be replaced with a WeakMap once they are implemented in
-	    // commonly used development environments.
-	    element._store = {};
-
-	    // To make comparing ReactElements easier for testing purposes, we make
-	    // the validation flag non-enumerable (where possible, which should
-	    // include every environment we run tests in), so the test framework
-	    // ignores it.
-	    if (canDefineProperty) {
-	      Object.defineProperty(element._store, 'validated', {
-	        configurable: false,
-	        enumerable: false,
-	        writable: true,
-	        value: false
-	      });
-	      // self and source are DEV only properties.
-	      Object.defineProperty(element, '_self', {
-	        configurable: false,
-	        enumerable: false,
-	        writable: false,
-	        value: self
-	      });
-	      // Two elements created in two different places should be considered
-	      // equal for testing purposes and therefore we hide it from enumeration.
-	      Object.defineProperty(element, '_source', {
-	        configurable: false,
-	        enumerable: false,
-	        writable: false,
-	        value: source
-	      });
-	    } else {
-	      element._store.validated = false;
-	      element._self = self;
-	      element._source = source;
-	    }
-	    if (Object.freeze) {
-	      Object.freeze(element.props);
-	      Object.freeze(element);
-	    }
-	  }
-
-	  return element;
-	};
-
-	/**
-	 * Create and return a new ReactElement of the given type.
-	 * See https://facebook.github.io/react/docs/top-level-api.html#react.createelement
-	 */
-	ReactElement.createElement = function (type, config, children) {
-	  var propName;
-
-	  // Reserved names are extracted
-	  var props = {};
-
-	  var key = null;
-	  var ref = null;
-	  var self = null;
-	  var source = null;
-
-	  if (config != null) {
-	    if (hasValidRef(config)) {
-	      ref = config.ref;
-	    }
-	    if (hasValidKey(config)) {
-	      key = '' + config.key;
-	    }
-
-	    self = config.__self === undefined ? null : config.__self;
-	    source = config.__source === undefined ? null : config.__source;
-	    // Remaining properties are added to a new props object
-	    for (propName in config) {
-	      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
-	        props[propName] = config[propName];
-	      }
-	    }
-	  }
-
-	  // Children can be more than one argument, and those are transferred onto
-	  // the newly allocated props object.
-	  var childrenLength = arguments.length - 2;
-	  if (childrenLength === 1) {
-	    props.children = children;
-	  } else if (childrenLength > 1) {
-	    var childArray = Array(childrenLength);
-	    for (var i = 0; i < childrenLength; i++) {
-	      childArray[i] = arguments[i + 2];
-	    }
-	    if (process.env.NODE_ENV !== 'production') {
-	      if (Object.freeze) {
-	        Object.freeze(childArray);
-	      }
-	    }
-	    props.children = childArray;
-	  }
-
-	  // Resolve default props
-	  if (type && type.defaultProps) {
-	    var defaultProps = type.defaultProps;
-	    for (propName in defaultProps) {
-	      if (props[propName] === undefined) {
-	        props[propName] = defaultProps[propName];
-	      }
-	    }
-	  }
-	  if (process.env.NODE_ENV !== 'production') {
-	    if (key || ref) {
-	      if (typeof props.$$typeof === 'undefined' || props.$$typeof !== REACT_ELEMENT_TYPE) {
-	        var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;
-	        if (key) {
-	          defineKeyPropWarningGetter(props, displayName);
-	        }
-	        if (ref) {
-	          defineRefPropWarningGetter(props, displayName);
-	        }
-	      }
-	    }
-	  }
-	  return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
-	};
-
-	/**
-	 * Return a function that produces ReactElements of a given type.
-	 * See https://facebook.github.io/react/docs/top-level-api.html#react.createfactory
-	 */
-	ReactElement.createFactory = function (type) {
-	  var factory = ReactElement.createElement.bind(null, type);
-	  // Expose the type on the factory and the prototype so that it can be
-	  // easily accessed on elements. E.g. `<Foo />.type === Foo`.
-	  // This should not be named `constructor` since this may not be the function
-	  // that created the element, and it may not even be a constructor.
-	  // Legacy hook TODO: Warn if this is accessed
-	  factory.type = type;
-	  return factory;
-	};
-
-	ReactElement.cloneAndReplaceKey = function (oldElement, newKey) {
-	  var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
-
-	  return newElement;
-	};
-
-	/**
-	 * Clone and return a new ReactElement using element as the starting point.
-	 * See https://facebook.github.io/react/docs/top-level-api.html#react.cloneelement
-	 */
-	ReactElement.cloneElement = function (element, config, children) {
-	  var propName;
-
-	  // Original props are copied
-	  var props = _assign({}, element.props);
-
-	  // Reserved names are extracted
-	  var key = element.key;
-	  var ref = element.ref;
-	  // Self is preserved since the owner is preserved.
-	  var self = element._self;
-	  // Source is preserved since cloneElement is unlikely to be targeted by a
-	  // transpiler, and the original source is probably a better indicator of the
-	  // true owner.
-	  var source = element._source;
-
-	  // Owner will be preserved, unless ref is overridden
-	  var owner = element._owner;
-
-	  if (config != null) {
-	    if (hasValidRef(config)) {
-	      // Silently steal the ref from the parent.
-	      ref = config.ref;
-	      owner = ReactCurrentOwner.current;
-	    }
-	    if (hasValidKey(config)) {
-	      key = '' + config.key;
-	    }
-
-	    // Remaining properties override existing props
-	    var defaultProps;
-	    if (element.type && element.type.defaultProps) {
-	      defaultProps = element.type.defaultProps;
-	    }
-	    for (propName in config) {
-	      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
-	        if (config[propName] === undefined && defaultProps !== undefined) {
-	          // Resolve default props
-	          props[propName] = defaultProps[propName];
-	        } else {
-	          props[propName] = config[propName];
-	        }
-	      }
-	    }
-	  }
-
-	  // Children can be more than one argument, and those are transferred onto
-	  // the newly allocated props object.
-	  var childrenLength = arguments.length - 2;
-	  if (childrenLength === 1) {
-	    props.children = children;
-	  } else if (childrenLength > 1) {
-	    var childArray = Array(childrenLength);
-	    for (var i = 0; i < childrenLength; i++) {
-	      childArray[i] = arguments[i + 2];
-	    }
-	    props.children = childArray;
-	  }
-
-	  return ReactElement(element.type, key, ref, self, source, owner, props);
-	};
-
-	/**
-	 * Verifies the object is a ReactElement.
-	 * See https://facebook.github.io/react/docs/top-level-api.html#react.isvalidelement
-	 * @param {?object} object
-	 * @return {boolean} True if `object` is a valid component.
-	 * @final
-	 */
-	ReactElement.isValidElement = function (object) {
-	  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
-	};
-
-	module.exports = ReactElement;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 10 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'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;
-
-/***/ },
-/* 11 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2014-2015, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var emptyFunction = __webpack_require__(12);
-
-	/**
-	 * Similar to invariant but only logs a warning if the condition is not met.
-	 * This can be used to log issues in development environments in critical
-	 * paths. Removing the logging code for production environments will keep the
-	 * same logic and follow the same code paths.
-	 */
-
-	var warning = emptyFunction;
-
-	if (process.env.NODE_ENV !== 'production') {
-	  (function () {
-	    var printWarning = function printWarning(format) {
-	      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-	        args[_key - 1] = arguments[_key];
-	      }
-
-	      var argIndex = 0;
-	      var message = 'Warning: ' + format.replace(/%s/g, function () {
-	        return args[argIndex++];
-	      });
-	      if (typeof console !== 'undefined') {
-	        console.error(message);
-	      }
-	      try {
-	        // --- Welcome to debugging React ---
-	        // This error was thrown as a convenience so that you can use this stack
-	        // to find the callsite that caused this warning to fire.
-	        throw new Error(message);
-	      } catch (x) {}
-	    };
-
-	    warning = function warning(condition, format) {
-	      if (format === undefined) {
-	        throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
-	      }
-
-	      if (format.indexOf('Failed Composite propType: ') === 0) {
-	        return; // Ignore CompositeComponent proptype check.
-	      }
-
-	      if (!condition) {
-	        for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
-	          args[_key2 - 2] = arguments[_key2];
-	        }
-
-	        printWarning.apply(undefined, [format].concat(args));
-	      }
-	    };
-	  })();
-	}
-
-	module.exports = warning;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 12 */
-/***/ function(module, exports) {
-
-	"use strict";
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	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.
-	 */
-	var emptyFunction = function emptyFunction() {};
-
-	emptyFunction.thatReturns = makeEmptyFunction;
-	emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
-	emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
-	emptyFunction.thatReturnsNull = makeEmptyFunction(null);
-	emptyFunction.thatReturnsThis = function () {
-	  return this;
-	};
-	emptyFunction.thatReturnsArgument = function (arg) {
-	  return arg;
-	};
-
-	module.exports = emptyFunction;
-
-/***/ },
-/* 13 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var canDefineProperty = false;
-	if (process.env.NODE_ENV !== 'production') {
-	  try {
-	    // $FlowFixMe https://github.com/facebook/flow/issues/285
-	    Object.defineProperty({}, 'x', { get: function () {} });
-	    canDefineProperty = true;
-	  } catch (x) {
-	    // IE will fail on defineProperty
-	  }
-	}
-
-	module.exports = canDefineProperty;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 14 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2014-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	// The Symbol used to tag the ReactElement type. If there is no native Symbol
-	// nor polyfill, then a plain number is used for performance.
-
-	var REACT_ELEMENT_TYPE = typeof Symbol === 'function' && Symbol['for'] && Symbol['for']('react.element') || 0xeac7;
-
-	module.exports = REACT_ELEMENT_TYPE;
-
-/***/ },
-/* 15 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(7);
-
-	var ReactCurrentOwner = __webpack_require__(10);
-	var REACT_ELEMENT_TYPE = __webpack_require__(14);
-
-	var getIteratorFn = __webpack_require__(16);
-	var invariant = __webpack_require__(8);
-	var KeyEscapeUtils = __webpack_require__(17);
-	var warning = __webpack_require__(11);
-
-	var SEPARATOR = '.';
-	var SUBSEPARATOR = ':';
-
-	/**
-	 * This is inlined from ReactElement since this file is shared between
-	 * isomorphic and renderers. We could extract this to a
-	 *
-	 */
-
-	/**
-	 * TODO: Test that a single child and an array with one item have the same key
-	 * pattern.
-	 */
-
-	var didWarnAboutMaps = false;
-
-	/**
-	 * 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}
-	 */
-	function getComponentKey(component, index) {
-	  // Do some typechecking here since we call this blindly. We want to ensure
-	  // that we don't block potential future ES APIs.
-	  if (component && typeof component === 'object' && component.key != null) {
-	    // Explicit key
-	    return KeyEscapeUtils.escape(component.key);
-	  }
-	  // Implicit key determined by the index in the set
-	  return index.toString(36);
-	}
-
-	/**
-	 * @param {?*} children Children tree container.
-	 * @param {!string} nameSoFar Name of the key path so far.
-	 * @param {!function} callback Callback to invoke with each child found.
-	 * @param {?*} traverseContext Used to pass information throughout the traversal
-	 * process.
-	 * @return {!number} The number of children in this subtree.
-	 */
-	function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {
-	  var type = typeof children;
-
-	  if (type === 'undefined' || type === 'boolean') {
-	    // All of the above are perceived as null.
-	    children = null;
-	  }
-
-	  if (children === null || type === 'string' || type === 'number' ||
-	  // The following is inlined from ReactElement. This means we can optimize
-	  // some checks. React Fiber also inlines this logic for similar purposes.
-	  type === 'object' && children.$$typeof === REACT_ELEMENT_TYPE) {
-	    callback(traverseContext, children,
-	    // 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.
-	    nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);
-	    return 1;
-	  }
-
-	  var child;
-	  var nextName;
-	  var subtreeCount = 0; // Count of children found in the current subtree.
-	  var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;
-
-	  if (Array.isArray(children)) {
-	    for (var i = 0; i < children.length; i++) {
-	      child = children[i];
-	      nextName = nextNamePrefix + getComponentKey(child, i);
-	      subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
-	    }
-	  } else {
-	    var iteratorFn = getIteratorFn(children);
-	    if (iteratorFn) {
-	      var iterator = iteratorFn.call(children);
-	      var step;
-	      if (iteratorFn !== children.entries) {
-	        var ii = 0;
-	        while (!(step = iterator.next()).done) {
-	          child = step.value;
-	          nextName = nextNamePrefix + getComponentKey(child, ii++);
-	          subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
-	        }
-	      } else {
-	        if (process.env.NODE_ENV !== 'production') {
-	          var mapsAsChildrenAddendum = '';
-	          if (ReactCurrentOwner.current) {
-	            var mapsAsChildrenOwnerName = ReactCurrentOwner.current.getName();
-	            if (mapsAsChildrenOwnerName) {
-	              mapsAsChildrenAddendum = ' Check the render method of `' + mapsAsChildrenOwnerName + '`.';
-	            }
-	          }
-	          process.env.NODE_ENV !== 'production' ? warning(didWarnAboutMaps, 'Using Maps as children is not yet fully supported. It is an ' + 'experimental feature that might be removed. Convert it to a ' + 'sequence / iterable of keyed ReactElements instead.%s', mapsAsChildrenAddendum) : void 0;
-	          didWarnAboutMaps = true;
-	        }
-	        // Iterator will provide entry [k,v] tuples rather than values.
-	        while (!(step = iterator.next()).done) {
-	          var entry = step.value;
-	          if (entry) {
-	            child = entry[1];
-	            nextName = nextNamePrefix + KeyEscapeUtils.escape(entry[0]) + SUBSEPARATOR + getComponentKey(child, 0);
-	            subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
-	          }
-	        }
-	      }
-	    } else if (type === 'object') {
-	      var addendum = '';
-	      if (process.env.NODE_ENV !== 'production') {
-	        addendum = ' If you meant to render a collection of children, use an array ' + 'instead or wrap the object using createFragment(object) from the ' + 'React add-ons.';
-	        if (children._isReactElement) {
-	          addendum = ' It looks like you\'re using an element created by a different ' + 'version of React. Make sure to use only one copy of React.';
-	        }
-	        if (ReactCurrentOwner.current) {
-	          var name = ReactCurrentOwner.current.getName();
-	          if (name) {
-	            addendum += ' Check the render method of `' + name + '`.';
-	          }
-	        }
-	      }
-	      var childrenString = String(children);
-	       true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum) : _prodInvariant('31', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum) : void 0;
-	    }
-	  }
-
-	  return subtreeCount;
-	}
-
-	/**
-	 * Traverses children that are typically specified as `props.children`, but
-	 * might also be specified through attributes:
-	 *
-	 * - `traverseAllChildren(this.props.children, ...)`
-	 * - `traverseAllChildren(this.props.leftPanelChildren, ...)`
-	 *
-	 * The `traverseContext` is an optional argument that is passed through the
-	 * entire traversal. It can be used to store accumulations or anything else that
-	 * the callback might find relevant.
-	 *
-	 * @param {?*} children Children tree object.
-	 * @param {!function} callback To invoke upon traversing each child.
-	 * @param {?*} traverseContext Context for traversal.
-	 * @return {!number} The number of children in this subtree.
-	 */
-	function traverseAllChildren(children, callback, traverseContext) {
-	  if (children == null) {
-	    return 0;
-	  }
-
-	  return traverseAllChildrenImpl(children, '', callback, traverseContext);
-	}
-
-	module.exports = traverseAllChildren;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 16 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	/* global Symbol */
-
-	var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
-	var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
-
-	/**
-	 * Returns the iterator method function contained on the iterable object.
-	 *
-	 * Be sure to invoke the function with the iterable as context:
-	 *
-	 *     var iteratorFn = getIteratorFn(myIterable);
-	 *     if (iteratorFn) {
-	 *       var iterator = iteratorFn.call(myIterable);
-	 *       ...
-	 *     }
-	 *
-	 * @param {?object} maybeIterable
-	 * @return {?function}
-	 */
-	function getIteratorFn(maybeIterable) {
-	  var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
-	  if (typeof iteratorFn === 'function') {
-	    return iteratorFn;
-	  }
-	}
-
-	module.exports = getIteratorFn;
-
-/***/ },
-/* 17 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	/**
-	 * Escape and wrap key so it is safe to use as a reactid
-	 *
-	 * @param {string} key to be escaped.
-	 * @return {string} the escaped key.
-	 */
-
-	function escape(key) {
-	  var escapeRegex = /[=:]/g;
-	  var escaperLookup = {
-	    '=': '=0',
-	    ':': '=2'
-	  };
-	  var escapedString = ('' + key).replace(escapeRegex, function (match) {
-	    return escaperLookup[match];
-	  });
-
-	  return '$' + escapedString;
-	}
-
-	/**
-	 * Unescape and unwrap key for human-readable display
-	 *
-	 * @param {string} key to unescape.
-	 * @return {string} the unescaped key.
-	 */
-	function unescape(key) {
-	  var unescapeRegex = /(=0|=2)/g;
-	  var unescaperLookup = {
-	    '=0': '=',
-	    '=2': ':'
-	  };
-	  var keySubstring = key[0] === '.' && key[1] === '$' ? key.substring(2) : key.substring(1);
-
-	  return ('' + keySubstring).replace(unescapeRegex, function (match) {
-	    return unescaperLookup[match];
-	  });
-	}
-
-	var KeyEscapeUtils = {
-	  escape: escape,
-	  unescape: unescape
-	};
-
-	module.exports = KeyEscapeUtils;
-
-/***/ },
-/* 18 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(7);
-
-	var ReactNoopUpdateQueue = __webpack_require__(19);
-
-	var canDefineProperty = __webpack_require__(13);
-	var emptyObject = __webpack_require__(20);
-	var invariant = __webpack_require__(8);
-	var warning = __webpack_require__(11);
-
-	/**
-	 * Base class helpers for the updating state of a component.
-	 */
-	function ReactComponent(props, context, updater) {
-	  this.props = props;
-	  this.context = context;
-	  this.refs = emptyObject;
-	  // We initialize the default updater but the real one gets injected by the
-	  // renderer.
-	  this.updater = updater || ReactNoopUpdateQueue;
-	}
-
-	ReactComponent.prototype.isReactComponent = {};
-
-	/**
-	 * Sets a subset of the state. Always use this 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.
-	 *
-	 * There is no guarantee that calls to `setState` will run synchronously,
-	 * as they may eventually be batched together.  You can provide an optional
-	 * callback that will be executed when the call to setState is actually
-	 * completed.
-	 *
-	 * When a function is provided to setState, it will be called at some point in
-	 * the future (not synchronously). It will be called with the up to date
-	 * component arguments (state, props, context). These values can be different
-	 * from this.* because your function may be called after receiveProps but before
-	 * shouldComponentUpdate, and this new state, props, and context will not yet be
-	 * assigned to this.
-	 *
-	 * @param {object|function} partialState Next partial state or function to
-	 *        produce next partial state to be merged with current state.
-	 * @param {?function} callback Called after state is updated.
-	 * @final
-	 * @protected
-	 */
-	ReactComponent.prototype.setState = function (partialState, callback) {
-	  !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'setState(...): takes an object of state variables to update or a function which returns an object of state variables.') : _prodInvariant('85') : void 0;
-	  this.updater.enqueueSetState(this, partialState);
-	  if (callback) {
-	    this.updater.enqueueCallback(this, callback, 'setState');
-	  }
-	};
-
-	/**
-	 * 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 `shouldComponentUpdate`, but it will invoke
-	 * `componentWillUpdate` and `componentDidUpdate`.
-	 *
-	 * @param {?function} callback Called after update is complete.
-	 * @final
-	 * @protected
-	 */
-	ReactComponent.prototype.forceUpdate = function (callback) {
-	  this.updater.enqueueForceUpdate(this);
-	  if (callback) {
-	    this.updater.enqueueCallback(this, callback, 'forceUpdate');
-	  }
-	};
-
-	/**
-	 * Deprecated APIs. These APIs used to exist on classic React classes but since
-	 * we would like to deprecate them, we're not going to move them over to this
-	 * modern base class. Instead, we define a getter that warns if it's accessed.
-	 */
-	if (process.env.NODE_ENV !== 'production') {
-	  var deprecatedAPIs = {
-	    isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],
-	    replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']
-	  };
-	  var defineDeprecationWarning = function (methodName, info) {
-	    if (canDefineProperty) {
-	      Object.defineProperty(ReactComponent.prototype, methodName, {
-	        get: function () {
-	          process.env.NODE_ENV !== 'production' ? warning(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]) : void 0;
-	          return undefined;
-	        }
-	      });
-	    }
-	  };
-	  for (var fnName in deprecatedAPIs) {
-	    if (deprecatedAPIs.hasOwnProperty(fnName)) {
-	      defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
-	    }
-	  }
-	}
-
-	module.exports = ReactComponent;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 19 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2015-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var warning = __webpack_require__(11);
-
-	function warnNoop(publicInstance, callerName) {
-	  if (process.env.NODE_ENV !== 'production') {
-	    var constructor = publicInstance.constructor;
-	    process.env.NODE_ENV !== 'production' ? warning(false, '%s(...): Can only update a mounted or mounting component. ' + 'This usually means you called %s() on an unmounted component. ' + 'This is a no-op. Please check the code for the %s component.', callerName, callerName, constructor && (constructor.displayName || constructor.name) || 'ReactClass') : void 0;
-	  }
-	}
-
-	/**
-	 * This is the abstract API for an update queue.
-	 */
-	var ReactNoopUpdateQueue = {
-
-	  /**
-	   * Checks whether or not this composite component is mounted.
-	   * @param {ReactClass} publicInstance The instance we want to test.
-	   * @return {boolean} True if mounted, false otherwise.
-	   * @protected
-	   * @final
-	   */
-	  isMounted: function (publicInstance) {
-	    return false;
-	  },
-
-	  /**
-	   * Enqueue a callback that will be executed after all the pending updates
-	   * have processed.
-	   *
-	   * @param {ReactClass} publicInstance The instance to use as `this` context.
-	   * @param {?function} callback Called after state is updated.
-	   * @internal
-	   */
-	  enqueueCallback: function (publicInstance, callback) {},
-
-	  /**
-	   * 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 `shouldComponentUpdate`, but it will invoke
-	   * `componentWillUpdate` and `componentDidUpdate`.
-	   *
-	   * @param {ReactClass} publicInstance The instance that should rerender.
-	   * @internal
-	   */
-	  enqueueForceUpdate: function (publicInstance) {
-	    warnNoop(publicInstance, 'forceUpdate');
-	  },
-
-	  /**
-	   * 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 {ReactClass} publicInstance The instance that should rerender.
-	   * @param {object} completeState Next state.
-	   * @internal
-	   */
-	  enqueueReplaceState: function (publicInstance, completeState) {
-	    warnNoop(publicInstance, 'replaceState');
-	  },
-
-	  /**
-	   * Sets a subset of the state. This only exists because _pendingState is
-	   * internal. This provides a merging strategy that is not available to deep
-	   * properties which is confusing. TODO: Expose pendingState or don't use it
-	   * during the merge.
-	   *
-	   * @param {ReactClass} publicInstance The instance that should rerender.
-	   * @param {object} partialState Next partial state to be merged with state.
-	   * @internal
-	   */
-	  enqueueSetState: function (publicInstance, partialState) {
-	    warnNoop(publicInstance, 'setState');
-	  }
-	};
-
-	module.exports = ReactNoopUpdateQueue;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 20 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var emptyObject = {};
-
-	if (process.env.NODE_ENV !== 'production') {
-	  Object.freeze(emptyObject);
-	}
-
-	module.exports = emptyObject;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 21 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _assign = __webpack_require__(4);
-
-	var ReactComponent = __webpack_require__(18);
-	var ReactNoopUpdateQueue = __webpack_require__(19);
-
-	var emptyObject = __webpack_require__(20);
-
-	/**
-	 * Base class helpers for the updating state of a component.
-	 */
-	function ReactPureComponent(props, context, updater) {
-	  // Duplicated from ReactComponent.
-	  this.props = props;
-	  this.context = context;
-	  this.refs = emptyObject;
-	  // We initialize the default updater but the real one gets injected by the
-	  // renderer.
-	  this.updater = updater || ReactNoopUpdateQueue;
-	}
-
-	function ComponentDummy() {}
-	ComponentDummy.prototype = ReactComponent.prototype;
-	ReactPureComponent.prototype = new ComponentDummy();
-	ReactPureComponent.prototype.constructor = ReactPureComponent;
-	// Avoid an extra prototype jump for these methods.
-	_assign(ReactPureComponent.prototype, ReactComponent.prototype);
-	ReactPureComponent.prototype.isPureReactComponent = true;
-
-	module.exports = ReactPureComponent;
-
-/***/ },
-/* 22 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(7),
-	    _assign = __webpack_require__(4);
-
-	var ReactComponent = __webpack_require__(18);
-	var ReactElement = __webpack_require__(9);
-	var ReactPropTypeLocationNames = __webpack_require__(23);
-	var ReactNoopUpdateQueue = __webpack_require__(19);
-
-	var emptyObject = __webpack_require__(20);
-	var invariant = __webpack_require__(8);
-	var warning = __webpack_require__(11);
-
-	var MIXINS_KEY = 'mixins';
-
-	// Helper function to allow the creation of anonymous functions which do not
-	// have .name set to the name of the variable being assigned to.
-	function identity(fn) {
-	  return fn;
-	}
-
-	/**
-	 * Policies that describe methods in `ReactClassInterface`.
-	 */
-
-
-	var injectedMixins = [];
-
-	/**
-	 * Composite components are higher-level components that compose other composite
-	 * or host components.
-	 *
-	 * To create a new type of `ReactClass`, 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 `ReactClassInterface` for
-	 * more the comprehensive protocol. Any other properties and methods in the
-	 * class specification will be available on the prototype.
-	 *
-	 * @interface ReactClassInterface
-	 * @internal
-	 */
-	var ReactClassInterface = {
-
-	  /**
-	   * An array of Mixin objects to include when defining your component.
-	   *
-	   * @type {array}
-	   * @optional
-	   */
-	  mixins: 'DEFINE_MANY',
-
-	  /**
-	   * An object containing properties and methods that should be defined on
-	   * the component's constructor instead of its prototype (static methods).
-	   *
-	   * @type {object}
-	   * @optional
-	   */
-	  statics: 'DEFINE_MANY',
-
-	  /**
-	   * Definition of prop types for this component.
-	   *
-	   * @type {object}
-	   * @optional
-	   */
-	  propTypes: 'DEFINE_MANY',
-
-	  /**
-	   * Definition of context types for this component.
-	   *
-	   * @type {object}
-	   * @optional
-	   */
-	  contextTypes: 'DEFINE_MANY',
-
-	  /**
-	   * Definition of context types this component sets for its children.
-	   *
-	   * @type {object}
-	   * @optional
-	   */
-	  childContextTypes: 'DEFINE_MANY',
-
-	  // ==== Definition methods ====
-
-	  /**
-	   * 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`.
-	   *
-	   * @return {object}
-	   * @optional
-	   */
-	  getDefaultProps: 'DEFINE_MANY_MERGED',
-
-	  /**
-	   * 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: 'DEFINE_MANY_MERGED',
-
-	  /**
-	   * @return {object}
-	   * @optional
-	   */
-	  getChildContext: 'DEFINE_MANY_MERGED',
-
-	  /**
-	   * 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: '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: '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: '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, nextContext) {
-	   *     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: 'DEFINE_MANY',
-
-	  /**
-	   * Invoked while deciding if the component should be updated as a result of
-	   * receiving new props, state and/or context.
-	   *
-	   * Use this as an opportunity to `return false` when you're certain that the
-	   * transition to the new props/state/context will not require a component
-	   * update.
-	   *
-	   *   shouldComponentUpdate: function(nextProps, nextState, nextContext) {
-	   *     return !equal(nextProps, this.props) ||
-	   *       !equal(nextState, this.state) ||
-	   *       !equal(nextContext, this.context);
-	   *   }
-	   *
-	   * @param {object} nextProps
-	   * @param {?object} nextState
-	   * @param {?object} nextContext
-	   * @return {boolean} True if the component should update.
-	   * @optional
-	   */
-	  shouldComponentUpdate: 'DEFINE_ONCE',
-
-	  /**
-	   * Invoked when the component is about to update due to a transition from
-	   * `this.props`, `this.state` and `this.context` to `nextProps`, `nextState`
-	   * and `nextContext`.
-	   *
-	   * 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 {?object} nextContext
-	   * @param {ReactReconcileTransaction} transaction
-	   * @optional
-	   */
-	  componentWillUpdate: '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 {?object} prevContext
-	   * @param {DOMElement} rootNode DOM element representing the component.
-	   * @optional
-	   */
-	  componentDidUpdate: '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: '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: 'OVERRIDE_BASE'
-
-	};
-
-	/**
-	 * Mapping from class specification keys to special processing functions.
-	 *
-	 * Although these are declared like instance properties in the specification
-	 * when defining classes using `React.createClass`, they are actually static
-	 * and are accessible on the constructor instead of the prototype. Despite
-	 * being static, they must be defined outside of the "statics" key under
-	 * which all other static methods are defined.
-	 */
-	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]);
-	      }
-	    }
-	  },
-	  childContextTypes: function (Constructor, childContextTypes) {
-	    if (process.env.NODE_ENV !== 'production') {
-	      validateTypeDef(Constructor, childContextTypes, 'childContext');
-	    }
-	    Constructor.childContextTypes = _assign({}, Constructor.childContextTypes, childContextTypes);
-	  },
-	  contextTypes: function (Constructor, contextTypes) {
-	    if (process.env.NODE_ENV !== 'production') {
-	      validateTypeDef(Constructor, contextTypes, 'context');
-	    }
-	    Constructor.contextTypes = _assign({}, Constructor.contextTypes, contextTypes);
-	  },
-	  /**
-	   * Special case getDefaultProps which should move into statics but requires
-	   * automatic merging.
-	   */
-	  getDefaultProps: function (Constructor, getDefaultProps) {
-	    if (Constructor.getDefaultProps) {
-	      Constructor.getDefaultProps = createMergedResultFunction(Constructor.getDefaultProps, getDefaultProps);
-	    } else {
-	      Constructor.getDefaultProps = getDefaultProps;
-	    }
-	  },
-	  propTypes: function (Constructor, propTypes) {
-	    if (process.env.NODE_ENV !== 'production') {
-	      validateTypeDef(Constructor, propTypes, 'prop');
-	    }
-	    Constructor.propTypes = _assign({}, Constructor.propTypes, propTypes);
-	  },
-	  statics: function (Constructor, statics) {
-	    mixStaticSpecIntoComponent(Constructor, statics);
-	  },
-	  autobind: function () {} };
-
-	function validateTypeDef(Constructor, typeDef, location) {
-	  for (var propName in typeDef) {
-	    if (typeDef.hasOwnProperty(propName)) {
-	      // use a warning instead of an invariant so components
-	      // don't show up in prod but only in __DEV__
-	      process.env.NODE_ENV !== 'production' ? warning(typeof typeDef[propName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'React.PropTypes.', Constructor.displayName || 'ReactClass', ReactPropTypeLocationNames[location], propName) : void 0;
-	    }
-	  }
-	}
-
-	function validateMethodOverride(isAlreadyDefined, name) {
-	  var specPolicy = ReactClassInterface.hasOwnProperty(name) ? ReactClassInterface[name] : null;
-
-	  // Disallow overriding of base class methods unless explicitly allowed.
-	  if (ReactClassMixin.hasOwnProperty(name)) {
-	    !(specPolicy === 'OVERRIDE_BASE') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClassInterface: You are attempting to override `%s` from your class specification. Ensure that your method names do not overlap with React methods.', name) : _prodInvariant('73', name) : void 0;
-	  }
-
-	  // Disallow defining methods more than once unless explicitly allowed.
-	  if (isAlreadyDefined) {
-	    !(specPolicy === 'DEFINE_MANY' || specPolicy === 'DEFINE_MANY_MERGED') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClassInterface: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.', name) : _prodInvariant('74', name) : void 0;
-	  }
-	}
-
-	/**
-	 * Mixin helper which handles policy validation and reserved
-	 * specification keys when building React classes.
-	 */
-	function mixSpecIntoComponent(Constructor, spec) {
-	  if (!spec) {
-	    if (process.env.NODE_ENV !== 'production') {
-	      var typeofSpec = typeof spec;
-	      var isMixinValid = typeofSpec === 'object' && spec !== null;
-
-	      process.env.NODE_ENV !== 'production' ? warning(isMixinValid, '%s: You\'re attempting to include a mixin that is either null ' + 'or not an object. Check the mixins included by the component, ' + 'as well as any mixins they include themselves. ' + 'Expected object but got %s.', Constructor.displayName || 'ReactClass', spec === null ? null : typeofSpec) : void 0;
-	    }
-
-	    return;
-	  }
-
-	  !(typeof spec !== 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: You\'re attempting to use a component class or function as a mixin. Instead, just use a regular object.') : _prodInvariant('75') : void 0;
-	  !!ReactElement.isValidElement(spec) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: You\'re attempting to use a component as a mixin. Instead, just use a regular object.') : _prodInvariant('76') : void 0;
-
-	  var proto = Constructor.prototype;
-	  var autoBindPairs = proto.__reactAutoBindPairs;
-
-	  // By handling mixins before any other properties, we ensure the same
-	  // chaining order is applied to methods with DEFINE_MANY policy, whether
-	  // mixins are listed before or after these methods in the spec.
-	  if (spec.hasOwnProperty(MIXINS_KEY)) {
-	    RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins);
-	  }
-
-	  for (var name in spec) {
-	    if (!spec.hasOwnProperty(name)) {
-	      continue;
-	    }
-
-	    if (name === MIXINS_KEY) {
-	      // We have already handled mixins in a special case above.
-	      continue;
-	    }
-
-	    var property = spec[name];
-	    var isAlreadyDefined = proto.hasOwnProperty(name);
-	    validateMethodOverride(isAlreadyDefined, name);
-
-	    if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {
-	      RESERVED_SPEC_KEYS[name](Constructor, property);
-	    } else {
-	      // Setup methods on prototype:
-	      // The following member methods should not be automatically bound:
-	      // 1. Expected ReactClass methods (in the "interface").
-	      // 2. Overridden methods (that were mixed in).
-	      var isReactClassMethod = ReactClassInterface.hasOwnProperty(name);
-	      var isFunction = typeof property === 'function';
-	      var shouldAutoBind = isFunction && !isReactClassMethod && !isAlreadyDefined && spec.autobind !== false;
-
-	      if (shouldAutoBind) {
-	        autoBindPairs.push(name, property);
-	        proto[name] = property;
-	      } else {
-	        if (isAlreadyDefined) {
-	          var specPolicy = ReactClassInterface[name];
-
-	          // These cases should already be caught by validateMethodOverride.
-	          !(isReactClassMethod && (specPolicy === 'DEFINE_MANY_MERGED' || specPolicy === 'DEFINE_MANY')) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: Unexpected spec policy %s for key %s when mixing in component specs.', specPolicy, name) : _prodInvariant('77', specPolicy, name) : void 0;
-
-	          // For methods which are defined more than once, call the existing
-	          // methods before calling the new property, merging if appropriate.
-	          if (specPolicy === 'DEFINE_MANY_MERGED') {
-	            proto[name] = createMergedResultFunction(proto[name], property);
-	          } else if (specPolicy === 'DEFINE_MANY') {
-	            proto[name] = createChainedFunction(proto[name], property);
-	          }
-	        } else {
-	          proto[name] = property;
-	          if (process.env.NODE_ENV !== 'production') {
-	            // Add verbose displayName to the function, which helps when looking
-	            // at profiling tools.
-	            if (typeof property === 'function' && spec.displayName) {
-	              proto[name].displayName = spec.displayName + '_' + name;
-	            }
-	          }
-	        }
-	      }
-	    }
-	  }
-	}
-
-	function mixStaticSpecIntoComponent(Constructor, statics) {
-	  if (!statics) {
-	    return;
-	  }
-	  for (var name in statics) {
-	    var property = statics[name];
-	    if (!statics.hasOwnProperty(name)) {
-	      continue;
-	    }
-
-	    var isReserved = name in RESERVED_SPEC_KEYS;
-	    !!isReserved ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: You are attempting to define a reserved property, `%s`, that shouldn\'t be on the "statics" key. Define it as an instance property instead; it will still be accessible on the constructor.', name) : _prodInvariant('78', name) : void 0;
-
-	    var isInherited = name in Constructor;
-	    !!isInherited ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactClass: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.', name) : _prodInvariant('79', name) : void 0;
-	    Constructor[name] = property;
-	  }
-	}
-
-	/**
-	 * Merge two objects, but throw if both contain the same key.
-	 *
-	 * @param {object} one The first object, which is mutated.
-	 * @param {object} two The second object
-	 * @return {object} one after it has been mutated to contain everything in two.
-	 */
-	function mergeIntoWithNoDuplicateKeys(one, two) {
-	  !(one && two && typeof one === 'object' && typeof two === 'object') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.') : _prodInvariant('80') : void 0;
-
-	  for (var key in two) {
-	    if (two.hasOwnProperty(key)) {
-	      !(one[key] === undefined) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'mergeIntoWithNoDuplicateKeys(): Tried to merge two objects with the same key: `%s`. This conflict may be due to a mixin; in particular, this may be caused by two getInitialState() or getDefaultProps() methods returning objects with clashing keys.', key) : _prodInvariant('81', key) : void 0;
-	      one[key] = two[key];
-	    }
-	  }
-	  return one;
-	}
-
-	/**
-	 * Creates a function that invokes two functions and merges their return values.
-	 *
-	 * @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 createMergedResultFunction(one, two) {
-	  return function mergedResult() {
-	    var a = one.apply(this, arguments);
-	    var b = two.apply(this, arguments);
-	    if (a == null) {
-	      return b;
-	    } else if (b == null) {
-	      return a;
-	    }
-	    var c = {};
-	    mergeIntoWithNoDuplicateKeys(c, a);
-	    mergeIntoWithNoDuplicateKeys(c, b);
-	    return c;
-	  };
-	}
-
-	/**
-	 * 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() {
-	    one.apply(this, arguments);
-	    two.apply(this, arguments);
-	  };
-	}
-
-	/**
-	 * Binds a method to the component.
-	 *
-	 * @param {object} component Component whose method is going to be bound.
-	 * @param {function} method Method to be bound.
-	 * @return {function} The bound method.
-	 */
-	function bindAutoBindMethod(component, method) {
-	  var boundMethod = method.bind(component);
-	  if (process.env.NODE_ENV !== 'production') {
-	    boundMethod.__reactBoundContext = component;
-	    boundMethod.__reactBoundMethod = method;
-	    boundMethod.__reactBoundArguments = null;
-	    var componentName = component.constructor.displayName;
-	    var _bind = boundMethod.bind;
-	    boundMethod.bind = function (newThis) {
-	      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-	        args[_key - 1] = arguments[_key];
-	      }
-
-	      // User is trying to bind() an autobound method; we effectively will
-	      // ignore the value of "this" that the user is trying to use, so
-	      // let's warn.
-	      if (newThis !== component && newThis !== null) {
-	        process.env.NODE_ENV !== 'production' ? warning(false, 'bind(): React component methods may only be bound to the ' + 'component instance. See %s', componentName) : void 0;
-	      } else if (!args.length) {
-	        process.env.NODE_ENV !== 'production' ? warning(false, 'bind(): You are binding a component method to the component. ' + 'React does this for you automatically in a high-performance ' + 'way, so you can safely remove this call. See %s', componentName) : void 0;
-	        return boundMethod;
-	      }
-	      var reboundMethod = _bind.apply(boundMethod, arguments);
-	      reboundMethod.__reactBoundContext = component;
-	      reboundMethod.__reactBoundMethod = method;
-	      reboundMethod.__reactBoundArguments = args;
-	      return reboundMethod;
-	    };
-	  }
-	  return boundMethod;
-	}
-
-	/**
-	 * Binds all auto-bound methods in a component.
-	 *
-	 * @param {object} component Component whose method is going to be bound.
-	 */
-	function bindAutoBindMethods(component) {
-	  var pairs = component.__reactAutoBindPairs;
-	  for (var i = 0; i < pairs.length; i += 2) {
-	    var autoBindKey = pairs[i];
-	    var method = pairs[i + 1];
-	    component[autoBindKey] = bindAutoBindMethod(component, method);
-	  }
-	}
-
-	/**
-	 * Add more to the ReactClass base class. These are all legacy features and
-	 * therefore not already part of the modern ReactComponent.
-	 */
-	var ReactClassMixin = {
-
-	  /**
-	   * TODO: This will be deprecated because state should always keep a consistent
-	   * type signature and the only use case for this, is to avoid that.
-	   */
-	  replaceState: function (newState, callback) {
-	    this.updater.enqueueReplaceState(this, newState);
-	    if (callback) {
-	      this.updater.enqueueCallback(this, callback, 'replaceState');
-	    }
-	  },
-
-	  /**
-	   * Checks whether or not this composite component is mounted.
-	   * @return {boolean} True if mounted, false otherwise.
-	   * @protected
-	   * @final
-	   */
-	  isMounted: function () {
-	    return this.updater.isMounted(this);
-	  }
-	};
-
-	var ReactClassComponent = function () {};
-	_assign(ReactClassComponent.prototype, ReactComponent.prototype, ReactClassMixin);
-
-	/**
-	 * Module for creating composite components.
-	 *
-	 * @class ReactClass
-	 */
-	var ReactClass = {
-
-	  /**
-	   * Creates a composite component class given a class specification.
-	   * See https://facebook.github.io/react/docs/top-level-api.html#react.createclass
-	   *
-	   * @param {object} spec Class specification (which must define `render`).
-	   * @return {function} Component constructor function.
-	   * @public
-	   */
-	  createClass: function (spec) {
-	    // To keep our warnings more understandable, we'll use a little hack here to
-	    // ensure that Constructor.name !== 'Constructor'. This makes sure we don't
-	    // unnecessarily identify a class without displayName as 'Constructor'.
-	    var Constructor = identity(function (props, context, updater) {
-	      // This constructor gets overridden by mocks. The argument is used
-	      // by mocks to assert on what gets mounted.
-
-	      if (process.env.NODE_ENV !== 'production') {
-	        process.env.NODE_ENV !== 'production' ? warning(this instanceof Constructor, 'Something is calling a React component directly. Use a factory or ' + 'JSX instead. See: https://fb.me/react-legacyfactory') : void 0;
-	      }
-
-	      // Wire up auto-binding
-	      if (this.__reactAutoBindPairs.length) {
-	        bindAutoBindMethods(this);
-	      }
-
-	      this.props = props;
-	      this.context = context;
-	      this.refs = emptyObject;
-	      this.updater = updater || ReactNoopUpdateQueue;
-
-	      this.state = null;
-
-	      // ReactClasses doesn't have constructors. Instead, they use the
-	      // getInitialState and componentWillMount methods for initialization.
-
-	      var initialState = this.getInitialState ? this.getInitialState() : null;
-	      if (process.env.NODE_ENV !== 'production') {
-	        // We allow auto-mocks to proceed as if they're returning null.
-	        if (initialState === undefined && this.getInitialState._isMockFunction) {
-	          // This is probably bad practice. Consider warning here and
-	          // deprecating this convenience.
-	          initialState = null;
-	        }
-	      }
-	      !(typeof initialState === 'object' && !Array.isArray(initialState)) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.getInitialState(): must return an object or null', Constructor.displayName || 'ReactCompositeComponent') : _prodInvariant('82', Constructor.displayName || 'ReactCompositeComponent') : void 0;
-
-	      this.state = initialState;
-	    });
-	    Constructor.prototype = new ReactClassComponent();
-	    Constructor.prototype.constructor = Constructor;
-	    Constructor.prototype.__reactAutoBindPairs = [];
-
-	    injectedMixins.forEach(mixSpecIntoComponent.bind(null, Constructor));
-
-	    mixSpecIntoComponent(Constructor, spec);
-
-	    // Initialize the defaultProps property after all mixins have been merged.
-	    if (Constructor.getDefaultProps) {
-	      Constructor.defaultProps = Constructor.getDefaultProps();
-	    }
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      // This is a tag to indicate that the use of these method names is ok,
-	      // since it's used with createClass. If it's not, then it's likely a
-	      // mistake so we'll warn you to use the static property, property
-	      // initializer or constructor respectively.
-	      if (Constructor.getDefaultProps) {
-	        Constructor.getDefaultProps.isReactClassApproved = {};
-	      }
-	      if (Constructor.prototype.getInitialState) {
-	        Constructor.prototype.getInitialState.isReactClassApproved = {};
-	      }
-	    }
-
-	    !Constructor.prototype.render ? process.env.NODE_ENV !== 'production' ? invariant(false, 'createClass(...): Class specification must implement a `render` method.') : _prodInvariant('83') : void 0;
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      process.env.NODE_ENV !== 'production' ? warning(!Constructor.prototype.componentShouldUpdate, '%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', spec.displayName || 'A component') : void 0;
-	      process.env.NODE_ENV !== 'production' ? warning(!Constructor.prototype.componentWillRecieveProps, '%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', spec.displayName || 'A component') : void 0;
-	    }
-
-	    // Reduce time spent doing lookups by setting these on the prototype.
-	    for (var methodName in ReactClassInterface) {
-	      if (!Constructor.prototype[methodName]) {
-	        Constructor.prototype[methodName] = null;
-	      }
-	    }
-
-	    return Constructor;
-	  },
-
-	  injection: {
-	    injectMixin: function (mixin) {
-	      injectedMixins.push(mixin);
-	    }
-	  }
-
-	};
-
-	module.exports = ReactClass;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 23 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var ReactPropTypeLocationNames = {};
-
-	if (process.env.NODE_ENV !== 'production') {
-	  ReactPropTypeLocationNames = {
-	    prop: 'prop',
-	    context: 'context',
-	    childContext: 'child context'
-	  };
-	}
-
-	module.exports = ReactPropTypeLocationNames;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 24 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ReactElement = __webpack_require__(9);
-
-	/**
-	 * Create a factory that creates HTML tag elements.
-	 *
-	 * @private
-	 */
-	var createDOMFactory = ReactElement.createFactory;
-	if (process.env.NODE_ENV !== 'production') {
-	  var ReactElementValidator = __webpack_require__(25);
-	  createDOMFactory = ReactElementValidator.createFactory;
-	}
-
-	/**
-	 * Creates a mapping from supported HTML tags to `ReactDOMComponent` classes.
-	 * This is also accessible via `React.DOM`.
-	 *
-	 * @public
-	 */
-	var ReactDOMFactories = {
-	  a: createDOMFactory('a'),
-	  abbr: createDOMFactory('abbr'),
-	  address: createDOMFactory('address'),
-	  area: createDOMFactory('area'),
-	  article: createDOMFactory('article'),
-	  aside: createDOMFactory('aside'),
-	  audio: createDOMFactory('audio'),
-	  b: createDOMFactory('b'),
-	  base: createDOMFactory('base'),
-	  bdi: createDOMFactory('bdi'),
-	  bdo: createDOMFactory('bdo'),
-	  big: createDOMFactory('big'),
-	  blockquote: createDOMFactory('blockquote'),
-	  body: createDOMFactory('body'),
-	  br: createDOMFactory('br'),
-	  button: createDOMFactory('button'),
-	  canvas: createDOMFactory('canvas'),
-	  caption: createDOMFactory('caption'),
-	  cite: createDOMFactory('cite'),
-	  code: createDOMFactory('code'),
-	  col: createDOMFactory('col'),
-	  colgroup: createDOMFactory('colgroup'),
-	  data: createDOMFactory('data'),
-	  datalist: createDOMFactory('datalist'),
-	  dd: createDOMFactory('dd'),
-	  del: createDOMFactory('del'),
-	  details: createDOMFactory('details'),
-	  dfn: createDOMFactory('dfn'),
-	  dialog: createDOMFactory('dialog'),
-	  div: createDOMFactory('div'),
-	  dl: createDOMFactory('dl'),
-	  dt: createDOMFactory('dt'),
-	  em: createDOMFactory('em'),
-	  embed: createDOMFactory('embed'),
-	  fieldset: createDOMFactory('fieldset'),
-	  figcaption: createDOMFactory('figcaption'),
-	  figure: createDOMFactory('figure'),
-	  footer: createDOMFactory('footer'),
-	  form: createDOMFactory('form'),
-	  h1: createDOMFactory('h1'),
-	  h2: createDOMFactory('h2'),
-	  h3: createDOMFactory('h3'),
-	  h4: createDOMFactory('h4'),
-	  h5: createDOMFactory('h5'),
-	  h6: createDOMFactory('h6'),
-	  head: createDOMFactory('head'),
-	  header: createDOMFactory('header'),
-	  hgroup: createDOMFactory('hgroup'),
-	  hr: createDOMFactory('hr'),
-	  html: createDOMFactory('html'),
-	  i: createDOMFactory('i'),
-	  iframe: createDOMFactory('iframe'),
-	  img: createDOMFactory('img'),
-	  input: createDOMFactory('input'),
-	  ins: createDOMFactory('ins'),
-	  kbd: createDOMFactory('kbd'),
-	  keygen: createDOMFactory('keygen'),
-	  label: createDOMFactory('label'),
-	  legend: createDOMFactory('legend'),
-	  li: createDOMFactory('li'),
-	  link: createDOMFactory('link'),
-	  main: createDOMFactory('main'),
-	  map: createDOMFactory('map'),
-	  mark: createDOMFactory('mark'),
-	  menu: createDOMFactory('menu'),
-	  menuitem: createDOMFactory('menuitem'),
-	  meta: createDOMFactory('meta'),
-	  meter: createDOMFactory('meter'),
-	  nav: createDOMFactory('nav'),
-	  noscript: createDOMFactory('noscript'),
-	  object: createDOMFactory('object'),
-	  ol: createDOMFactory('ol'),
-	  optgroup: createDOMFactory('optgroup'),
-	  option: createDOMFactory('option'),
-	  output: createDOMFactory('output'),
-	  p: createDOMFactory('p'),
-	  param: createDOMFactory('param'),
-	  picture: createDOMFactory('picture'),
-	  pre: createDOMFactory('pre'),
-	  progress: createDOMFactory('progress'),
-	  q: createDOMFactory('q'),
-	  rp: createDOMFactory('rp'),
-	  rt: createDOMFactory('rt'),
-	  ruby: createDOMFactory('ruby'),
-	  s: createDOMFactory('s'),
-	  samp: createDOMFactory('samp'),
-	  script: createDOMFactory('script'),
-	  section: createDOMFactory('section'),
-	  select: createDOMFactory('select'),
-	  small: createDOMFactory('small'),
-	  source: createDOMFactory('source'),
-	  span: createDOMFactory('span'),
-	  strong: createDOMFactory('strong'),
-	  style: createDOMFactory('style'),
-	  sub: createDOMFactory('sub'),
-	  summary: createDOMFactory('summary'),
-	  sup: createDOMFactory('sup'),
-	  table: createDOMFactory('table'),
-	  tbody: createDOMFactory('tbody'),
-	  td: createDOMFactory('td'),
-	  textarea: createDOMFactory('textarea'),
-	  tfoot: createDOMFactory('tfoot'),
-	  th: createDOMFactory('th'),
-	  thead: createDOMFactory('thead'),
-	  time: createDOMFactory('time'),
-	  title: createDOMFactory('title'),
-	  tr: createDOMFactory('tr'),
-	  track: createDOMFactory('track'),
-	  u: createDOMFactory('u'),
-	  ul: createDOMFactory('ul'),
-	  'var': createDOMFactory('var'),
-	  video: createDOMFactory('video'),
-	  wbr: createDOMFactory('wbr'),
-
-	  // SVG
-	  circle: createDOMFactory('circle'),
-	  clipPath: createDOMFactory('clipPath'),
-	  defs: createDOMFactory('defs'),
-	  ellipse: createDOMFactory('ellipse'),
-	  g: createDOMFactory('g'),
-	  image: createDOMFactory('image'),
-	  line: createDOMFactory('line'),
-	  linearGradient: createDOMFactory('linearGradient'),
-	  mask: createDOMFactory('mask'),
-	  path: createDOMFactory('path'),
-	  pattern: createDOMFactory('pattern'),
-	  polygon: createDOMFactory('polygon'),
-	  polyline: createDOMFactory('polyline'),
-	  radialGradient: createDOMFactory('radialGradient'),
-	  rect: createDOMFactory('rect'),
-	  stop: createDOMFactory('stop'),
-	  svg: createDOMFactory('svg'),
-	  text: createDOMFactory('text'),
-	  tspan: createDOMFactory('tspan')
-	};
-
-	module.exports = ReactDOMFactories;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 25 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2014-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	/**
-	 * ReactElementValidator provides a wrapper around a element factory
-	 * which validates the props passed to the element. This is intended to be
-	 * used only in DEV and could be replaced by a static type checker for languages
-	 * that support it.
-	 */
-
-	'use strict';
-
-	var ReactCurrentOwner = __webpack_require__(10);
-	var ReactComponentTreeHook = __webpack_require__(26);
-	var ReactElement = __webpack_require__(9);
-
-	var checkReactTypeSpec = __webpack_require__(27);
-
-	var canDefineProperty = __webpack_require__(13);
-	var getIteratorFn = __webpack_require__(16);
-	var warning = __webpack_require__(11);
-
-	function getDeclarationErrorAddendum() {
-	  if (ReactCurrentOwner.current) {
-	    var name = ReactCurrentOwner.current.getName();
-	    if (name) {
-	      return ' Check the render method of `' + name + '`.';
-	    }
-	  }
-	  return '';
-	}
-
-	/**
-	 * Warn if there's no key explicitly set on dynamic arrays of children or
-	 * object keys are not valid. This allows us to keep track of children between
-	 * updates.
-	 */
-	var ownerHasKeyUseWarning = {};
-
-	function getCurrentComponentErrorInfo(parentType) {
-	  var info = getDeclarationErrorAddendum();
-
-	  if (!info) {
-	    var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;
-	    if (parentName) {
-	      info = ' Check the top-level render call using <' + parentName + '>.';
-	    }
-	  }
-	  return info;
-	}
-
-	/**
-	 * Warn if the element doesn't have an explicit key assigned to it.
-	 * This element is in an array. The array could grow and shrink or be
-	 * reordered. All children that haven't already been validated are required to
-	 * have a "key" property assigned to it. Error statuses are cached so a warning
-	 * will only be shown once.
-	 *
-	 * @internal
-	 * @param {ReactElement} element Element that requires a key.
-	 * @param {*} parentType element's parent's type.
-	 */
-	function validateExplicitKey(element, parentType) {
-	  if (!element._store || element._store.validated || element.key != null) {
-	    return;
-	  }
-	  element._store.validated = true;
-
-	  var memoizer = ownerHasKeyUseWarning.uniqueKey || (ownerHasKeyUseWarning.uniqueKey = {});
-
-	  var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
-	  if (memoizer[currentComponentErrorInfo]) {
-	    return;
-	  }
-	  memoizer[currentComponentErrorInfo] = true;
-
-	  // 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.
-	  var childOwner = '';
-	  if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
-	    // Give the component that originally created this child.
-	    childOwner = ' It was passed a child from ' + element._owner.getName() + '.';
-	  }
-
-	  process.env.NODE_ENV !== 'production' ? warning(false, 'Each child in an array or iterator should have a unique "key" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.%s', currentComponentErrorInfo, childOwner, ReactComponentTreeHook.getCurrentStackAddendum(element)) : void 0;
-	}
-
-	/**
-	 * Ensure that every element either is passed in a static location, in an
-	 * array with an explicit keys property defined, or in an object literal
-	 * with valid key property.
-	 *
-	 * @internal
-	 * @param {ReactNode} node Statically passed child of any type.
-	 * @param {*} parentType node's parent's type.
-	 */
-	function validateChildKeys(node, parentType) {
-	  if (typeof node !== 'object') {
-	    return;
-	  }
-	  if (Array.isArray(node)) {
-	    for (var i = 0; i < node.length; i++) {
-	      var child = node[i];
-	      if (ReactElement.isValidElement(child)) {
-	        validateExplicitKey(child, parentType);
-	      }
-	    }
-	  } else if (ReactElement.isValidElement(node)) {
-	    // This element was passed in a valid location.
-	    if (node._store) {
-	      node._store.validated = true;
-	    }
-	  } else if (node) {
-	    var iteratorFn = getIteratorFn(node);
-	    // Entry iterators provide implicit keys.
-	    if (iteratorFn) {
-	      if (iteratorFn !== node.entries) {
-	        var iterator = iteratorFn.call(node);
-	        var step;
-	        while (!(step = iterator.next()).done) {
-	          if (ReactElement.isValidElement(step.value)) {
-	            validateExplicitKey(step.value, parentType);
-	          }
-	        }
-	      }
-	    }
-	  }
-	}
-
-	/**
-	 * Given an element, validate that its props follow the propTypes definition,
-	 * provided by the type.
-	 *
-	 * @param {ReactElement} element
-	 */
-	function validatePropTypes(element) {
-	  var componentClass = element.type;
-	  if (typeof componentClass !== 'function') {
-	    return;
-	  }
-	  var name = componentClass.displayName || componentClass.name;
-	  if (componentClass.propTypes) {
-	    checkReactTypeSpec(componentClass.propTypes, element.props, 'prop', name, element, null);
-	  }
-	  if (typeof componentClass.getDefaultProps === 'function') {
-	    process.env.NODE_ENV !== 'production' ? warning(componentClass.getDefaultProps.isReactClassApproved, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.') : void 0;
-	  }
-	}
-
-	var ReactElementValidator = {
-
-	  createElement: function (type, props, children) {
-	    var validType = typeof type === 'string' || typeof type === 'function';
-	    // We warn in this case but don't throw. We expect the element creation to
-	    // succeed and there will likely be errors in render.
-	    if (!validType) {
-	      process.env.NODE_ENV !== 'production' ? warning(false, 'React.createElement: type should not be null, undefined, boolean, or ' + 'number. It should be a string (for DOM elements) or a ReactClass ' + '(for composite components).%s', getDeclarationErrorAddendum()) : void 0;
-	    }
-
-	    var element = ReactElement.createElement.apply(this, arguments);
-
-	    // The result can be nullish if a mock or a custom function is used.
-	    // TODO: Drop this when these are no longer allowed as the type argument.
-	    if (element == null) {
-	      return element;
-	    }
-
-	    // Skip key warning if the type isn't valid since our key validation logic
-	    // doesn't expect a non-string/function type and can throw confusing errors.
-	    // We don't want exception behavior to differ between dev and prod.
-	    // (Rendering will throw with a helpful message and as soon as the type is
-	    // fixed, the key warnings will appear.)
-	    if (validType) {
-	      for (var i = 2; i < arguments.length; i++) {
-	        validateChildKeys(arguments[i], type);
-	      }
-	    }
-
-	    validatePropTypes(element);
-
-	    return element;
-	  },
-
-	  createFactory: function (type) {
-	    var validatedFactory = ReactElementValidator.createElement.bind(null, type);
-	    // Legacy hook TODO: Warn if this is accessed
-	    validatedFactory.type = type;
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      if (canDefineProperty) {
-	        Object.defineProperty(validatedFactory, 'type', {
-	          enumerable: false,
-	          get: function () {
-	            process.env.NODE_ENV !== 'production' ? warning(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.') : void 0;
-	            Object.defineProperty(this, 'type', {
-	              value: type
-	            });
-	            return type;
-	          }
-	        });
-	      }
-	    }
-
-	    return validatedFactory;
-	  },
-
-	  cloneElement: function (element, props, children) {
-	    var newElement = ReactElement.cloneElement.apply(this, arguments);
-	    for (var i = 2; i < arguments.length; i++) {
-	      validateChildKeys(arguments[i], newElement.type);
-	    }
-	    validatePropTypes(newElement);
-	    return newElement;
-	  }
-
-	};
-
-	module.exports = ReactElementValidator;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 26 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2016-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(7);
-
-	var ReactCurrentOwner = __webpack_require__(10);
-
-	var invariant = __webpack_require__(8);
-	var warning = __webpack_require__(11);
-
-	function isNative(fn) {
-	  // Based on isNative() from Lodash
-	  var funcToString = Function.prototype.toString;
-	  var hasOwnProperty = Object.prototype.hasOwnProperty;
-	  var reIsNative = RegExp('^' + funcToString
-	  // Take an example native function source for comparison
-	  .call(hasOwnProperty)
-	  // Strip regex characters so we can use it for regex
-	  .replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
-	  // Remove hasOwnProperty from the template to make it generic
-	  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$');
-	  try {
-	    var source = funcToString.call(fn);
-	    return reIsNative.test(source);
-	  } catch (err) {
-	    return false;
-	  }
-	}
-
-	var canUseCollections =
-	// Array.from
-	typeof Array.from === 'function' &&
-	// Map
-	typeof Map === 'function' && isNative(Map) &&
-	// Map.prototype.keys
-	Map.prototype != null && typeof Map.prototype.keys === 'function' && isNative(Map.prototype.keys) &&
-	// Set
-	typeof Set === 'function' && isNative(Set) &&
-	// Set.prototype.keys
-	Set.prototype != null && typeof Set.prototype.keys === 'function' && isNative(Set.prototype.keys);
-
-	var setItem;
-	var getItem;
-	var removeItem;
-	var getItemIDs;
-	var addRoot;
-	var removeRoot;
-	var getRootIDs;
-
-	if (canUseCollections) {
-	  var itemMap = new Map();
-	  var rootIDSet = new Set();
-
-	  setItem = function (id, item) {
-	    itemMap.set(id, item);
-	  };
-	  getItem = function (id) {
-	    return itemMap.get(id);
-	  };
-	  removeItem = function (id) {
-	    itemMap['delete'](id);
-	  };
-	  getItemIDs = function () {
-	    return Array.from(itemMap.keys());
-	  };
-
-	  addRoot = function (id) {
-	    rootIDSet.add(id);
-	  };
-	  removeRoot = function (id) {
-	    rootIDSet['delete'](id);
-	  };
-	  getRootIDs = function () {
-	    return Array.from(rootIDSet.keys());
-	  };
-	} else {
-	  var itemByKey = {};
-	  var rootByKey = {};
-
-	  // Use non-numeric keys to prevent V8 performance issues:
-	  // https://github.com/facebook/react/pull/7232
-	  var getKeyFromID = function (id) {
-	    return '.' + id;
-	  };
-	  var getIDFromKey = function (key) {
-	    return parseInt(key.substr(1), 10);
-	  };
-
-	  setItem = function (id, item) {
-	    var key = getKeyFromID(id);
-	    itemByKey[key] = item;
-	  };
-	  getItem = function (id) {
-	    var key = getKeyFromID(id);
-	    return itemByKey[key];
-	  };
-	  removeItem = function (id) {
-	    var key = getKeyFromID(id);
-	    delete itemByKey[key];
-	  };
-	  getItemIDs = function () {
-	    return Object.keys(itemByKey).map(getIDFromKey);
-	  };
-
-	  addRoot = function (id) {
-	    var key = getKeyFromID(id);
-	    rootByKey[key] = true;
-	  };
-	  removeRoot = function (id) {
-	    var key = getKeyFromID(id);
-	    delete rootByKey[key];
-	  };
-	  getRootIDs = function () {
-	    return Object.keys(rootByKey).map(getIDFromKey);
-	  };
-	}
-
-	var unmountedIDs = [];
-
-	function purgeDeep(id) {
-	  var item = getItem(id);
-	  if (item) {
-	    var childIDs = item.childIDs;
-
-	    removeItem(id);
-	    childIDs.forEach(purgeDeep);
-	  }
-	}
-
-	function describeComponentFrame(name, source, ownerName) {
-	  return '\n    in ' + (name || 'Unknown') + (source ? ' (at ' + source.fileName.replace(/^.*[\\\/]/, '') + ':' + source.lineNumber + ')' : ownerName ? ' (created by ' + ownerName + ')' : '');
-	}
-
-	function getDisplayName(element) {
-	  if (element == null) {
-	    return '#empty';
-	  } else if (typeof element === 'string' || typeof element === 'number') {
-	    return '#text';
-	  } else if (typeof element.type === 'string') {
-	    return element.type;
-	  } else {
-	    return element.type.displayName || element.type.name || 'Unknown';
-	  }
-	}
-
-	function describeID(id) {
-	  var name = ReactComponentTreeHook.getDisplayName(id);
-	  var element = ReactComponentTreeHook.getElement(id);
-	  var ownerID = ReactComponentTreeHook.getOwnerID(id);
-	  var ownerName;
-	  if (ownerID) {
-	    ownerName = ReactComponentTreeHook.getDisplayName(ownerID);
-	  }
-	  process.env.NODE_ENV !== 'production' ? warning(element, 'ReactComponentTreeHook: Missing React element for debugID %s when ' + 'building stack', id) : void 0;
-	  return describeComponentFrame(name, element && element._source, ownerName);
-	}
-
-	var ReactComponentTreeHook = {
-	  onSetChildren: function (id, nextChildIDs) {
-	    var item = getItem(id);
-	    !item ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Item must have been set') : _prodInvariant('144') : void 0;
-	    item.childIDs = nextChildIDs;
-
-	    for (var i = 0; i < nextChildIDs.length; i++) {
-	      var nextChildID = nextChildIDs[i];
-	      var nextChild = getItem(nextChildID);
-	      !nextChild ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected hook events to fire for the child before its parent includes it in onSetChildren().') : _prodInvariant('140') : void 0;
-	      !(nextChild.childIDs != null || typeof nextChild.element !== 'object' || nextChild.element == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected onSetChildren() to fire for a container child before its parent includes it in onSetChildren().') : _prodInvariant('141') : void 0;
-	      !nextChild.isMounted ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected onMountComponent() to fire for the child before its parent includes it in onSetChildren().') : _prodInvariant('71') : void 0;
-	      if (nextChild.parentID == null) {
-	        nextChild.parentID = id;
-	        // TODO: This shouldn't be necessary but mounting a new root during in
-	        // componentWillMount currently causes not-yet-mounted components to
-	        // be purged from our tree data so their parent id is missing.
-	      }
-	      !(nextChild.parentID === id) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected onBeforeMountComponent() parent and onSetChildren() to be consistent (%s has parents %s and %s).', nextChildID, nextChild.parentID, id) : _prodInvariant('142', nextChildID, nextChild.parentID, id) : void 0;
-	    }
-	  },
-	  onBeforeMountComponent: function (id, element, parentID) {
-	    var item = {
-	      element: element,
-	      parentID: parentID,
-	      text: null,
-	      childIDs: [],
-	      isMounted: false,
-	      updateCount: 0
-	    };
-	    setItem(id, item);
-	  },
-	  onBeforeUpdateComponent: function (id, element) {
-	    var item = getItem(id);
-	    if (!item || !item.isMounted) {
-	      // We may end up here as a result of setState() in componentWillUnmount().
-	      // In this case, ignore the element.
-	      return;
-	    }
-	    item.element = element;
-	  },
-	  onMountComponent: function (id) {
-	    var item = getItem(id);
-	    !item ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Item must have been set') : _prodInvariant('144') : void 0;
-	    item.isMounted = true;
-	    var isRoot = item.parentID === 0;
-	    if (isRoot) {
-	      addRoot(id);
-	    }
-	  },
-	  onUpdateComponent: function (id) {
-	    var item = getItem(id);
-	    if (!item || !item.isMounted) {
-	      // We may end up here as a result of setState() in componentWillUnmount().
-	      // In this case, ignore the element.
-	      return;
-	    }
-	    item.updateCount++;
-	  },
-	  onUnmountComponent: function (id) {
-	    var item = getItem(id);
-	    if (item) {
-	      // We need to check if it exists.
-	      // `item` might not exist if it is inside an error boundary, and a sibling
-	      // error boundary child threw while mounting. Then this instance never
-	      // got a chance to mount, but it still gets an unmounting event during
-	      // the error boundary cleanup.
-	      item.isMounted = false;
-	      var isRoot = item.parentID === 0;
-	      if (isRoot) {
-	        removeRoot(id);
-	      }
-	    }
-	    unmountedIDs.push(id);
-	  },
-	  purgeUnmountedComponents: function () {
-	    if (ReactComponentTreeHook._preventPurging) {
-	      // Should only be used for testing.
-	      return;
-	    }
-
-	    for (var i = 0; i < unmountedIDs.length; i++) {
-	      var id = unmountedIDs[i];
-	      purgeDeep(id);
-	    }
-	    unmountedIDs.length = 0;
-	  },
-	  isMounted: function (id) {
-	    var item = getItem(id);
-	    return item ? item.isMounted : false;
-	  },
-	  getCurrentStackAddendum: function (topElement) {
-	    var info = '';
-	    if (topElement) {
-	      var name = getDisplayName(topElement);
-	      var owner = topElement._owner;
-	      info += describeComponentFrame(name, topElement._source, owner && owner.getName());
-	    }
-
-	    var currentOwner = ReactCurrentOwner.current;
-	    var id = currentOwner && currentOwner._debugID;
-
-	    info += ReactComponentTreeHook.getStackAddendumByID(id);
-	    return info;
-	  },
-	  getStackAddendumByID: function (id) {
-	    var info = '';
-	    while (id) {
-	      info += describeID(id);
-	      id = ReactComponentTreeHook.getParentID(id);
-	    }
-	    return info;
-	  },
-	  getChildIDs: function (id) {
-	    var item = getItem(id);
-	    return item ? item.childIDs : [];
-	  },
-	  getDisplayName: function (id) {
-	    var element = ReactComponentTreeHook.getElement(id);
-	    if (!element) {
-	      return null;
-	    }
-	    return getDisplayName(element);
-	  },
-	  getElement: function (id) {
-	    var item = getItem(id);
-	    return item ? item.element : null;
-	  },
-	  getOwnerID: function (id) {
-	    var element = ReactComponentTreeHook.getElement(id);
-	    if (!element || !element._owner) {
-	      return null;
-	    }
-	    return element._owner._debugID;
-	  },
-	  getParentID: function (id) {
-	    var item = getItem(id);
-	    return item ? item.parentID : null;
-	  },
-	  getSource: function (id) {
-	    var item = getItem(id);
-	    var element = item ? item.element : null;
-	    var source = element != null ? element._source : null;
-	    return source;
-	  },
-	  getText: function (id) {
-	    var element = ReactComponentTreeHook.getElement(id);
-	    if (typeof element === 'string') {
-	      return element;
-	    } else if (typeof element === 'number') {
-	      return '' + element;
-	    } else {
-	      return null;
-	    }
-	  },
-	  getUpdateCount: function (id) {
-	    var item = getItem(id);
-	    return item ? item.updateCount : 0;
-	  },
-
-
-	  getRootIDs: getRootIDs,
-	  getRegisteredIDs: getItemIDs
-	};
-
-	module.exports = ReactComponentTreeHook;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 27 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(7);
-
-	var ReactPropTypeLocationNames = __webpack_require__(23);
-	var ReactPropTypesSecret = __webpack_require__(28);
-
-	var invariant = __webpack_require__(8);
-	var warning = __webpack_require__(11);
-
-	var ReactComponentTreeHook;
-
-	if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV === 'test') {
-	  // Temporary hack.
-	  // Inline requires don't work well with Jest:
-	  // https://github.com/facebook/react/issues/7240
-	  // Remove the inline requires when we don't need them anymore:
-	  // https://github.com/facebook/react/pull/7178
-	  ReactComponentTreeHook = __webpack_require__(26);
-	}
-
-	var loggedTypeFailures = {};
-
-	/**
-	 * Assert that the values match with the type specs.
-	 * Error messages are memorized and will only be shown once.
-	 *
-	 * @param {object} typeSpecs Map of name to a ReactPropType
-	 * @param {object} values Runtime values that need to be type-checked
-	 * @param {string} location e.g. "prop", "context", "child context"
-	 * @param {string} componentName Name of the component for error messages.
-	 * @param {?object} element The React element that is being type-checked
-	 * @param {?number} debugID The React component instance that is being type-checked
-	 * @private
-	 */
-	function checkReactTypeSpec(typeSpecs, values, location, componentName, element, debugID) {
-	  for (var typeSpecName in typeSpecs) {
-	    if (typeSpecs.hasOwnProperty(typeSpecName)) {
-	      var error;
-	      // Prop type validation may throw. In case they do, we don't want to
-	      // fail the render phase where it didn't fail before. So we log it.
-	      // After these have been cleaned up, we'll let them throw.
-	      try {
-	        // This is intentionally an invariant that gets caught. It's the same
-	        // behavior as without this statement except with a better message.
-	        !(typeof typeSpecs[typeSpecName] === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s: %s type `%s` is invalid; it must be a function, usually from React.PropTypes.', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName) : _prodInvariant('84', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName) : void 0;
-	        error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
-	      } catch (ex) {
-	        error = ex;
-	      }
-	      process.env.NODE_ENV !== 'production' ? warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName, typeof error) : void 0;
-	      if (error instanceof Error && !(error.message in loggedTypeFailures)) {
-	        // Only monitor this failure once because there tends to be a lot of the
-	        // same error.
-	        loggedTypeFailures[error.message] = true;
-
-	        var componentStackInfo = '';
-
-	        if (process.env.NODE_ENV !== 'production') {
-	          if (!ReactComponentTreeHook) {
-	            ReactComponentTreeHook = __webpack_require__(26);
-	          }
-	          if (debugID !== null) {
-	            componentStackInfo = ReactComponentTreeHook.getStackAddendumByID(debugID);
-	          } else if (element !== null) {
-	            componentStackInfo = ReactComponentTreeHook.getCurrentStackAddendum(element);
-	          }
-	        }
-
-	        process.env.NODE_ENV !== 'production' ? warning(false, 'Failed %s type: %s%s', location, error.message, componentStackInfo) : void 0;
-	      }
-	    }
-	  }
-	}
-
-	module.exports = checkReactTypeSpec;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 28 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
-
-	module.exports = ReactPropTypesSecret;
-
-/***/ },
-/* 29 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ReactElement = __webpack_require__(9);
-	var ReactPropTypeLocationNames = __webpack_require__(23);
-	var ReactPropTypesSecret = __webpack_require__(28);
-
-	var emptyFunction = __webpack_require__(12);
-	var getIteratorFn = __webpack_require__(16);
-	var warning = __webpack_require__(11);
-
-	/**
-	 * Collection of methods that allow declaration and validation of props that are
-	 * supplied to React components. Example usage:
-	 *
-	 *   var Props = require('ReactPropTypes');
-	 *   var MyArticle = React.createClass({
-	 *     propTypes: {
-	 *       // 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|func|object|number|string|oneOf([...])|instanceOf(...)
-	 *   decl := ReactPropTypes.{type}(.isRequired)?
-	 *
-	 * Each and every declaration produces a function with the same signature. This
-	 * allows the creation of custom validation functions. For example:
-	 *
-	 *  var MyLink = React.createClass({
-	 *    propTypes: {
-	 *      // An optional string or URI prop named "href".
-	 *      href: function(props, propName, componentName) {
-	 *        var propValue = props[propName];
-	 *        if (propValue != null && typeof propValue !== 'string' &&
-	 *            !(propValue instanceof URI)) {
-	 *          return new Error(
-	 *            'Expected a string or an URI for ' + propName + ' in ' +
-	 *            componentName
-	 *          );
-	 *        }
-	 *      }
-	 *    },
-	 *    render: function() {...}
-	 *  });
-	 *
-	 * @internal
-	 */
-
-	var ANONYMOUS = '<<anonymous>>';
-
-	var ReactPropTypes = {
-	  array: createPrimitiveTypeChecker('array'),
-	  bool: createPrimitiveTypeChecker('boolean'),
-	  func: createPrimitiveTypeChecker('function'),
-	  number: createPrimitiveTypeChecker('number'),
-	  object: createPrimitiveTypeChecker('object'),
-	  string: createPrimitiveTypeChecker('string'),
-	  symbol: createPrimitiveTypeChecker('symbol'),
-
-	  any: createAnyTypeChecker(),
-	  arrayOf: createArrayOfTypeChecker,
-	  element: createElementTypeChecker(),
-	  instanceOf: createInstanceTypeChecker,
-	  node: createNodeChecker(),
-	  objectOf: createObjectOfTypeChecker,
-	  oneOf: createEnumTypeChecker,
-	  oneOfType: createUnionTypeChecker,
-	  shape: createShapeTypeChecker
-	};
-
-	/**
-	 * inlined Object.is polyfill to avoid requiring consumers ship their own
-	 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
-	 */
-	/*eslint-disable no-self-compare*/
-	function is(x, y) {
-	  // SameValue algorithm
-	  if (x === y) {
-	    // Steps 1-5, 7-10
-	    // Steps 6.b-6.e: +0 != -0
-	    return x !== 0 || 1 / x === 1 / y;
-	  } else {
-	    // Step 6.a: NaN == NaN
-	    return x !== x && y !== y;
-	  }
-	}
-	/*eslint-enable no-self-compare*/
-
-	/**
-	 * We use an Error-like object for backward compatibility as people may call
-	 * PropTypes directly and inspect their output. However we don't use real
-	 * Errors anymore. We don't inspect their stack anyway, and creating them
-	 * is prohibitively expensive if they are created too often, such as what
-	 * happens in oneOfType() for any type before the one that matched.
-	 */
-	function PropTypeError(message) {
-	  this.message = message;
-	  this.stack = '';
-	}
-	// Make `instanceof Error` still work for returned errors.
-	PropTypeError.prototype = Error.prototype;
-
-	function createChainableTypeChecker(validate) {
-	  if (process.env.NODE_ENV !== 'production') {
-	    var manualPropTypeCallCache = {};
-	  }
-	  function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
-	    componentName = componentName || ANONYMOUS;
-	    propFullName = propFullName || propName;
-	    if (process.env.NODE_ENV !== 'production') {
-	      if (secret !== ReactPropTypesSecret && typeof console !== 'undefined') {
-	        var cacheKey = componentName + ':' + propName;
-	        if (!manualPropTypeCallCache[cacheKey]) {
-	          process.env.NODE_ENV !== 'production' ? warning(false, 'You are manually calling a React.PropTypes validation ' + 'function for the `%s` prop on `%s`. This is deprecated ' + 'and will not work in production with the next major version. ' + 'You may be seeing this warning due to a third-party PropTypes ' + 'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.', propFullName, componentName) : void 0;
-	          manualPropTypeCallCache[cacheKey] = true;
-	        }
-	      }
-	    }
-	    if (props[propName] == null) {
-	      var locationName = ReactPropTypeLocationNames[location];
-	      if (isRequired) {
-	        if (props[propName] === null) {
-	          return new PropTypeError('The ' + locationName + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
-	        }
-	        return new PropTypeError('The ' + locationName + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
-	      }
-	      return null;
-	    } else {
-	      return validate(props, propName, componentName, location, propFullName);
-	    }
-	  }
-
-	  var chainedCheckType = checkType.bind(null, false);
-	  chainedCheckType.isRequired = checkType.bind(null, true);
-
-	  return chainedCheckType;
-	}
-
-	function createPrimitiveTypeChecker(expectedType) {
-	  function validate(props, propName, componentName, location, propFullName, secret) {
-	    var propValue = props[propName];
-	    var propType = getPropType(propValue);
-	    if (propType !== expectedType) {
-	      var locationName = ReactPropTypeLocationNames[location];
-	      // `propValue` being instance of, say, date/regexp, pass the 'object'
-	      // check, but we can offer a more precise error message here rather than
-	      // 'of type `object`'.
-	      var preciseType = getPreciseType(propValue);
-
-	      return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));
-	    }
-	    return null;
-	  }
-	  return createChainableTypeChecker(validate);
-	}
-
-	function createAnyTypeChecker() {
-	  return createChainableTypeChecker(emptyFunction.thatReturns(null));
-	}
-
-	function createArrayOfTypeChecker(typeChecker) {
-	  function validate(props, propName, componentName, location, propFullName) {
-	    if (typeof typeChecker !== 'function') {
-	      return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
-	    }
-	    var propValue = props[propName];
-	    if (!Array.isArray(propValue)) {
-	      var locationName = ReactPropTypeLocationNames[location];
-	      var propType = getPropType(propValue);
-	      return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
-	    }
-	    for (var i = 0; i < propValue.length; i++) {
-	      var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);
-	      if (error instanceof Error) {
-	        return error;
-	      }
-	    }
-	    return null;
-	  }
-	  return createChainableTypeChecker(validate);
-	}
-
-	function createElementTypeChecker() {
-	  function validate(props, propName, componentName, location, propFullName) {
-	    var propValue = props[propName];
-	    if (!ReactElement.isValidElement(propValue)) {
-	      var locationName = ReactPropTypeLocationNames[location];
-	      var propType = getPropType(propValue);
-	      return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
-	    }
-	    return null;
-	  }
-	  return createChainableTypeChecker(validate);
-	}
-
-	function createInstanceTypeChecker(expectedClass) {
-	  function validate(props, propName, componentName, location, propFullName) {
-	    if (!(props[propName] instanceof expectedClass)) {
-	      var locationName = ReactPropTypeLocationNames[location];
-	      var expectedClassName = expectedClass.name || ANONYMOUS;
-	      var actualClassName = getClassName(props[propName]);
-	      return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
-	    }
-	    return null;
-	  }
-	  return createChainableTypeChecker(validate);
-	}
-
-	function createEnumTypeChecker(expectedValues) {
-	  if (!Array.isArray(expectedValues)) {
-	    process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOf, expected an instance of array.') : void 0;
-	    return emptyFunction.thatReturnsNull;
-	  }
-
-	  function validate(props, propName, componentName, location, propFullName) {
-	    var propValue = props[propName];
-	    for (var i = 0; i < expectedValues.length; i++) {
-	      if (is(propValue, expectedValues[i])) {
-	        return null;
-	      }
-	    }
-
-	    var locationName = ReactPropTypeLocationNames[location];
-	    var valuesString = JSON.stringify(expectedValues);
-	    return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
-	  }
-	  return createChainableTypeChecker(validate);
-	}
-
-	function createObjectOfTypeChecker(typeChecker) {
-	  function validate(props, propName, componentName, location, propFullName) {
-	    if (typeof typeChecker !== 'function') {
-	      return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
-	    }
-	    var propValue = props[propName];
-	    var propType = getPropType(propValue);
-	    if (propType !== 'object') {
-	      var locationName = ReactPropTypeLocationNames[location];
-	      return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
-	    }
-	    for (var key in propValue) {
-	      if (propValue.hasOwnProperty(key)) {
-	        var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
-	        if (error instanceof Error) {
-	          return error;
-	        }
-	      }
-	    }
-	    return null;
-	  }
-	  return createChainableTypeChecker(validate);
-	}
-
-	function createUnionTypeChecker(arrayOfTypeCheckers) {
-	  if (!Array.isArray(arrayOfTypeCheckers)) {
-	    process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
-	    return emptyFunction.thatReturnsNull;
-	  }
-
-	  function validate(props, propName, componentName, location, propFullName) {
-	    for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
-	      var checker = arrayOfTypeCheckers[i];
-	      if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {
-	        return null;
-	      }
-	    }
-
-	    var locationName = ReactPropTypeLocationNames[location];
-	    return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));
-	  }
-	  return createChainableTypeChecker(validate);
-	}
-
-	function createNodeChecker() {
-	  function validate(props, propName, componentName, location, propFullName) {
-	    if (!isNode(props[propName])) {
-	      var locationName = ReactPropTypeLocationNames[location];
-	      return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
-	    }
-	    return null;
-	  }
-	  return createChainableTypeChecker(validate);
-	}
-
-	function createShapeTypeChecker(shapeTypes) {
-	  function validate(props, propName, componentName, location, propFullName) {
-	    var propValue = props[propName];
-	    var propType = getPropType(propValue);
-	    if (propType !== 'object') {
-	      var locationName = ReactPropTypeLocationNames[location];
-	      return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
-	    }
-	    for (var key in shapeTypes) {
-	      var checker = shapeTypes[key];
-	      if (!checker) {
-	        continue;
-	      }
-	      var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
-	      if (error) {
-	        return error;
-	      }
-	    }
-	    return null;
-	  }
-	  return createChainableTypeChecker(validate);
-	}
-
-	function isNode(propValue) {
-	  switch (typeof propValue) {
-	    case 'number':
-	    case 'string':
-	    case 'undefined':
-	      return true;
-	    case 'boolean':
-	      return !propValue;
-	    case 'object':
-	      if (Array.isArray(propValue)) {
-	        return propValue.every(isNode);
-	      }
-	      if (propValue === null || ReactElement.isValidElement(propValue)) {
-	        return true;
-	      }
-
-	      var iteratorFn = getIteratorFn(propValue);
-	      if (iteratorFn) {
-	        var iterator = iteratorFn.call(propValue);
-	        var step;
-	        if (iteratorFn !== propValue.entries) {
-	          while (!(step = iterator.next()).done) {
-	            if (!isNode(step.value)) {
-	              return false;
-	            }
-	          }
-	        } else {
-	          // Iterator will provide entry [k,v] tuples rather than values.
-	          while (!(step = iterator.next()).done) {
-	            var entry = step.value;
-	            if (entry) {
-	              if (!isNode(entry[1])) {
-	                return false;
-	              }
-	            }
-	          }
-	        }
-	      } else {
-	        return false;
-	      }
-
-	      return true;
-	    default:
-	      return false;
-	  }
-	}
-
-	function isSymbol(propType, propValue) {
-	  // Native Symbol.
-	  if (propType === 'symbol') {
-	    return true;
-	  }
-
-	  // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
-	  if (propValue['@@toStringTag'] === 'Symbol') {
-	    return true;
-	  }
-
-	  // Fallback for non-spec compliant Symbols which are polyfilled.
-	  if (typeof Symbol === 'function' && propValue instanceof Symbol) {
-	    return true;
-	  }
-
-	  return false;
-	}
-
-	// Equivalent of `typeof` but with special handling for array and regexp.
-	function getPropType(propValue) {
-	  var propType = typeof propValue;
-	  if (Array.isArray(propValue)) {
-	    return 'array';
-	  }
-	  if (propValue instanceof RegExp) {
-	    // Old webkits (at least until Android 4.0) return 'function' rather than
-	    // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
-	    // passes PropTypes.object.
-	    return 'object';
-	  }
-	  if (isSymbol(propType, propValue)) {
-	    return 'symbol';
-	  }
-	  return propType;
-	}
-
-	// This handles more types than `getPropType`. Only used for error messages.
-	// See `createPrimitiveTypeChecker`.
-	function getPreciseType(propValue) {
-	  var propType = getPropType(propValue);
-	  if (propType === 'object') {
-	    if (propValue instanceof Date) {
-	      return 'date';
-	    } else if (propValue instanceof RegExp) {
-	      return 'regexp';
-	    }
-	  }
-	  return propType;
-	}
-
-	// Returns class name of the object, if any.
-	function getClassName(propValue) {
-	  if (!propValue.constructor || !propValue.constructor.name) {
-	    return ANONYMOUS;
-	  }
-	  return propValue.constructor.name;
-	}
-
-	module.exports = ReactPropTypes;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 30 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	module.exports = '15.4.1';
-
-/***/ },
-/* 31 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(7);
-
-	var ReactElement = __webpack_require__(9);
-
-	var invariant = __webpack_require__(8);
-
-	/**
-	 * Returns the first child in a collection of children and verifies that there
-	 * is only one child in the collection.
-	 *
-	 * See https://facebook.github.io/react/docs/top-level-api.html#react.children.only
-	 *
-	 * The current implementation of this 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 {ReactElement} The first and only `ReactElement` contained in the
-	 * structure.
-	 */
-	function onlyChild(children) {
-	  !ReactElement.isValidElement(children) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'React.Children.only expected to receive a single React element child.') : _prodInvariant('143') : void 0;
-	  return children;
-	}
-
-	module.exports = onlyChild;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 32 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	module.exports = __webpack_require__(33);
-
-
-/***/ },
-/* 33 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	/* globals __REACT_DEVTOOLS_GLOBAL_HOOK__*/
-
-	'use strict';
-
-	var ReactDOMComponentTree = __webpack_require__(34);
-	var ReactDefaultInjection = __webpack_require__(39);
-	var ReactMount = __webpack_require__(171);
-	var ReactReconciler = __webpack_require__(63);
-	var ReactUpdates = __webpack_require__(60);
-	var ReactVersion = __webpack_require__(176);
-
-	var findDOMNode = __webpack_require__(177);
-	var getHostComponentFromComposite = __webpack_require__(178);
-	var renderSubtreeIntoContainer = __webpack_require__(179);
-	var warning = __webpack_require__(47);
-
-	ReactDefaultInjection.inject();
-
-	var ReactDOM = {
-	  findDOMNode: findDOMNode,
-	  render: ReactMount.render,
-	  unmountComponentAtNode: ReactMount.unmountComponentAtNode,
-	  version: ReactVersion,
-
-	  /* eslint-disable camelcase */
-	  unstable_batchedUpdates: ReactUpdates.batchedUpdates,
-	  unstable_renderSubtreeIntoContainer: renderSubtreeIntoContainer
-	};
-
-	// Inject the runtime into a devtools global hook regardless of browser.
-	// Allows for debugging when the hook is injected on the page.
-	if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.inject === 'function') {
-	  __REACT_DEVTOOLS_GLOBAL_HOOK__.inject({
-	    ComponentTree: {
-	      getClosestInstanceFromNode: ReactDOMComponentTree.getClosestInstanceFromNode,
-	      getNodeFromInstance: function (inst) {
-	        // inst is an internal instance (but could be a composite)
-	        if (inst._renderedComponent) {
-	          inst = getHostComponentFromComposite(inst);
-	        }
-	        if (inst) {
-	          return ReactDOMComponentTree.getNodeFromInstance(inst);
-	        } else {
-	          return null;
-	        }
-	      }
-	    },
-	    Mount: ReactMount,
-	    Reconciler: ReactReconciler
-	  });
-	}
-
-	if (process.env.NODE_ENV !== 'production') {
-	  var ExecutionEnvironment = __webpack_require__(51);
-	  if (ExecutionEnvironment.canUseDOM && window.top === window.self) {
-
-	    // First check if devtools is not installed
-	    if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {
-	      // If we're in Chrome or Firefox, provide a download link if not installed.
-	      if (navigator.userAgent.indexOf('Chrome') > -1 && navigator.userAgent.indexOf('Edge') === -1 || navigator.userAgent.indexOf('Firefox') > -1) {
-	        // Firefox does not have the issue with devtools loaded over file://
-	        var showFileUrlMessage = window.location.protocol.indexOf('http') === -1 && navigator.userAgent.indexOf('Firefox') === -1;
-	        console.debug('Download the React DevTools ' + (showFileUrlMessage ? 'and use an HTTP server (instead of a file: URL) ' : '') + 'for a better development experience: ' + 'https://fb.me/react-devtools');
-	      }
-	    }
-
-	    var testFunc = function testFn() {};
-	    process.env.NODE_ENV !== 'production' ? warning((testFunc.name || testFunc.toString()).indexOf('testFn') !== -1, 'It looks like you\'re using a minified copy of the development build ' + 'of React. When deploying React apps to production, make sure to use ' + 'the production build which skips development warnings and is faster. ' + 'See https://fb.me/react-minification for more details.') : void 0;
-
-	    // If we're in IE8, check to see if we are in compatibility mode and provide
-	    // information on preventing compatibility mode
-	    var ieCompatibilityMode = document.documentMode && document.documentMode < 8;
-
-	    process.env.NODE_ENV !== 'production' ? warning(!ieCompatibilityMode, 'Internet Explorer is running in compatibility mode; please add the ' + 'following tag to your HTML to prevent this from happening: ' + '<meta http-equiv="X-UA-Compatible" content="IE=edge" />') : void 0;
-
-	    var expectedFeatures = [
-	    // shims
-	    Array.isArray, Array.prototype.every, Array.prototype.forEach, Array.prototype.indexOf, Array.prototype.map, Date.now, Function.prototype.bind, Object.keys, String.prototype.trim];
-
-	    for (var i = 0; i < expectedFeatures.length; i++) {
-	      if (!expectedFeatures[i]) {
-	        process.env.NODE_ENV !== 'production' ? warning(false, 'One or more ES5 shims expected by React are not available: ' + 'https://fb.me/react-warning-polyfills') : void 0;
-	        break;
-	      }
-	    }
-	  }
-	}
-
-	if (process.env.NODE_ENV !== 'production') {
-	  var ReactInstrumentation = __webpack_require__(66);
-	  var ReactDOMUnknownPropertyHook = __webpack_require__(180);
-	  var ReactDOMNullInputValuePropHook = __webpack_require__(181);
-	  var ReactDOMInvalidARIAHook = __webpack_require__(182);
-
-	  ReactInstrumentation.debugTool.addHook(ReactDOMUnknownPropertyHook);
-	  ReactInstrumentation.debugTool.addHook(ReactDOMNullInputValuePropHook);
-	  ReactInstrumentation.debugTool.addHook(ReactDOMInvalidARIAHook);
-	}
-
-	module.exports = ReactDOM;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 34 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var DOMProperty = __webpack_require__(36);
-	var ReactDOMComponentFlags = __webpack_require__(38);
-
-	var invariant = __webpack_require__(37);
-
-	var ATTR_NAME = DOMProperty.ID_ATTRIBUTE_NAME;
-	var Flags = ReactDOMComponentFlags;
-
-	var internalInstanceKey = '__reactInternalInstance$' + Math.random().toString(36).slice(2);
-
-	/**
-	 * Drill down (through composites and empty components) until we get a host or
-	 * host text component.
-	 *
-	 * This is pretty polymorphic but unavoidable with the current structure we have
-	 * for `_renderedChildren`.
-	 */
-	function getRenderedHostOrTextFromComponent(component) {
-	  var rendered;
-	  while (rendered = component._renderedComponent) {
-	    component = rendered;
-	  }
-	  return component;
-	}
-
-	/**
-	 * Populate `_hostNode` on the rendered host/text component with the given
-	 * DOM node. The passed `inst` can be a composite.
-	 */
-	function precacheNode(inst, node) {
-	  var hostInst = getRenderedHostOrTextFromComponent(inst);
-	  hostInst._hostNode = node;
-	  node[internalInstanceKey] = hostInst;
-	}
-
-	function uncacheNode(inst) {
-	  var node = inst._hostNode;
-	  if (node) {
-	    delete node[internalInstanceKey];
-	    inst._hostNode = null;
-	  }
-	}
-
-	/**
-	 * Populate `_hostNode` on each child of `inst`, assuming that the children
-	 * match up with the DOM (element) children of `node`.
-	 *
-	 * We cache entire levels at once to avoid an n^2 problem where we access the
-	 * children of a node sequentially and have to walk from the start to our target
-	 * node every time.
-	 *
-	 * Since we update `_renderedChildren` and the actual DOM at (slightly)
-	 * different times, we could race here and see a newer `_renderedChildren` than
-	 * the DOM nodes we see. To avoid this, ReactMultiChild calls
-	 * `prepareToManageChildren` before we change `_renderedChildren`, at which
-	 * time the container's child nodes are always cached (until it unmounts).
-	 */
-	function precacheChildNodes(inst, node) {
-	  if (inst._flags & Flags.hasCachedChildNodes) {
-	    return;
-	  }
-	  var children = inst._renderedChildren;
-	  var childNode = node.firstChild;
-	  outer: for (var name in children) {
-	    if (!children.hasOwnProperty(name)) {
-	      continue;
-	    }
-	    var childInst = children[name];
-	    var childID = getRenderedHostOrTextFromComponent(childInst)._domID;
-	    if (childID === 0) {
-	      // We're currently unmounting this child in ReactMultiChild; skip it.
-	      continue;
-	    }
-	    // We assume the child nodes are in the same order as the child instances.
-	    for (; childNode !== null; childNode = childNode.nextSibling) {
-	      if (childNode.nodeType === 1 && childNode.getAttribute(ATTR_NAME) === String(childID) || childNode.nodeType === 8 && childNode.nodeValue === ' react-text: ' + childID + ' ' || childNode.nodeType === 8 && childNode.nodeValue === ' react-empty: ' + childID + ' ') {
-	        precacheNode(childInst, childNode);
-	        continue outer;
-	      }
-	    }
-	    // We reached the end of the DOM children without finding an ID match.
-	     true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Unable to find element with ID %s.', childID) : _prodInvariant('32', childID) : void 0;
-	  }
-	  inst._flags |= Flags.hasCachedChildNodes;
-	}
-
-	/**
-	 * Given a DOM node, return the closest ReactDOMComponent or
-	 * ReactDOMTextComponent instance ancestor.
-	 */
-	function getClosestInstanceFromNode(node) {
-	  if (node[internalInstanceKey]) {
-	    return node[internalInstanceKey];
-	  }
-
-	  // Walk up the tree until we find an ancestor whose instance we have cached.
-	  var parents = [];
-	  while (!node[internalInstanceKey]) {
-	    parents.push(node);
-	    if (node.parentNode) {
-	      node = node.parentNode;
-	    } else {
-	      // Top of the tree. This node must not be part of a React tree (or is
-	      // unmounted, potentially).
-	      return null;
-	    }
-	  }
-
-	  var closest;
-	  var inst;
-	  for (; node && (inst = node[internalInstanceKey]); node = parents.pop()) {
-	    closest = inst;
-	    if (parents.length) {
-	      precacheChildNodes(inst, node);
-	    }
-	  }
-
-	  return closest;
-	}
-
-	/**
-	 * Given a DOM node, return the ReactDOMComponent or ReactDOMTextComponent
-	 * instance, or null if the node was not rendered by this React.
-	 */
-	function getInstanceFromNode(node) {
-	  var inst = getClosestInstanceFromNode(node);
-	  if (inst != null && inst._hostNode === node) {
-	    return inst;
-	  } else {
-	    return null;
-	  }
-	}
-
-	/**
-	 * Given a ReactDOMComponent or ReactDOMTextComponent, return the corresponding
-	 * DOM node.
-	 */
-	function getNodeFromInstance(inst) {
-	  // Without this first invariant, passing a non-DOM-component triggers the next
-	  // invariant for a missing parent, which is super confusing.
-	  !(inst._hostNode !== undefined) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getNodeFromInstance: Invalid argument.') : _prodInvariant('33') : void 0;
-
-	  if (inst._hostNode) {
-	    return inst._hostNode;
-	  }
-
-	  // Walk up the tree until we find an ancestor whose DOM node we have cached.
-	  var parents = [];
-	  while (!inst._hostNode) {
-	    parents.push(inst);
-	    !inst._hostParent ? process.env.NODE_ENV !== 'production' ? invariant(false, 'React DOM tree root should always have a node reference.') : _prodInvariant('34') : void 0;
-	    inst = inst._hostParent;
-	  }
-
-	  // Now parents contains each ancestor that does *not* have a cached native
-	  // node, and `inst` is the deepest ancestor that does.
-	  for (; parents.length; inst = parents.pop()) {
-	    precacheChildNodes(inst, inst._hostNode);
-	  }
-
-	  return inst._hostNode;
-	}
-
-	var ReactDOMComponentTree = {
-	  getClosestInstanceFromNode: getClosestInstanceFromNode,
-	  getInstanceFromNode: getInstanceFromNode,
-	  getNodeFromInstance: getNodeFromInstance,
-	  precacheChildNodes: precacheChildNodes,
-	  precacheNode: precacheNode,
-	  uncacheNode: uncacheNode
-	};
-
-	module.exports = ReactDOMComponentTree;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 35 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-	'use strict';
-
-	/**
-	 * WARNING: DO NOT manually require this module.
-	 * This is a replacement for `invariant(...)` used by the error code system
-	 * and will _only_ be required by the corresponding babel pass.
-	 * It always throws.
-	 */
-
-	function reactProdInvariant(code) {
-	  var argCount = arguments.length - 1;
-
-	  var message = 'Minified React error #' + code + '; visit ' + 'http://facebook.github.io/react/docs/error-decoder.html?invariant=' + code;
-
-	  for (var argIdx = 0; argIdx < argCount; argIdx++) {
-	    message += '&args[]=' + encodeURIComponent(arguments[argIdx + 1]);
-	  }
-
-	  message += ' for the full message or use the non-minified dev environment' + ' for full errors and additional helpful warnings.';
-
-	  var error = new Error(message);
-	  error.name = 'Invariant Violation';
-	  error.framesToPop = 1; // we don't care about reactProdInvariant's own frame
-
-	  throw error;
-	}
-
-	module.exports = reactProdInvariant;
-
-/***/ },
-/* 36 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var invariant = __webpack_require__(37);
-
-	function checkMask(value, bitmask) {
-	  return (value & bitmask) === bitmask;
-	}
-
-	var DOMPropertyInjection = {
-	  /**
-	   * Mapping from normalized, camelcased property names to a configuration that
-	   * specifies how the associated DOM property should be accessed or rendered.
-	   */
-	  MUST_USE_PROPERTY: 0x1,
-	  HAS_BOOLEAN_VALUE: 0x4,
-	  HAS_NUMERIC_VALUE: 0x8,
-	  HAS_POSITIVE_NUMERIC_VALUE: 0x10 | 0x8,
-	  HAS_OVERLOADED_BOOLEAN_VALUE: 0x20,
-
-	  /**
-	   * Inject some specialized knowledge about the DOM. This takes a config object
-	   * with the following properties:
-	   *
-	   * isCustomAttribute: function that given an attribute name will return true
-	   * if it can be inserted into the DOM verbatim. Useful for data-* or aria-*
-	   * attributes where it's impossible to enumerate all of the possible
-	   * attribute names,
-	   *
-	   * Properties: object mapping DOM property name to one of the
-	   * DOMPropertyInjection constants or null. If your attribute isn't in here,
-	   * it won't get written to the DOM.
-	   *
-	   * DOMAttributeNames: object mapping React attribute name to the DOM
-	   * attribute name. Attribute names not specified use the **lowercase**
-	   * normalized name.
-	   *
-	   * DOMAttributeNamespaces: object mapping React attribute name to the DOM
-	   * attribute namespace URL. (Attribute names not specified use no namespace.)
-	   *
-	   * DOMPropertyNames: similar to DOMAttributeNames but for DOM properties.
-	   * Property names not specified use the normalized name.
-	   *
-	   * DOMMutationMethods: Properties that require special mutation methods. If
-	   * `value` is undefined, the mutation method should unset the property.
-	   *
-	   * @param {object} domPropertyConfig the config as described above.
-	   */
-	  injectDOMPropertyConfig: function (domPropertyConfig) {
-	    var Injection = DOMPropertyInjection;
-	    var Properties = domPropertyConfig.Properties || {};
-	    var DOMAttributeNamespaces = domPropertyConfig.DOMAttributeNamespaces || {};
-	    var DOMAttributeNames = domPropertyConfig.DOMAttributeNames || {};
-	    var DOMPropertyNames = domPropertyConfig.DOMPropertyNames || {};
-	    var DOMMutationMethods = domPropertyConfig.DOMMutationMethods || {};
-
-	    if (domPropertyConfig.isCustomAttribute) {
-	      DOMProperty._isCustomAttributeFunctions.push(domPropertyConfig.isCustomAttribute);
-	    }
-
-	    for (var propName in Properties) {
-	      !!DOMProperty.properties.hasOwnProperty(propName) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'injectDOMPropertyConfig(...): You\'re trying to inject DOM property \'%s\' which has already been injected. You may be accidentally injecting the same DOM property config twice, or you may be injecting two configs that have conflicting property names.', propName) : _prodInvariant('48', propName) : void 0;
-
-	      var lowerCased = propName.toLowerCase();
-	      var propConfig = Properties[propName];
-
-	      var propertyInfo = {
-	        attributeName: lowerCased,
-	        attributeNamespace: null,
-	        propertyName: propName,
-	        mutationMethod: null,
-
-	        mustUseProperty: checkMask(propConfig, Injection.MUST_USE_PROPERTY),
-	        hasBooleanValue: checkMask(propConfig, Injection.HAS_BOOLEAN_VALUE),
-	        hasNumericValue: checkMask(propConfig, Injection.HAS_NUMERIC_VALUE),
-	        hasPositiveNumericValue: checkMask(propConfig, Injection.HAS_POSITIVE_NUMERIC_VALUE),
-	        hasOverloadedBooleanValue: checkMask(propConfig, Injection.HAS_OVERLOADED_BOOLEAN_VALUE)
-	      };
-	      !(propertyInfo.hasBooleanValue + propertyInfo.hasNumericValue + propertyInfo.hasOverloadedBooleanValue <= 1) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'DOMProperty: Value can be one of boolean, overloaded boolean, or numeric value, but not a combination: %s', propName) : _prodInvariant('50', propName) : void 0;
-
-	      if (process.env.NODE_ENV !== 'production') {
-	        DOMProperty.getPossibleStandardName[lowerCased] = propName;
-	      }
-
-	      if (DOMAttributeNames.hasOwnProperty(propName)) {
-	        var attributeName = DOMAttributeNames[propName];
-	        propertyInfo.attributeName = attributeName;
-	        if (process.env.NODE_ENV !== 'production') {
-	          DOMProperty.getPossibleStandardName[attributeName] = propName;
-	        }
-	      }
-
-	      if (DOMAttributeNamespaces.hasOwnProperty(propName)) {
-	        propertyInfo.attributeNamespace = DOMAttributeNamespaces[propName];
-	      }
-
-	      if (DOMPropertyNames.hasOwnProperty(propName)) {
-	        propertyInfo.propertyName = DOMPropertyNames[propName];
-	      }
-
-	      if (DOMMutationMethods.hasOwnProperty(propName)) {
-	        propertyInfo.mutationMethod = DOMMutationMethods[propName];
-	      }
-
-	      DOMProperty.properties[propName] = propertyInfo;
-	    }
-	  }
-	};
-
-	/* eslint-disable max-len */
-	var ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
-	/* eslint-enable max-len */
-
-	/**
-	 * 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 = {
-
-	  ID_ATTRIBUTE_NAME: 'data-reactid',
-	  ROOT_ATTRIBUTE_NAME: 'data-reactroot',
-
-	  ATTRIBUTE_NAME_START_CHAR: ATTRIBUTE_NAME_START_CHAR,
-	  ATTRIBUTE_NAME_CHAR: ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040',
-
-	  /**
-	   * Map from property "standard name" to an object with info about how to set
-	   * the property in the DOM. Each object contains:
-	   *
-	   * attributeName:
-	   *   Used when rendering markup or with `*Attribute()`.
-	   * attributeNamespace
-	   * propertyName:
-	   *   Used on DOM node instances. (This includes properties that mutate due to
-	   *   external factors.)
-	   * mutationMethod:
-	   *   If non-null, used instead of the property or `setAttribute()` after
-	   *   initial render.
-	   * mustUseProperty:
-	   *   Whether the property must be accessed and mutated as an object property.
-	   * hasBooleanValue:
-	   *   Whether the property should be removed when set to a falsey value.
-	   * hasNumericValue:
-	   *   Whether the property must be numeric or parse as a numeric and should be
-	   *   removed when set to a falsey value.
-	   * hasPositiveNumericValue:
-	   *   Whether the property must be positive numeric or parse as a positive
-	   *   numeric and should be removed when set to a falsey value.
-	   * hasOverloadedBooleanValue:
-	   *   Whether the property can be used as a flag as well as with a value.
-	   *   Removed when strictly equal to false; present without a value when
-	   *   strictly equal to true; present with a value otherwise.
-	   */
-	  properties: {},
-
-	  /**
-	   * Mapping from lowercase property names to the properly cased version, used
-	   * to warn in the case of missing properties. Available only in __DEV__.
-	   *
-	   * autofocus is predefined, because adding it to the property whitelist
-	   * causes unintended side effects.
-	   *
-	   * @type {Object}
-	   */
-	  getPossibleStandardName: process.env.NODE_ENV !== 'production' ? { autofocus: 'autoFocus' } : null,
-
-	  /**
-	   * All of the isCustomAttribute() functions that have been injected.
-	   */
-	  _isCustomAttributeFunctions: [],
-
-	  /**
-	   * Checks whether a property name is a custom attribute.
-	   * @method
-	   */
-	  isCustomAttribute: function (attributeName) {
-	    for (var i = 0; i < DOMProperty._isCustomAttributeFunctions.length; i++) {
-	      var isCustomAttributeFn = DOMProperty._isCustomAttributeFunctions[i];
-	      if (isCustomAttributeFn(attributeName)) {
-	        return true;
-	      }
-	    }
-	    return false;
-	  },
-
-	  injection: DOMPropertyInjection
-	};
-
-	module.exports = DOMProperty;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 37 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	/**
-	 * Use invariant() to assert state which your program assumes to be true.
-	 *
-	 * Provide sprintf-style format (only %s is supported) 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, format, a, b, c, d, e, f) {
-	  if (process.env.NODE_ENV !== 'production') {
-	    if (format === undefined) {
-	      throw new Error('invariant requires an error message argument');
-	    }
-	  }
-
-	  if (!condition) {
-	    var error;
-	    if (format === undefined) {
-	      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
-	    } else {
-	      var args = [a, b, c, d, e, f];
-	      var argIndex = 0;
-	      error = new Error(format.replace(/%s/g, function () {
-	        return args[argIndex++];
-	      }));
-	      error.name = 'Invariant Violation';
-	    }
-
-	    error.framesToPop = 1; // we don't care about invariant's own frame
-	    throw error;
-	  }
-	}
-
-	module.exports = invariant;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 38 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2015-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ReactDOMComponentFlags = {
-	  hasCachedChildNodes: 1 << 0
-	};
-
-	module.exports = ReactDOMComponentFlags;
-
-/***/ },
-/* 39 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ARIADOMPropertyConfig = __webpack_require__(40);
-	var BeforeInputEventPlugin = __webpack_require__(41);
-	var ChangeEventPlugin = __webpack_require__(59);
-	var DefaultEventPluginOrder = __webpack_require__(76);
-	var EnterLeaveEventPlugin = __webpack_require__(77);
-	var HTMLDOMPropertyConfig = __webpack_require__(82);
-	var ReactComponentBrowserEnvironment = __webpack_require__(83);
-	var ReactDOMComponent = __webpack_require__(96);
-	var ReactDOMComponentTree = __webpack_require__(34);
-	var ReactDOMEmptyComponent = __webpack_require__(142);
-	var ReactDOMTreeTraversal = __webpack_require__(143);
-	var ReactDOMTextComponent = __webpack_require__(144);
-	var ReactDefaultBatchingStrategy = __webpack_require__(145);
-	var ReactEventListener = __webpack_require__(146);
-	var ReactInjection = __webpack_require__(149);
-	var ReactReconcileTransaction = __webpack_require__(150);
-	var SVGDOMPropertyConfig = __webpack_require__(158);
-	var SelectEventPlugin = __webpack_require__(159);
-	var SimpleEventPlugin = __webpack_require__(160);
-
-	var alreadyInjected = false;
-
-	function inject() {
-	  if (alreadyInjected) {
-	    // TODO: This is currently true because these injections are shared between
-	    // the client and the server package. They should be built independently
-	    // and not share any injection state. Then this problem will be solved.
-	    return;
-	  }
-	  alreadyInjected = true;
-
-	  ReactInjection.EventEmitter.injectReactEventListener(ReactEventListener);
-
-	  /**
-	   * Inject modules for resolving DOM hierarchy and plugin ordering.
-	   */
-	  ReactInjection.EventPluginHub.injectEventPluginOrder(DefaultEventPluginOrder);
-	  ReactInjection.EventPluginUtils.injectComponentTree(ReactDOMComponentTree);
-	  ReactInjection.EventPluginUtils.injectTreeTraversal(ReactDOMTreeTraversal);
-
-	  /**
-	   * Some important event plugins included by default (without having to require
-	   * them).
-	   */
-	  ReactInjection.EventPluginHub.injectEventPluginsByName({
-	    SimpleEventPlugin: SimpleEventPlugin,
-	    EnterLeaveEventPlugin: EnterLeaveEventPlugin,
-	    ChangeEventPlugin: ChangeEventPlugin,
-	    SelectEventPlugin: SelectEventPlugin,
-	    BeforeInputEventPlugin: BeforeInputEventPlugin
-	  });
-
-	  ReactInjection.HostComponent.injectGenericComponentClass(ReactDOMComponent);
-
-	  ReactInjection.HostComponent.injectTextComponentClass(ReactDOMTextComponent);
-
-	  ReactInjection.DOMProperty.injectDOMPropertyConfig(ARIADOMPropertyConfig);
-	  ReactInjection.DOMProperty.injectDOMPropertyConfig(HTMLDOMPropertyConfig);
-	  ReactInjection.DOMProperty.injectDOMPropertyConfig(SVGDOMPropertyConfig);
-
-	  ReactInjection.EmptyComponent.injectEmptyComponentFactory(function (instantiate) {
-	    return new ReactDOMEmptyComponent(instantiate);
-	  });
-
-	  ReactInjection.Updates.injectReconcileTransaction(ReactReconcileTransaction);
-	  ReactInjection.Updates.injectBatchingStrategy(ReactDefaultBatchingStrategy);
-
-	  ReactInjection.Component.injectEnvironment(ReactComponentBrowserEnvironment);
-	}
-
-	module.exports = {
-	  inject: inject
-	};
-
-/***/ },
-/* 40 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ARIADOMPropertyConfig = {
-	  Properties: {
-	    // Global States and Properties
-	    'aria-current': 0, // state
-	    'aria-details': 0,
-	    'aria-disabled': 0, // state
-	    'aria-hidden': 0, // state
-	    'aria-invalid': 0, // state
-	    'aria-keyshortcuts': 0,
-	    'aria-label': 0,
-	    'aria-roledescription': 0,
-	    // Widget Attributes
-	    'aria-autocomplete': 0,
-	    'aria-checked': 0,
-	    'aria-expanded': 0,
-	    'aria-haspopup': 0,
-	    'aria-level': 0,
-	    'aria-modal': 0,
-	    'aria-multiline': 0,
-	    'aria-multiselectable': 0,
-	    'aria-orientation': 0,
-	    'aria-placeholder': 0,
-	    'aria-pressed': 0,
-	    'aria-readonly': 0,
-	    'aria-required': 0,
-	    'aria-selected': 0,
-	    'aria-sort': 0,
-	    'aria-valuemax': 0,
-	    'aria-valuemin': 0,
-	    'aria-valuenow': 0,
-	    'aria-valuetext': 0,
-	    // Live Region Attributes
-	    'aria-atomic': 0,
-	    'aria-busy': 0,
-	    'aria-live': 0,
-	    'aria-relevant': 0,
-	    // Drag-and-Drop Attributes
-	    'aria-dropeffect': 0,
-	    'aria-grabbed': 0,
-	    // Relationship Attributes
-	    'aria-activedescendant': 0,
-	    'aria-colcount': 0,
-	    'aria-colindex': 0,
-	    'aria-colspan': 0,
-	    'aria-controls': 0,
-	    'aria-describedby': 0,
-	    'aria-errormessage': 0,
-	    'aria-flowto': 0,
-	    'aria-labelledby': 0,
-	    'aria-owns': 0,
-	    'aria-posinset': 0,
-	    'aria-rowcount': 0,
-	    'aria-rowindex': 0,
-	    'aria-rowspan': 0,
-	    'aria-setsize': 0
-	  },
-	  DOMAttributeNames: {},
-	  DOMPropertyNames: {}
-	};
-
-	module.exports = ARIADOMPropertyConfig;
-
-/***/ },
-/* 41 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var EventPropagators = __webpack_require__(42);
-	var ExecutionEnvironment = __webpack_require__(51);
-	var FallbackCompositionState = __webpack_require__(52);
-	var SyntheticCompositionEvent = __webpack_require__(56);
-	var SyntheticInputEvent = __webpack_require__(58);
-
-	var END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space
-	var START_KEYCODE = 229;
-
-	var canUseCompositionEvent = ExecutionEnvironment.canUseDOM && 'CompositionEvent' in window;
-
-	var documentMode = null;
-	if (ExecutionEnvironment.canUseDOM && 'documentMode' in document) {
-	  documentMode = document.documentMode;
-	}
-
-	// Webkit offers a very useful `textInput` event that can be used to
-	// directly represent `beforeInput`. The IE `textinput` event is not as
-	// useful, so we don't use it.
-	var canUseTextInputEvent = ExecutionEnvironment.canUseDOM && 'TextEvent' in window && !documentMode && !isPresto();
-
-	// In IE9+, we have access to composition events, but the data supplied
-	// by the native compositionend event may be incorrect. Japanese ideographic
-	// spaces, for instance (\u3000) are not recorded correctly.
-	var useFallbackCompositionData = ExecutionEnvironment.canUseDOM && (!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11);
-
-	/**
-	 * Opera <= 12 includes TextEvent in window, but does not fire
-	 * text input events. Rely on keypress instead.
-	 */
-	function isPresto() {
-	  var opera = window.opera;
-	  return typeof opera === 'object' && typeof opera.version === 'function' && parseInt(opera.version(), 10) <= 12;
-	}
-
-	var SPACEBAR_CODE = 32;
-	var SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);
-
-	// Events and their corresponding property names.
-	var eventTypes = {
-	  beforeInput: {
-	    phasedRegistrationNames: {
-	      bubbled: 'onBeforeInput',
-	      captured: 'onBeforeInputCapture'
-	    },
-	    dependencies: ['topCompositionEnd', 'topKeyPress', 'topTextInput', 'topPaste']
-	  },
-	  compositionEnd: {
-	    phasedRegistrationNames: {
-	      bubbled: 'onCompositionEnd',
-	      captured: 'onCompositionEndCapture'
-	    },
-	    dependencies: ['topBlur', 'topCompositionEnd', 'topKeyDown', 'topKeyPress', 'topKeyUp', 'topMouseDown']
-	  },
-	  compositionStart: {
-	    phasedRegistrationNames: {
-	      bubbled: 'onCompositionStart',
-	      captured: 'onCompositionStartCapture'
-	    },
-	    dependencies: ['topBlur', 'topCompositionStart', 'topKeyDown', 'topKeyPress', 'topKeyUp', 'topMouseDown']
-	  },
-	  compositionUpdate: {
-	    phasedRegistrationNames: {
-	      bubbled: 'onCompositionUpdate',
-	      captured: 'onCompositionUpdateCapture'
-	    },
-	    dependencies: ['topBlur', 'topCompositionUpdate', 'topKeyDown', 'topKeyPress', 'topKeyUp', 'topMouseDown']
-	  }
-	};
-
-	// Track whether we've ever handled a keypress on the space key.
-	var hasSpaceKeypress = false;
-
-	/**
-	 * Return whether a native keypress event is assumed to be a command.
-	 * This is required because Firefox fires `keypress` events for key commands
-	 * (cut, copy, select-all, etc.) even though no character is inserted.
-	 */
-	function isKeypressCommand(nativeEvent) {
-	  return (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) &&
-	  // ctrlKey && altKey is equivalent to AltGr, and is not a command.
-	  !(nativeEvent.ctrlKey && nativeEvent.altKey);
-	}
-
-	/**
-	 * Translate native top level events into event types.
-	 *
-	 * @param {string} topLevelType
-	 * @return {object}
-	 */
-	function getCompositionEventType(topLevelType) {
-	  switch (topLevelType) {
-	    case 'topCompositionStart':
-	      return eventTypes.compositionStart;
-	    case 'topCompositionEnd':
-	      return eventTypes.compositionEnd;
-	    case 'topCompositionUpdate':
-	      return eventTypes.compositionUpdate;
-	  }
-	}
-
-	/**
-	 * Does our fallback best-guess model think this event signifies that
-	 * composition has begun?
-	 *
-	 * @param {string} topLevelType
-	 * @param {object} nativeEvent
-	 * @return {boolean}
-	 */
-	function isFallbackCompositionStart(topLevelType, nativeEvent) {
-	  return topLevelType === 'topKeyDown' && nativeEvent.keyCode === START_KEYCODE;
-	}
-
-	/**
-	 * Does our fallback mode think that this event is the end of composition?
-	 *
-	 * @param {string} topLevelType
-	 * @param {object} nativeEvent
-	 * @return {boolean}
-	 */
-	function isFallbackCompositionEnd(topLevelType, nativeEvent) {
-	  switch (topLevelType) {
-	    case 'topKeyUp':
-	      // Command keys insert or clear IME input.
-	      return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;
-	    case 'topKeyDown':
-	      // Expect IME keyCode on each keydown. If we get any other
-	      // code we must have exited earlier.
-	      return nativeEvent.keyCode !== START_KEYCODE;
-	    case 'topKeyPress':
-	    case 'topMouseDown':
-	    case 'topBlur':
-	      // Events are not possible without cancelling IME.
-	      return true;
-	    default:
-	      return false;
-	  }
-	}
-
-	/**
-	 * Google Input Tools provides composition data via a CustomEvent,
-	 * with the `data` property populated in the `detail` object. If this
-	 * is available on the event object, use it. If not, this is a plain
-	 * composition event and we have nothing special to extract.
-	 *
-	 * @param {object} nativeEvent
-	 * @return {?string}
-	 */
-	function getDataFromCustomEvent(nativeEvent) {
-	  var detail = nativeEvent.detail;
-	  if (typeof detail === 'object' && 'data' in detail) {
-	    return detail.data;
-	  }
-	  return null;
-	}
-
-	// Track the current IME composition fallback object, if any.
-	var currentComposition = null;
-
-	/**
-	 * @return {?object} A SyntheticCompositionEvent.
-	 */
-	function extractCompositionEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-	  var eventType;
-	  var fallbackData;
-
-	  if (canUseCompositionEvent) {
-	    eventType = getCompositionEventType(topLevelType);
-	  } else if (!currentComposition) {
-	    if (isFallbackCompositionStart(topLevelType, nativeEvent)) {
-	      eventType = eventTypes.compositionStart;
-	    }
-	  } else if (isFallbackCompositionEnd(topLevelType, nativeEvent)) {
-	    eventType = eventTypes.compositionEnd;
-	  }
-
-	  if (!eventType) {
-	    return null;
-	  }
-
-	  if (useFallbackCompositionData) {
-	    // The current composition is stored statically and must not be
-	    // overwritten while composition continues.
-	    if (!currentComposition && eventType === eventTypes.compositionStart) {
-	      currentComposition = FallbackCompositionState.getPooled(nativeEventTarget);
-	    } else if (eventType === eventTypes.compositionEnd) {
-	      if (currentComposition) {
-	        fallbackData = currentComposition.getData();
-	      }
-	    }
-	  }
-
-	  var event = SyntheticCompositionEvent.getPooled(eventType, targetInst, nativeEvent, nativeEventTarget);
-
-	  if (fallbackData) {
-	    // Inject data generated from fallback path into the synthetic event.
-	    // This matches the property of native CompositionEventInterface.
-	    event.data = fallbackData;
-	  } else {
-	    var customData = getDataFromCustomEvent(nativeEvent);
-	    if (customData !== null) {
-	      event.data = customData;
-	    }
-	  }
-
-	  EventPropagators.accumulateTwoPhaseDispatches(event);
-	  return event;
-	}
-
-	/**
-	 * @param {string} topLevelType Record from `EventConstants`.
-	 * @param {object} nativeEvent Native browser event.
-	 * @return {?string} The string corresponding to this `beforeInput` event.
-	 */
-	function getNativeBeforeInputChars(topLevelType, nativeEvent) {
-	  switch (topLevelType) {
-	    case 'topCompositionEnd':
-	      return getDataFromCustomEvent(nativeEvent);
-	    case 'topKeyPress':
-	      /**
-	       * If native `textInput` events are available, our goal is to make
-	       * use of them. However, there is a special case: the spacebar key.
-	       * In Webkit, preventing default on a spacebar `textInput` event
-	       * cancels character insertion, but it *also* causes the browser
-	       * to fall back to its default spacebar behavior of scrolling the
-	       * page.
-	       *
-	       * Tracking at:
-	       * https://code.google.com/p/chromium/issues/detail?id=355103
-	       *
-	       * To avoid this issue, use the keypress event as if no `textInput`
-	       * event is available.
-	       */
-	      var which = nativeEvent.which;
-	      if (which !== SPACEBAR_CODE) {
-	        return null;
-	      }
-
-	      hasSpaceKeypress = true;
-	      return SPACEBAR_CHAR;
-
-	    case 'topTextInput':
-	      // Record the characters to be added to the DOM.
-	      var chars = nativeEvent.data;
-
-	      // If it's a spacebar character, assume that we have already handled
-	      // it at the keypress level and bail immediately. Android Chrome
-	      // doesn't give us keycodes, so we need to blacklist it.
-	      if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {
-	        return null;
-	      }
-
-	      return chars;
-
-	    default:
-	      // For other native event types, do nothing.
-	      return null;
-	  }
-	}
-
-	/**
-	 * For browsers that do not provide the `textInput` event, extract the
-	 * appropriate string to use for SyntheticInputEvent.
-	 *
-	 * @param {string} topLevelType Record from `EventConstants`.
-	 * @param {object} nativeEvent Native browser event.
-	 * @return {?string} The fallback string for this `beforeInput` event.
-	 */
-	function getFallbackBeforeInputChars(topLevelType, nativeEvent) {
-	  // If we are currently composing (IME) and using a fallback to do so,
-	  // try to extract the composed characters from the fallback object.
-	  // If composition event is available, we extract a string only at
-	  // compositionevent, otherwise extract it at fallback events.
-	  if (currentComposition) {
-	    if (topLevelType === 'topCompositionEnd' || !canUseCompositionEvent && isFallbackCompositionEnd(topLevelType, nativeEvent)) {
-	      var chars = currentComposition.getData();
-	      FallbackCompositionState.release(currentComposition);
-	      currentComposition = null;
-	      return chars;
-	    }
-	    return null;
-	  }
-
-	  switch (topLevelType) {
-	    case 'topPaste':
-	      // If a paste event occurs after a keypress, throw out the input
-	      // chars. Paste events should not lead to BeforeInput events.
-	      return null;
-	    case 'topKeyPress':
-	      /**
-	       * As of v27, Firefox may fire keypress events even when no character
-	       * will be inserted. A few possibilities:
-	       *
-	       * - `which` is `0`. Arrow keys, Esc key, etc.
-	       *
-	       * - `which` is the pressed key code, but no char is available.
-	       *   Ex: 'AltGr + d` in Polish. There is no modified character for
-	       *   this key combination and no character is inserted into the
-	       *   document, but FF fires the keypress for char code `100` anyway.
-	       *   No `input` event will occur.
-	       *
-	       * - `which` is the pressed key code, but a command combination is
-	       *   being used. Ex: `Cmd+C`. No character is inserted, and no
-	       *   `input` event will occur.
-	       */
-	      if (nativeEvent.which && !isKeypressCommand(nativeEvent)) {
-	        return String.fromCharCode(nativeEvent.which);
-	      }
-	      return null;
-	    case 'topCompositionEnd':
-	      return useFallbackCompositionData ? null : nativeEvent.data;
-	    default:
-	      return null;
-	  }
-	}
-
-	/**
-	 * Extract a SyntheticInputEvent for `beforeInput`, based on either native
-	 * `textInput` or fallback behavior.
-	 *
-	 * @return {?object} A SyntheticInputEvent.
-	 */
-	function extractBeforeInputEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-	  var chars;
-
-	  if (canUseTextInputEvent) {
-	    chars = getNativeBeforeInputChars(topLevelType, nativeEvent);
-	  } else {
-	    chars = getFallbackBeforeInputChars(topLevelType, nativeEvent);
-	  }
-
-	  // If no characters are being inserted, no BeforeInput event should
-	  // be fired.
-	  if (!chars) {
-	    return null;
-	  }
-
-	  var event = SyntheticInputEvent.getPooled(eventTypes.beforeInput, targetInst, nativeEvent, nativeEventTarget);
-
-	  event.data = chars;
-	  EventPropagators.accumulateTwoPhaseDispatches(event);
-	  return event;
-	}
-
-	/**
-	 * Create an `onBeforeInput` event to match
-	 * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.
-	 *
-	 * This event plugin is based on the native `textInput` event
-	 * available in Chrome, Safari, Opera, and IE. This event fires after
-	 * `onKeyPress` and `onCompositionEnd`, but before `onInput`.
-	 *
-	 * `beforeInput` is spec'd but not implemented in any browsers, and
-	 * the `input` event does not provide any useful information about what has
-	 * actually been added, contrary to the spec. Thus, `textInput` is the best
-	 * available event to identify the characters that have actually been inserted
-	 * into the target node.
-	 *
-	 * This plugin is also responsible for emitting `composition` events, thus
-	 * allowing us to share composition fallback code for both `beforeInput` and
-	 * `composition` event types.
-	 */
-	var BeforeInputEventPlugin = {
-
-	  eventTypes: eventTypes,
-
-	  extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-	    return [extractCompositionEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget), extractBeforeInputEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget)];
-	  }
-	};
-
-	module.exports = BeforeInputEventPlugin;
-
-/***/ },
-/* 42 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var EventPluginHub = __webpack_require__(43);
-	var EventPluginUtils = __webpack_require__(45);
-
-	var accumulateInto = __webpack_require__(49);
-	var forEachAccumulated = __webpack_require__(50);
-	var warning = __webpack_require__(47);
-
-	var getListener = EventPluginHub.getListener;
-
-	/**
-	 * Some event types have a notion of different registration names for different
-	 * "phases" of propagation. This finds listeners by a given phase.
-	 */
-	function listenerAtPhase(inst, event, propagationPhase) {
-	  var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
-	  return getListener(inst, registrationName);
-	}
-
-	/**
-	 * 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(inst, phase, event) {
-	  if (process.env.NODE_ENV !== 'production') {
-	    process.env.NODE_ENV !== 'production' ? warning(inst, 'Dispatching inst must not be null') : void 0;
-	  }
-	  var listener = listenerAtPhase(inst, event, phase);
-	  if (listener) {
-	    event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
-	    event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
-	  }
-	}
-
-	/**
-	 * 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 cannot perform a
-	 * single traversal for the entire collection of events because each event may
-	 * have a different target.
-	 */
-	function accumulateTwoPhaseDispatchesSingle(event) {
-	  if (event && event.dispatchConfig.phasedRegistrationNames) {
-	    EventPluginUtils.traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
-	  }
-	}
-
-	/**
-	 * Same as `accumulateTwoPhaseDispatchesSingle`, but skips over the targetID.
-	 */
-	function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
-	  if (event && event.dispatchConfig.phasedRegistrationNames) {
-	    var targetInst = event._targetInst;
-	    var parentInst = targetInst ? EventPluginUtils.getParentInstance(targetInst) : null;
-	    EventPluginUtils.traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
-	  }
-	}
-
-	/**
-	 * Accumulates without regard to direction, does not look for phased
-	 * registration names. Same as `accumulateDirectDispatchesSingle` but without
-	 * requiring that the `dispatchMarker` be the same as the dispatched ID.
-	 */
-	function accumulateDispatches(inst, ignoredDirection, event) {
-	  if (event && event.dispatchConfig.registrationName) {
-	    var registrationName = event.dispatchConfig.registrationName;
-	    var listener = getListener(inst, registrationName);
-	    if (listener) {
-	      event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
-	      event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
-	    }
-	  }
-	}
-
-	/**
-	 * Accumulates dispatches on an `SyntheticEvent`, but only for the
-	 * `dispatchMarker`.
-	 * @param {SyntheticEvent} event
-	 */
-	function accumulateDirectDispatchesSingle(event) {
-	  if (event && event.dispatchConfig.registrationName) {
-	    accumulateDispatches(event._targetInst, null, event);
-	  }
-	}
-
-	function accumulateTwoPhaseDispatches(events) {
-	  forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);
-	}
-
-	function accumulateTwoPhaseDispatchesSkipTarget(events) {
-	  forEachAccumulated(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
-	}
-
-	function accumulateEnterLeaveDispatches(leave, enter, from, to) {
-	  EventPluginUtils.traverseEnterLeave(from, to, accumulateDispatches, leave, enter);
-	}
-
-	function accumulateDirectDispatches(events) {
-	  forEachAccumulated(events, 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,
-	  accumulateTwoPhaseDispatchesSkipTarget: accumulateTwoPhaseDispatchesSkipTarget,
-	  accumulateDirectDispatches: accumulateDirectDispatches,
-	  accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches
-	};
-
-	module.exports = EventPropagators;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 43 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var EventPluginRegistry = __webpack_require__(44);
-	var EventPluginUtils = __webpack_require__(45);
-	var ReactErrorUtils = __webpack_require__(46);
-
-	var accumulateInto = __webpack_require__(49);
-	var forEachAccumulated = __webpack_require__(50);
-	var invariant = __webpack_require__(37);
-
-	/**
-	 * Internal store for event listeners
-	 */
-	var listenerBank = {};
-
-	/**
-	 * Internal queue of events that have accumulated their dispatches and are
-	 * waiting to have their dispatches executed.
-	 */
-	var eventQueue = null;
-
-	/**
-	 * Dispatches an event and releases it back into the pool, unless persistent.
-	 *
-	 * @param {?object} event Synthetic event to be dispatched.
-	 * @param {boolean} simulated If the event is simulated (changes exn behavior)
-	 * @private
-	 */
-	var executeDispatchesAndRelease = function (event, simulated) {
-	  if (event) {
-	    EventPluginUtils.executeDispatchesInOrder(event, simulated);
-
-	    if (!event.isPersistent()) {
-	      event.constructor.release(event);
-	    }
-	  }
-	};
-	var executeDispatchesAndReleaseSimulated = function (e) {
-	  return executeDispatchesAndRelease(e, true);
-	};
-	var executeDispatchesAndReleaseTopLevel = function (e) {
-	  return executeDispatchesAndRelease(e, false);
-	};
-
-	var getDictionaryKey = function (inst) {
-	  // Prevents V8 performance issue:
-	  // https://github.com/facebook/react/pull/7232
-	  return '.' + inst._rootNodeID;
-	};
-
-	function isInteractive(tag) {
-	  return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea';
-	}
-
-	function shouldPreventMouseEvent(name, type, props) {
-	  switch (name) {
-	    case 'onClick':
-	    case 'onClickCapture':
-	    case 'onDoubleClick':
-	    case 'onDoubleClickCapture':
-	    case 'onMouseDown':
-	    case 'onMouseDownCapture':
-	    case 'onMouseMove':
-	    case 'onMouseMoveCapture':
-	    case 'onMouseUp':
-	    case 'onMouseUpCapture':
-	      return !!(props.disabled && isInteractive(type));
-	    default:
-	      return false;
-	  }
-	}
-
-	/**
-	 * This is a unified interface for event plugins to be installed and configured.
-	 *
-	 * Event plugins can implement the following properties:
-	 *
-	 *   `extractEvents` {function(string, DOMEventTarget, string, object): *}
-	 *     Required. When a top-level event is fired, this method is expected to
-	 *     extract synthetic events that will in turn be queued and dispatched.
-	 *
-	 *   `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`.
-	 *
-	 *   `executeDispatch` {function(object, function, string)}
-	 *     Optional, allows plugins to override how an event gets dispatched. By
-	 *     default, the listener is simply invoked.
-	 *
-	 * Each plugin that is injected into `EventsPluginHub` is immediately operable.
-	 *
-	 * @public
-	 */
-	var EventPluginHub = {
-
-	  /**
-	   * Methods for injecting dependencies.
-	   */
-	  injection: {
-
-	    /**
-	     * @param {array} InjectedEventPluginOrder
-	     * @public
-	     */
-	    injectEventPluginOrder: EventPluginRegistry.injectEventPluginOrder,
-
-	    /**
-	     * @param {object} injectedNamesToPlugins Map from names to plugin modules.
-	     */
-	    injectEventPluginsByName: EventPluginRegistry.injectEventPluginsByName
-
-	  },
-
-	  /**
-	   * Stores `listener` at `listenerBank[registrationName][key]`. Is idempotent.
-	   *
-	   * @param {object} inst The instance, which is the source of events.
-	   * @param {string} registrationName Name of listener (e.g. `onClick`).
-	   * @param {function} listener The callback to store.
-	   */
-	  putListener: function (inst, registrationName, listener) {
-	    !(typeof listener === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected %s listener to be a function, instead got type %s', registrationName, typeof listener) : _prodInvariant('94', registrationName, typeof listener) : void 0;
-
-	    var key = getDictionaryKey(inst);
-	    var bankForRegistrationName = listenerBank[registrationName] || (listenerBank[registrationName] = {});
-	    bankForRegistrationName[key] = listener;
-
-	    var PluginModule = EventPluginRegistry.registrationNameModules[registrationName];
-	    if (PluginModule && PluginModule.didPutListener) {
-	      PluginModule.didPutListener(inst, registrationName, listener);
-	    }
-	  },
-
-	  /**
-	   * @param {object} inst The instance, which is the source of events.
-	   * @param {string} registrationName Name of listener (e.g. `onClick`).
-	   * @return {?function} The stored callback.
-	   */
-	  getListener: function (inst, registrationName) {
-	    // TODO: shouldPreventMouseEvent is DOM-specific and definitely should not
-	    // live here; needs to be moved to a better place soon
-	    var bankForRegistrationName = listenerBank[registrationName];
-	    if (shouldPreventMouseEvent(registrationName, inst._currentElement.type, inst._currentElement.props)) {
-	      return null;
-	    }
-	    var key = getDictionaryKey(inst);
-	    return bankForRegistrationName && bankForRegistrationName[key];
-	  },
-
-	  /**
-	   * Deletes a listener from the registration bank.
-	   *
-	   * @param {object} inst The instance, which is the source of events.
-	   * @param {string} registrationName Name of listener (e.g. `onClick`).
-	   */
-	  deleteListener: function (inst, registrationName) {
-	    var PluginModule = EventPluginRegistry.registrationNameModules[registrationName];
-	    if (PluginModule && PluginModule.willDeleteListener) {
-	      PluginModule.willDeleteListener(inst, registrationName);
-	    }
-
-	    var bankForRegistrationName = listenerBank[registrationName];
-	    // TODO: This should never be null -- when is it?
-	    if (bankForRegistrationName) {
-	      var key = getDictionaryKey(inst);
-	      delete bankForRegistrationName[key];
-	    }
-	  },
-
-	  /**
-	   * Deletes all listeners for the DOM element with the supplied ID.
-	   *
-	   * @param {object} inst The instance, which is the source of events.
-	   */
-	  deleteAllListeners: function (inst) {
-	    var key = getDictionaryKey(inst);
-	    for (var registrationName in listenerBank) {
-	      if (!listenerBank.hasOwnProperty(registrationName)) {
-	        continue;
-	      }
-
-	      if (!listenerBank[registrationName][key]) {
-	        continue;
-	      }
-
-	      var PluginModule = EventPluginRegistry.registrationNameModules[registrationName];
-	      if (PluginModule && PluginModule.willDeleteListener) {
-	        PluginModule.willDeleteListener(inst, registrationName);
-	      }
-
-	      delete listenerBank[registrationName][key];
-	    }
-	  },
-
-	  /**
-	   * Allows registered plugins an opportunity to extract events from top-level
-	   * native browser events.
-	   *
-	   * @return {*} An accumulation of synthetic events.
-	   * @internal
-	   */
-	  extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-	    var events;
-	    var plugins = EventPluginRegistry.plugins;
-	    for (var i = 0; i < plugins.length; i++) {
-	      // Not every plugin in the ordering may be loaded at runtime.
-	      var possiblePlugin = plugins[i];
-	      if (possiblePlugin) {
-	        var extractedEvents = possiblePlugin.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
-	        if (extractedEvents) {
-	          events = accumulateInto(events, extractedEvents);
-	        }
-	      }
-	    }
-	    return events;
-	  },
-
-	  /**
-	   * Enqueues a synthetic event that should be dispatched when
-	   * `processEventQueue` is invoked.
-	   *
-	   * @param {*} events An accumulation of synthetic events.
-	   * @internal
-	   */
-	  enqueueEvents: function (events) {
-	    if (events) {
-	      eventQueue = accumulateInto(eventQueue, events);
-	    }
-	  },
-
-	  /**
-	   * Dispatches all synthetic events on the event queue.
-	   *
-	   * @internal
-	   */
-	  processEventQueue: function (simulated) {
-	    // Set `eventQueue` to null before processing it so that we can tell if more
-	    // events get enqueued while processing.
-	    var processingEventQueue = eventQueue;
-	    eventQueue = null;
-	    if (simulated) {
-	      forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseSimulated);
-	    } else {
-	      forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseTopLevel);
-	    }
-	    !!eventQueue ? process.env.NODE_ENV !== 'production' ? invariant(false, 'processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented.') : _prodInvariant('95') : void 0;
-	    // This would be a good time to rethrow if any of the event handlers threw.
-	    ReactErrorUtils.rethrowCaughtError();
-	  },
-
-	  /**
-	   * These are needed for tests only. Do not use!
-	   */
-	  __purge: function () {
-	    listenerBank = {};
-	  },
-
-	  __getListenerBank: function () {
-	    return listenerBank;
-	  }
-
-	};
-
-	module.exports = EventPluginHub;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 44 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var invariant = __webpack_require__(37);
-
-	/**
-	 * Injectable ordering of event plugins.
-	 */
-	var eventPluginOrder = null;
-
-	/**
-	 * Injectable mapping from names to event plugin modules.
-	 */
-	var namesToPlugins = {};
-
-	/**
-	 * Recomputes the plugin list using the injected plugins and plugin ordering.
-	 *
-	 * @private
-	 */
-	function recomputePluginOrdering() {
-	  if (!eventPluginOrder) {
-	    // Wait until an `eventPluginOrder` is injected.
-	    return;
-	  }
-	  for (var pluginName in namesToPlugins) {
-	    var pluginModule = namesToPlugins[pluginName];
-	    var pluginIndex = eventPluginOrder.indexOf(pluginName);
-	    !(pluginIndex > -1) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `%s`.', pluginName) : _prodInvariant('96', pluginName) : void 0;
-	    if (EventPluginRegistry.plugins[pluginIndex]) {
-	      continue;
-	    }
-	    !pluginModule.extractEvents ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `%s` does not.', pluginName) : _prodInvariant('97', pluginName) : void 0;
-	    EventPluginRegistry.plugins[pluginIndex] = pluginModule;
-	    var publishedEvents = pluginModule.eventTypes;
-	    for (var eventName in publishedEvents) {
-	      !publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.', eventName, pluginName) : _prodInvariant('98', eventName, pluginName) : void 0;
-	    }
-	  }
-	}
-
-	/**
-	 * Publishes an event so that it can be dispatched by the supplied plugin.
-	 *
-	 * @param {object} dispatchConfig Dispatch configuration for the event.
-	 * @param {object} PluginModule Plugin publishing the event.
-	 * @return {boolean} True if the event was successfully published.
-	 * @private
-	 */
-	function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {
-	  !!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same event name, `%s`.', eventName) : _prodInvariant('99', eventName) : void 0;
-	  EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig;
-
-	  var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
-	  if (phasedRegistrationNames) {
-	    for (var phaseName in phasedRegistrationNames) {
-	      if (phasedRegistrationNames.hasOwnProperty(phaseName)) {
-	        var phasedRegistrationName = phasedRegistrationNames[phaseName];
-	        publishRegistrationName(phasedRegistrationName, pluginModule, eventName);
-	      }
-	    }
-	    return true;
-	  } else if (dispatchConfig.registrationName) {
-	    publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName);
-	    return true;
-	  }
-	  return false;
-	}
-
-	/**
-	 * Publishes a registration name that is used to identify dispatched events and
-	 * can be used with `EventPluginHub.putListener` to register listeners.
-	 *
-	 * @param {string} registrationName Registration name to add.
-	 * @param {object} PluginModule Plugin publishing the event.
-	 * @private
-	 */
-	function publishRegistrationName(registrationName, pluginModule, eventName) {
-	  !!EventPluginRegistry.registrationNameModules[registrationName] ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same registration name, `%s`.', registrationName) : _prodInvariant('100', registrationName) : void 0;
-	  EventPluginRegistry.registrationNameModules[registrationName] = pluginModule;
-	  EventPluginRegistry.registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies;
-
-	  if (process.env.NODE_ENV !== 'production') {
-	    var lowerCasedName = registrationName.toLowerCase();
-	    EventPluginRegistry.possibleRegistrationNames[lowerCasedName] = registrationName;
-
-	    if (registrationName === 'onDoubleClick') {
-	      EventPluginRegistry.possibleRegistrationNames.ondblclick = registrationName;
-	    }
-	  }
-	}
-
-	/**
-	 * Registers plugins so that they can extract and dispatch events.
-	 *
-	 * @see {EventPluginHub}
-	 */
-	var EventPluginRegistry = {
-
-	  /**
-	   * Ordered list of injected plugins.
-	   */
-	  plugins: [],
-
-	  /**
-	   * Mapping from event name to dispatch config
-	   */
-	  eventNameDispatchConfigs: {},
-
-	  /**
-	   * Mapping from registration name to plugin module
-	   */
-	  registrationNameModules: {},
-
-	  /**
-	   * Mapping from registration name to event name
-	   */
-	  registrationNameDependencies: {},
-
-	  /**
-	   * Mapping from lowercase registration names to the properly cased version,
-	   * used to warn in the case of missing event handlers. Available
-	   * only in __DEV__.
-	   * @type {Object}
-	   */
-	  possibleRegistrationNames: process.env.NODE_ENV !== 'production' ? {} : null,
-	  // Trust the developer to only use possibleRegistrationNames in __DEV__
-
-	  /**
-	   * Injects an ordering of plugins (by plugin name). This allows the ordering
-	   * to be decoupled from injection of the actual plugins so that ordering is
-	   * always deterministic regardless of packaging, on-the-fly injection, etc.
-	   *
-	   * @param {array} InjectedEventPluginOrder
-	   * @internal
-	   * @see {EventPluginHub.injection.injectEventPluginOrder}
-	   */
-	  injectEventPluginOrder: function (injectedEventPluginOrder) {
-	    !!eventPluginOrder ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React.') : _prodInvariant('101') : void 0;
-	    // Clone the ordering so it cannot be dynamically mutated.
-	    eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder);
-	    recomputePluginOrdering();
-	  },
-
-	  /**
-	   * Injects plugins to be used by `EventPluginHub`. The plugin names must be
-	   * in the ordering injected by `injectEventPluginOrder`.
-	   *
-	   * Plugins can be injected as part of page initialization or on-the-fly.
-	   *
-	   * @param {object} injectedNamesToPlugins Map from names to plugin modules.
-	   * @internal
-	   * @see {EventPluginHub.injection.injectEventPluginsByName}
-	   */
-	  injectEventPluginsByName: function (injectedNamesToPlugins) {
-	    var isOrderingDirty = false;
-	    for (var pluginName in injectedNamesToPlugins) {
-	      if (!injectedNamesToPlugins.hasOwnProperty(pluginName)) {
-	        continue;
-	      }
-	      var pluginModule = injectedNamesToPlugins[pluginName];
-	      if (!namesToPlugins.hasOwnProperty(pluginName) || namesToPlugins[pluginName] !== pluginModule) {
-	        !!namesToPlugins[pluginName] ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject two different event plugins using the same name, `%s`.', pluginName) : _prodInvariant('102', pluginName) : void 0;
-	        namesToPlugins[pluginName] = pluginModule;
-	        isOrderingDirty = true;
-	      }
-	    }
-	    if (isOrderingDirty) {
-	      recomputePluginOrdering();
-	    }
-	  },
-
-	  /**
-	   * Looks up the plugin for the supplied event.
-	   *
-	   * @param {object} event A synthetic event.
-	   * @return {?object} The plugin that created the supplied event.
-	   * @internal
-	   */
-	  getPluginModuleForEvent: function (event) {
-	    var dispatchConfig = event.dispatchConfig;
-	    if (dispatchConfig.registrationName) {
-	      return EventPluginRegistry.registrationNameModules[dispatchConfig.registrationName] || null;
-	    }
-	    if (dispatchConfig.phasedRegistrationNames !== undefined) {
-	      // pulling phasedRegistrationNames out of dispatchConfig helps Flow see
-	      // that it is not undefined.
-	      var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
-
-	      for (var phase in phasedRegistrationNames) {
-	        if (!phasedRegistrationNames.hasOwnProperty(phase)) {
-	          continue;
-	        }
-	        var pluginModule = EventPluginRegistry.registrationNameModules[phasedRegistrationNames[phase]];
-	        if (pluginModule) {
-	          return pluginModule;
-	        }
-	      }
-	    }
-	    return null;
-	  },
-
-	  /**
-	   * Exposed for unit testing.
-	   * @private
-	   */
-	  _resetEventPlugins: function () {
-	    eventPluginOrder = null;
-	    for (var pluginName in namesToPlugins) {
-	      if (namesToPlugins.hasOwnProperty(pluginName)) {
-	        delete namesToPlugins[pluginName];
-	      }
-	    }
-	    EventPluginRegistry.plugins.length = 0;
-
-	    var eventNameDispatchConfigs = EventPluginRegistry.eventNameDispatchConfigs;
-	    for (var eventName in eventNameDispatchConfigs) {
-	      if (eventNameDispatchConfigs.hasOwnProperty(eventName)) {
-	        delete eventNameDispatchConfigs[eventName];
-	      }
-	    }
-
-	    var registrationNameModules = EventPluginRegistry.registrationNameModules;
-	    for (var registrationName in registrationNameModules) {
-	      if (registrationNameModules.hasOwnProperty(registrationName)) {
-	        delete registrationNameModules[registrationName];
-	      }
-	    }
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      var possibleRegistrationNames = EventPluginRegistry.possibleRegistrationNames;
-	      for (var lowerCasedName in possibleRegistrationNames) {
-	        if (possibleRegistrationNames.hasOwnProperty(lowerCasedName)) {
-	          delete possibleRegistrationNames[lowerCasedName];
-	        }
-	      }
-	    }
-	  }
-
-	};
-
-	module.exports = EventPluginRegistry;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 45 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var ReactErrorUtils = __webpack_require__(46);
-
-	var invariant = __webpack_require__(37);
-	var warning = __webpack_require__(47);
-
-	/**
-	 * Injected dependencies:
-	 */
-
-	/**
-	 * - `ComponentTree`: [required] Module that can convert between React instances
-	 *   and actual node references.
-	 */
-	var ComponentTree;
-	var TreeTraversal;
-	var injection = {
-	  injectComponentTree: function (Injected) {
-	    ComponentTree = Injected;
-	    if (process.env.NODE_ENV !== 'production') {
-	      process.env.NODE_ENV !== 'production' ? warning(Injected && Injected.getNodeFromInstance && Injected.getInstanceFromNode, 'EventPluginUtils.injection.injectComponentTree(...): Injected ' + 'module is missing getNodeFromInstance or getInstanceFromNode.') : void 0;
-	    }
-	  },
-	  injectTreeTraversal: function (Injected) {
-	    TreeTraversal = Injected;
-	    if (process.env.NODE_ENV !== 'production') {
-	      process.env.NODE_ENV !== 'production' ? warning(Injected && Injected.isAncestor && Injected.getLowestCommonAncestor, 'EventPluginUtils.injection.injectTreeTraversal(...): Injected ' + 'module is missing isAncestor or getLowestCommonAncestor.') : void 0;
-	    }
-	  }
-	};
-
-	function isEndish(topLevelType) {
-	  return topLevelType === 'topMouseUp' || topLevelType === 'topTouchEnd' || topLevelType === 'topTouchCancel';
-	}
-
-	function isMoveish(topLevelType) {
-	  return topLevelType === 'topMouseMove' || topLevelType === 'topTouchMove';
-	}
-	function isStartish(topLevelType) {
-	  return topLevelType === 'topMouseDown' || topLevelType === 'topTouchStart';
-	}
-
-	var validateEventDispatches;
-	if (process.env.NODE_ENV !== 'production') {
-	  validateEventDispatches = function (event) {
-	    var dispatchListeners = event._dispatchListeners;
-	    var dispatchInstances = event._dispatchInstances;
-
-	    var listenersIsArr = Array.isArray(dispatchListeners);
-	    var listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0;
-
-	    var instancesIsArr = Array.isArray(dispatchInstances);
-	    var instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;
-
-	    process.env.NODE_ENV !== 'production' ? warning(instancesIsArr === listenersIsArr && instancesLen === listenersLen, 'EventPluginUtils: Invalid `event`.') : void 0;
-	  };
-	}
-
-	/**
-	 * Dispatch the event to the listener.
-	 * @param {SyntheticEvent} event SyntheticEvent to handle
-	 * @param {boolean} simulated If the event is simulated (changes exn behavior)
-	 * @param {function} listener Application-level callback
-	 * @param {*} inst Internal component instance
-	 */
-	function executeDispatch(event, simulated, listener, inst) {
-	  var type = event.type || 'unknown-event';
-	  event.currentTarget = EventPluginUtils.getNodeFromInstance(inst);
-	  if (simulated) {
-	    ReactErrorUtils.invokeGuardedCallbackWithCatch(type, listener, event);
-	  } else {
-	    ReactErrorUtils.invokeGuardedCallback(type, listener, event);
-	  }
-	  event.currentTarget = null;
-	}
-
-	/**
-	 * Standard/simple iteration through an event's collected dispatches.
-	 */
-	function executeDispatchesInOrder(event, simulated) {
-	  var dispatchListeners = event._dispatchListeners;
-	  var dispatchInstances = event._dispatchInstances;
-	  if (process.env.NODE_ENV !== 'production') {
-	    validateEventDispatches(event);
-	  }
-	  if (Array.isArray(dispatchListeners)) {
-	    for (var i = 0; i < dispatchListeners.length; i++) {
-	      if (event.isPropagationStopped()) {
-	        break;
-	      }
-	      // Listeners and Instances are two parallel arrays that are always in sync.
-	      executeDispatch(event, simulated, dispatchListeners[i], dispatchInstances[i]);
-	    }
-	  } else if (dispatchListeners) {
-	    executeDispatch(event, simulated, dispatchListeners, dispatchInstances);
-	  }
-	  event._dispatchListeners = null;
-	  event._dispatchInstances = null;
-	}
-
-	/**
-	 * Standard/simple iteration through an event's collected dispatches, but stops
-	 * at the first dispatch execution returning true, and returns that id.
-	 *
-	 * @return {?string} id of the first dispatch execution who's listener returns
-	 * true, or null if no listener returned true.
-	 */
-	function executeDispatchesInOrderStopAtTrueImpl(event) {
-	  var dispatchListeners = event._dispatchListeners;
-	  var dispatchInstances = event._dispatchInstances;
-	  if (process.env.NODE_ENV !== 'production') {
-	    validateEventDispatches(event);
-	  }
-	  if (Array.isArray(dispatchListeners)) {
-	    for (var i = 0; i < dispatchListeners.length; i++) {
-	      if (event.isPropagationStopped()) {
-	        break;
-	      }
-	      // Listeners and Instances are two parallel arrays that are always in sync.
-	      if (dispatchListeners[i](event, dispatchInstances[i])) {
-	        return dispatchInstances[i];
-	      }
-	    }
-	  } else if (dispatchListeners) {
-	    if (dispatchListeners(event, dispatchInstances)) {
-	      return dispatchInstances;
-	    }
-	  }
-	  return null;
-	}
-
-	/**
-	 * @see executeDispatchesInOrderStopAtTrueImpl
-	 */
-	function executeDispatchesInOrderStopAtTrue(event) {
-	  var ret = executeDispatchesInOrderStopAtTrueImpl(event);
-	  event._dispatchInstances = null;
-	  event._dispatchListeners = null;
-	  return ret;
-	}
-
-	/**
-	 * 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.
-	 *
-	 * @return {*} The return value of executing the single dispatch.
-	 */
-	function executeDirectDispatch(event) {
-	  if (process.env.NODE_ENV !== 'production') {
-	    validateEventDispatches(event);
-	  }
-	  var dispatchListener = event._dispatchListeners;
-	  var dispatchInstance = event._dispatchInstances;
-	  !!Array.isArray(dispatchListener) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'executeDirectDispatch(...): Invalid `event`.') : _prodInvariant('103') : void 0;
-	  event.currentTarget = dispatchListener ? EventPluginUtils.getNodeFromInstance(dispatchInstance) : null;
-	  var res = dispatchListener ? dispatchListener(event) : null;
-	  event.currentTarget = null;
-	  event._dispatchListeners = null;
-	  event._dispatchInstances = null;
-	  return res;
-	}
-
-	/**
-	 * @param {SyntheticEvent} event
-	 * @return {boolean} True iff number of dispatches accumulated is greater than 0.
-	 */
-	function hasDispatches(event) {
-	  return !!event._dispatchListeners;
-	}
-
-	/**
-	 * General utilities that are useful in creating custom Event Plugins.
-	 */
-	var EventPluginUtils = {
-	  isEndish: isEndish,
-	  isMoveish: isMoveish,
-	  isStartish: isStartish,
-
-	  executeDirectDispatch: executeDirectDispatch,
-	  executeDispatchesInOrder: executeDispatchesInOrder,
-	  executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,
-	  hasDispatches: hasDispatches,
-
-	  getInstanceFromNode: function (node) {
-	    return ComponentTree.getInstanceFromNode(node);
-	  },
-	  getNodeFromInstance: function (node) {
-	    return ComponentTree.getNodeFromInstance(node);
-	  },
-	  isAncestor: function (a, b) {
-	    return TreeTraversal.isAncestor(a, b);
-	  },
-	  getLowestCommonAncestor: function (a, b) {
-	    return TreeTraversal.getLowestCommonAncestor(a, b);
-	  },
-	  getParentInstance: function (inst) {
-	    return TreeTraversal.getParentInstance(inst);
-	  },
-	  traverseTwoPhase: function (target, fn, arg) {
-	    return TreeTraversal.traverseTwoPhase(target, fn, arg);
-	  },
-	  traverseEnterLeave: function (from, to, fn, argFrom, argTo) {
-	    return TreeTraversal.traverseEnterLeave(from, to, fn, argFrom, argTo);
-	  },
-
-	  injection: injection
-	};
-
-	module.exports = EventPluginUtils;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 46 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var caughtError = null;
-
-	/**
-	 * Call a function while guarding against errors that happens within it.
-	 *
-	 * @param {String} name of the guard to use for logging or debugging
-	 * @param {Function} func The function to invoke
-	 * @param {*} a First argument
-	 * @param {*} b Second argument
-	 */
-	function invokeGuardedCallback(name, func, a) {
-	  try {
-	    func(a);
-	  } catch (x) {
-	    if (caughtError === null) {
-	      caughtError = x;
-	    }
-	  }
-	}
-
-	var ReactErrorUtils = {
-	  invokeGuardedCallback: invokeGuardedCallback,
-
-	  /**
-	   * Invoked by ReactTestUtils.Simulate so that any errors thrown by the event
-	   * handler are sure to be rethrown by rethrowCaughtError.
-	   */
-	  invokeGuardedCallbackWithCatch: invokeGuardedCallback,
-
-	  /**
-	   * During execution of guarded functions we will capture the first error which
-	   * we will rethrow to be handled by the top level error handler.
-	   */
-	  rethrowCaughtError: function () {
-	    if (caughtError) {
-	      var error = caughtError;
-	      caughtError = null;
-	      throw error;
-	    }
-	  }
-	};
-
-	if (process.env.NODE_ENV !== 'production') {
-	  /**
-	   * To help development we can get better devtools integration by simulating a
-	   * real browser event.
-	   */
-	  if (typeof window !== 'undefined' && typeof window.dispatchEvent === 'function' && typeof document !== 'undefined' && typeof document.createEvent === 'function') {
-	    var fakeNode = document.createElement('react');
-	    ReactErrorUtils.invokeGuardedCallback = function (name, func, a) {
-	      var boundFunc = func.bind(null, a);
-	      var evtType = 'react-' + name;
-	      fakeNode.addEventListener(evtType, boundFunc, false);
-	      var evt = document.createEvent('Event');
-	      // $FlowFixMe https://github.com/facebook/flow/issues/2336
-	      evt.initEvent(evtType, false, false);
-	      fakeNode.dispatchEvent(evt);
-	      fakeNode.removeEventListener(evtType, boundFunc, false);
-	    };
-	  }
-	}
-
-	module.exports = ReactErrorUtils;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 47 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2014-2015, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var emptyFunction = __webpack_require__(48);
-
-	/**
-	 * Similar to invariant but only logs a warning if the condition is not met.
-	 * This can be used to log issues in development environments in critical
-	 * paths. Removing the logging code for production environments will keep the
-	 * same logic and follow the same code paths.
-	 */
-
-	var warning = emptyFunction;
-
-	if (process.env.NODE_ENV !== 'production') {
-	  (function () {
-	    var printWarning = function printWarning(format) {
-	      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-	        args[_key - 1] = arguments[_key];
-	      }
-
-	      var argIndex = 0;
-	      var message = 'Warning: ' + format.replace(/%s/g, function () {
-	        return args[argIndex++];
-	      });
-	      if (typeof console !== 'undefined') {
-	        console.error(message);
-	      }
-	      try {
-	        // --- Welcome to debugging React ---
-	        // This error was thrown as a convenience so that you can use this stack
-	        // to find the callsite that caused this warning to fire.
-	        throw new Error(message);
-	      } catch (x) {}
-	    };
-
-	    warning = function warning(condition, format) {
-	      if (format === undefined) {
-	        throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
-	      }
-
-	      if (format.indexOf('Failed Composite propType: ') === 0) {
-	        return; // Ignore CompositeComponent proptype check.
-	      }
-
-	      if (!condition) {
-	        for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
-	          args[_key2 - 2] = arguments[_key2];
-	        }
-
-	        printWarning.apply(undefined, [format].concat(args));
-	      }
-	    };
-	  })();
-	}
-
-	module.exports = warning;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 48 */
-/***/ function(module, exports) {
-
-	"use strict";
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	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.
-	 */
-	var emptyFunction = function emptyFunction() {};
-
-	emptyFunction.thatReturns = makeEmptyFunction;
-	emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
-	emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
-	emptyFunction.thatReturnsNull = makeEmptyFunction(null);
-	emptyFunction.thatReturnsThis = function () {
-	  return this;
-	};
-	emptyFunction.thatReturnsArgument = function (arg) {
-	  return arg;
-	};
-
-	module.exports = emptyFunction;
-
-/***/ },
-/* 49 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2014-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var invariant = __webpack_require__(37);
-
-	/**
-	 * Accumulates items that must not be null or undefined into the first one. This
-	 * is used to conserve memory by avoiding array allocations, and thus sacrifices
-	 * API cleanness. Since `current` can be null before being passed in and not
-	 * null after this function, make sure to assign it back to `current`:
-	 *
-	 * `a = accumulateInto(a, b);`
-	 *
-	 * This API should be sparingly used. Try `accumulate` for something cleaner.
-	 *
-	 * @return {*|array<*>} An accumulation of items.
-	 */
-
-	function accumulateInto(current, next) {
-	  !(next != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'accumulateInto(...): Accumulated items must not be null or undefined.') : _prodInvariant('30') : void 0;
-
-	  if (current == null) {
-	    return next;
-	  }
-
-	  // 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).
-	  if (Array.isArray(current)) {
-	    if (Array.isArray(next)) {
-	      current.push.apply(current, next);
-	      return current;
-	    }
-	    current.push(next);
-	    return current;
-	  }
-
-	  if (Array.isArray(next)) {
-	    // A bit too dangerous to mutate `next`.
-	    return [current].concat(next);
-	  }
-
-	  return [current, next];
-	}
-
-	module.exports = accumulateInto;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 50 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	/**
-	 * @param {array} arr 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).
-	 */
-
-	function forEachAccumulated(arr, cb, scope) {
-	  if (Array.isArray(arr)) {
-	    arr.forEach(cb, scope);
-	  } else if (arr) {
-	    cb.call(scope, arr);
-	  }
-	}
-
-	module.exports = forEachAccumulated;
-
-/***/ },
-/* 51 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
-
-	/**
-	 * 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',
-
-	  canUseEventListeners: canUseDOM && !!(window.addEventListener || window.attachEvent),
-
-	  canUseViewport: canUseDOM && !!window.screen,
-
-	  isInWorker: !canUseDOM // For now, this is true - might change in the future.
-
-	};
-
-	module.exports = ExecutionEnvironment;
-
-/***/ },
-/* 52 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _assign = __webpack_require__(53);
-
-	var PooledClass = __webpack_require__(54);
-
-	var getTextContentAccessor = __webpack_require__(55);
-
-	/**
-	 * This helper class stores information about text content of a target node,
-	 * allowing comparison of content before and after a given event.
-	 *
-	 * Identify the node where selection currently begins, then observe
-	 * both its text content and its current position in the DOM. Since the
-	 * browser may natively replace the target node during composition, we can
-	 * use its position to find its replacement.
-	 *
-	 * @param {DOMEventTarget} root
-	 */
-	function FallbackCompositionState(root) {
-	  this._root = root;
-	  this._startText = this.getText();
-	  this._fallbackText = null;
-	}
-
-	_assign(FallbackCompositionState.prototype, {
-	  destructor: function () {
-	    this._root = null;
-	    this._startText = null;
-	    this._fallbackText = null;
-	  },
-
-	  /**
-	   * Get current text of input.
-	   *
-	   * @return {string}
-	   */
-	  getText: function () {
-	    if ('value' in this._root) {
-	      return this._root.value;
-	    }
-	    return this._root[getTextContentAccessor()];
-	  },
-
-	  /**
-	   * Determine the differing substring between the initially stored
-	   * text content and the current content.
-	   *
-	   * @return {string}
-	   */
-	  getData: function () {
-	    if (this._fallbackText) {
-	      return this._fallbackText;
-	    }
-
-	    var start;
-	    var startValue = this._startText;
-	    var startLength = startValue.length;
-	    var end;
-	    var endValue = this.getText();
-	    var endLength = endValue.length;
-
-	    for (start = 0; start < startLength; start++) {
-	      if (startValue[start] !== endValue[start]) {
-	        break;
-	      }
-	    }
-
-	    var minEnd = startLength - start;
-	    for (end = 1; end <= minEnd; end++) {
-	      if (startValue[startLength - end] !== endValue[endLength - end]) {
-	        break;
-	      }
-	    }
-
-	    var sliceTail = end > 1 ? 1 - end : undefined;
-	    this._fallbackText = endValue.slice(start, sliceTail);
-	    return this._fallbackText;
-	  }
-	});
-
-	PooledClass.addPoolingTo(FallbackCompositionState);
-
-	module.exports = FallbackCompositionState;
-
-/***/ },
-/* 53 */
-/***/ function(module, exports) {
-
-	'use strict';
-	/* eslint-disable no-unused-vars */
-	var hasOwnProperty = Object.prototype.hasOwnProperty;
-	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
-
-	function toObject(val) {
-		if (val === null || val === undefined) {
-			throw new TypeError('Object.assign cannot be called with null or undefined');
-		}
-
-		return Object(val);
-	}
-
-	function shouldUseNative() {
-		try {
-			if (!Object.assign) {
-				return false;
-			}
-
-			// Detect buggy property enumeration order in older V8 versions.
-
-			// https://bugs.chromium.org/p/v8/issues/detail?id=4118
-			var test1 = new String('abc');  // eslint-disable-line
-			test1[5] = 'de';
-			if (Object.getOwnPropertyNames(test1)[0] === '5') {
-				return false;
-			}
-
-			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
-			var test2 = {};
-			for (var i = 0; i < 10; i++) {
-				test2['_' + String.fromCharCode(i)] = i;
-			}
-			var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
-				return test2[n];
-			});
-			if (order2.join('') !== '0123456789') {
-				return false;
-			}
-
-			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
-			var test3 = {};
-			'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
-				test3[letter] = letter;
-			});
-			if (Object.keys(Object.assign({}, test3)).join('') !==
-					'abcdefghijklmnopqrst') {
-				return false;
-			}
-
-			return true;
-		} catch (e) {
-			// We don't expect any of the above to throw, but better to be safe.
-			return false;
-		}
-	}
-
-	module.exports = shouldUseNative() ? Object.assign : function (target, source) {
-		var from;
-		var to = toObject(target);
-		var symbols;
-
-		for (var s = 1; s < arguments.length; s++) {
-			from = Object(arguments[s]);
-
-			for (var key in from) {
-				if (hasOwnProperty.call(from, key)) {
-					to[key] = from[key];
-				}
-			}
-
-			if (Object.getOwnPropertySymbols) {
-				symbols = Object.getOwnPropertySymbols(from);
-				for (var i = 0; i < symbols.length; i++) {
-					if (propIsEnumerable.call(from, symbols[i])) {
-						to[symbols[i]] = from[symbols[i]];
-					}
-				}
-			}
-		}
-
-		return to;
-	};
-
-
-/***/ },
-/* 54 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var invariant = __webpack_require__(37);
-
-	/**
-	 * 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 threeArgumentPooler = function (a1, a2, a3) {
-	  var Klass = this;
-	  if (Klass.instancePool.length) {
-	    var instance = Klass.instancePool.pop();
-	    Klass.call(instance, a1, a2, a3);
-	    return instance;
-	  } else {
-	    return new Klass(a1, a2, a3);
-	  }
-	};
-
-	var fourArgumentPooler = function (a1, a2, a3, a4) {
-	  var Klass = this;
-	  if (Klass.instancePool.length) {
-	    var instance = Klass.instancePool.pop();
-	    Klass.call(instance, a1, a2, a3, a4);
-	    return instance;
-	  } else {
-	    return new Klass(a1, a2, a3, a4);
-	  }
-	};
-
-	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;
-	  !(instance instanceof Klass) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Trying to release an instance into a pool of a different type.') : _prodInvariant('25') : void 0;
-	  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.
-	 *
-	 * @param {Function} CopyConstructor Constructor that can be used to reset.
-	 * @param {Function} pooler Customizable pooler.
-	 */
-	var addPoolingTo = function (CopyConstructor, pooler) {
-	  // Casting as any so that flow ignores the actual implementation and trusts
-	  // it to match the type we declared
-	  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,
-	  threeArgumentPooler: threeArgumentPooler,
-	  fourArgumentPooler: fourArgumentPooler,
-	  fiveArgumentPooler: fiveArgumentPooler
-	};
-
-	module.exports = PooledClass;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 55 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ExecutionEnvironment = __webpack_require__(51);
-
-	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) {
-	    // Prefer textContent to innerText because many browsers support both but
-	    // SVG <text> elements don't support innerText even when <div> does.
-	    contentKey = 'textContent' in document.documentElement ? 'textContent' : 'innerText';
-	  }
-	  return contentKey;
-	}
-
-	module.exports = getTextContentAccessor;
-
-/***/ },
-/* 56 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var SyntheticEvent = __webpack_require__(57);
-
-	/**
-	 * @interface Event
-	 * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
-	 */
-	var CompositionEventInterface = {
-	  data: null
-	};
-
-	/**
-	 * @param {object} dispatchConfig Configuration used to dispatch this event.
-	 * @param {string} dispatchMarker Marker identifying the event target.
-	 * @param {object} nativeEvent Native browser event.
-	 * @extends {SyntheticUIEvent}
-	 */
-	function SyntheticCompositionEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
-	  return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
-	}
-
-	SyntheticEvent.augmentClass(SyntheticCompositionEvent, CompositionEventInterface);
-
-	module.exports = SyntheticCompositionEvent;
-
-/***/ },
-/* 57 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _assign = __webpack_require__(53);
-
-	var PooledClass = __webpack_require__(54);
-
-	var emptyFunction = __webpack_require__(48);
-	var warning = __webpack_require__(47);
-
-	var didWarnForAddedNewProperty = false;
-	var isProxySupported = typeof Proxy === 'function';
-
-	var shouldBeReleasedProperties = ['dispatchConfig', '_targetInst', 'nativeEvent', 'isDefaultPrevented', 'isPropagationStopped', '_dispatchListeners', '_dispatchInstances'];
-
-	/**
-	 * @interface Event
-	 * @see http://www.w3.org/TR/DOM-Level-3-Events/
-	 */
-	var EventInterface = {
-	  type: null,
-	  target: null,
-	  // currentTarget is set when dispatching; no use in copying it here
-	  currentTarget: emptyFunction.thatReturnsNull,
-	  eventPhase: null,
-	  bubbles: null,
-	  cancelable: null,
-	  timeStamp: function (event) {
-	    return event.timeStamp || Date.now();
-	  },
-	  defaultPrevented: null,
-	  isTrusted: null
-	};
-
-	/**
-	 * Synthetic events are dispatched by event plugins, typically in response to a
-	 * top-level event delegation handler.
-	 *
-	 * These systems should generally use pooling to reduce the frequency of garbage
-	 * collection. The system should check `isPersistent` to determine whether the
-	 * event should be released into the pool after being dispatched. Users that
-	 * need a persisted event should invoke `persist`.
-	 *
-	 * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
-	 * normalizing browser quirks. Subclasses do not necessarily have to implement a
-	 * DOM interface; custom application-specific events can also subclass this.
-	 *
-	 * @param {object} dispatchConfig Configuration used to dispatch this event.
-	 * @param {*} targetInst Marker identifying the event target.
-	 * @param {object} nativeEvent Native browser event.
-	 * @param {DOMEventTarget} nativeEventTarget Target node.
-	 */
-	function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
-	  if (process.env.NODE_ENV !== 'production') {
-	    // these have a getter/setter for warnings
-	    delete this.nativeEvent;
-	    delete this.preventDefault;
-	    delete this.stopPropagation;
-	  }
-
-	  this.dispatchConfig = dispatchConfig;
-	  this._targetInst = targetInst;
-	  this.nativeEvent = nativeEvent;
-
-	  var Interface = this.constructor.Interface;
-	  for (var propName in Interface) {
-	    if (!Interface.hasOwnProperty(propName)) {
-	      continue;
-	    }
-	    if (process.env.NODE_ENV !== 'production') {
-	      delete this[propName]; // this has a getter/setter for warnings
-	    }
-	    var normalize = Interface[propName];
-	    if (normalize) {
-	      this[propName] = normalize(nativeEvent);
-	    } else {
-	      if (propName === 'target') {
-	        this.target = nativeEventTarget;
-	      } else {
-	        this[propName] = nativeEvent[propName];
-	      }
-	    }
-	  }
-
-	  var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
-	  if (defaultPrevented) {
-	    this.isDefaultPrevented = emptyFunction.thatReturnsTrue;
-	  } else {
-	    this.isDefaultPrevented = emptyFunction.thatReturnsFalse;
-	  }
-	  this.isPropagationStopped = emptyFunction.thatReturnsFalse;
-	  return this;
-	}
-
-	_assign(SyntheticEvent.prototype, {
-
-	  preventDefault: function () {
-	    this.defaultPrevented = true;
-	    var event = this.nativeEvent;
-	    if (!event) {
-	      return;
-	    }
-
-	    if (event.preventDefault) {
-	      event.preventDefault();
-	    } else if (typeof event.returnValue !== 'unknown') {
-	      // eslint-disable-line valid-typeof
-	      event.returnValue = false;
-	    }
-	    this.isDefaultPrevented = emptyFunction.thatReturnsTrue;
-	  },
-
-	  stopPropagation: function () {
-	    var event = this.nativeEvent;
-	    if (!event) {
-	      return;
-	    }
-
-	    if (event.stopPropagation) {
-	      event.stopPropagation();
-	    } else if (typeof event.cancelBubble !== 'unknown') {
-	      // eslint-disable-line valid-typeof
-	      // The ChangeEventPlugin registers a "propertychange" event for
-	      // IE. This event does not support bubbling or cancelling, and
-	      // any references to cancelBubble throw "Member not found".  A
-	      // typeof check of "unknown" circumvents this issue (and is also
-	      // IE specific).
-	      event.cancelBubble = true;
-	    }
-
-	    this.isPropagationStopped = emptyFunction.thatReturnsTrue;
-	  },
-
-	  /**
-	   * We release all dispatched `SyntheticEvent`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.
-	   */
-	  persist: function () {
-	    this.isPersistent = emptyFunction.thatReturnsTrue;
-	  },
-
-	  /**
-	   * Checks if this event should be released back into the pool.
-	   *
-	   * @return {boolean} True if this should not be released, false otherwise.
-	   */
-	  isPersistent: emptyFunction.thatReturnsFalse,
-
-	  /**
-	   * `PooledClass` looks for `destructor` on each instance it releases.
-	   */
-	  destructor: function () {
-	    var Interface = this.constructor.Interface;
-	    for (var propName in Interface) {
-	      if (process.env.NODE_ENV !== 'production') {
-	        Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
-	      } else {
-	        this[propName] = null;
-	      }
-	    }
-	    for (var i = 0; i < shouldBeReleasedProperties.length; i++) {
-	      this[shouldBeReleasedProperties[i]] = null;
-	    }
-	    if (process.env.NODE_ENV !== 'production') {
-	      Object.defineProperty(this, 'nativeEvent', getPooledWarningPropertyDefinition('nativeEvent', null));
-	      Object.defineProperty(this, 'preventDefault', getPooledWarningPropertyDefinition('preventDefault', emptyFunction));
-	      Object.defineProperty(this, 'stopPropagation', getPooledWarningPropertyDefinition('stopPropagation', emptyFunction));
-	    }
-	  }
-
-	});
-
-	SyntheticEvent.Interface = EventInterface;
-
-	if (process.env.NODE_ENV !== 'production') {
-	  if (isProxySupported) {
-	    /*eslint-disable no-func-assign */
-	    SyntheticEvent = new Proxy(SyntheticEvent, {
-	      construct: function (target, args) {
-	        return this.apply(target, Object.create(target.prototype), args);
-	      },
-	      apply: function (constructor, that, args) {
-	        return new Proxy(constructor.apply(that, args), {
-	          set: function (target, prop, value) {
-	            if (prop !== 'isPersistent' && !target.constructor.Interface.hasOwnProperty(prop) && shouldBeReleasedProperties.indexOf(prop) === -1) {
-	              process.env.NODE_ENV !== 'production' ? warning(didWarnForAddedNewProperty || target.isPersistent(), 'This synthetic event is reused for performance reasons. If you\'re ' + 'seeing this, you\'re adding a new property in the synthetic event object. ' + 'The property is never released. See ' + 'https://fb.me/react-event-pooling for more information.') : void 0;
-	              didWarnForAddedNewProperty = true;
-	            }
-	            target[prop] = value;
-	            return true;
-	          }
-	        });
-	      }
-	    });
-	    /*eslint-enable no-func-assign */
-	  }
-	}
-	/**
-	 * Helper to reduce boilerplate when creating subclasses.
-	 *
-	 * @param {function} Class
-	 * @param {?object} Interface
-	 */
-	SyntheticEvent.augmentClass = function (Class, Interface) {
-	  var Super = this;
-
-	  var E = function () {};
-	  E.prototype = Super.prototype;
-	  var prototype = new E();
-
-	  _assign(prototype, Class.prototype);
-	  Class.prototype = prototype;
-	  Class.prototype.constructor = Class;
-
-	  Class.Interface = _assign({}, Super.Interface, Interface);
-	  Class.augmentClass = Super.augmentClass;
-
-	  PooledClass.addPoolingTo(Class, PooledClass.fourArgumentPooler);
-	};
-
-	PooledClass.addPoolingTo(SyntheticEvent, PooledClass.fourArgumentPooler);
-
-	module.exports = SyntheticEvent;
-
-	/**
-	  * Helper to nullify syntheticEvent instance properties when destructing
-	  *
-	  * @param {object} SyntheticEvent
-	  * @param {String} propName
-	  * @return {object} defineProperty object
-	  */
-	function getPooledWarningPropertyDefinition(propName, getVal) {
-	  var isFunction = typeof getVal === 'function';
-	  return {
-	    configurable: true,
-	    set: set,
-	    get: get
-	  };
-
-	  function set(val) {
-	    var action = isFunction ? 'setting the method' : 'setting the property';
-	    warn(action, 'This is effectively a no-op');
-	    return val;
-	  }
-
-	  function get() {
-	    var action = isFunction ? 'accessing the method' : 'accessing the property';
-	    var result = isFunction ? 'This is a no-op function' : 'This is set to null';
-	    warn(action, result);
-	    return getVal;
-	  }
-
-	  function warn(action, result) {
-	    var warningCondition = false;
-	    process.env.NODE_ENV !== 'production' ? warning(warningCondition, 'This synthetic event is reused for performance reasons. If you\'re seeing this, ' + 'you\'re %s `%s` on a released/nullified synthetic event. %s. ' + 'If you must keep the original synthetic event around, use event.persist(). ' + 'See https://fb.me/react-event-pooling for more information.', action, propName, result) : void 0;
-	  }
-	}
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 58 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var SyntheticEvent = __webpack_require__(57);
-
-	/**
-	 * @interface Event
-	 * @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105
-	 *      /#events-inputevents
-	 */
-	var InputEventInterface = {
-	  data: null
-	};
-
-	/**
-	 * @param {object} dispatchConfig Configuration used to dispatch this event.
-	 * @param {string} dispatchMarker Marker identifying the event target.
-	 * @param {object} nativeEvent Native browser event.
-	 * @extends {SyntheticUIEvent}
-	 */
-	function SyntheticInputEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
-	  return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
-	}
-
-	SyntheticEvent.augmentClass(SyntheticInputEvent, InputEventInterface);
-
-	module.exports = SyntheticInputEvent;
-
-/***/ },
-/* 59 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var EventPluginHub = __webpack_require__(43);
-	var EventPropagators = __webpack_require__(42);
-	var ExecutionEnvironment = __webpack_require__(51);
-	var ReactDOMComponentTree = __webpack_require__(34);
-	var ReactUpdates = __webpack_require__(60);
-	var SyntheticEvent = __webpack_require__(57);
-
-	var getEventTarget = __webpack_require__(73);
-	var isEventSupported = __webpack_require__(74);
-	var isTextInputElement = __webpack_require__(75);
-
-	var eventTypes = {
-	  change: {
-	    phasedRegistrationNames: {
-	      bubbled: 'onChange',
-	      captured: 'onChangeCapture'
-	    },
-	    dependencies: ['topBlur', 'topChange', 'topClick', 'topFocus', 'topInput', 'topKeyDown', 'topKeyUp', 'topSelectionChange']
-	  }
-	};
-
-	/**
-	 * For IE shims
-	 */
-	var activeElement = null;
-	var activeElementInst = null;
-	var activeElementValue = null;
-	var activeElementValueProp = null;
-
-	/**
-	 * SECTION: handle `change` event
-	 */
-	function shouldUseChangeEvent(elem) {
-	  var nodeName = elem.nodeName && elem.nodeName.toLowerCase();
-	  return nodeName === 'select' || nodeName === 'input' && elem.type === 'file';
-	}
-
-	var doesChangeEventBubble = false;
-	if (ExecutionEnvironment.canUseDOM) {
-	  // See `handleChange` comment below
-	  doesChangeEventBubble = isEventSupported('change') && (!document.documentMode || document.documentMode > 8);
-	}
-
-	function manualDispatchChangeEvent(nativeEvent) {
-	  var event = SyntheticEvent.getPooled(eventTypes.change, activeElementInst, nativeEvent, getEventTarget(nativeEvent));
-	  EventPropagators.accumulateTwoPhaseDispatches(event);
-
-	  // If change and propertychange bubbled, we'd just bind to it like all the
-	  // other events and have it go through ReactBrowserEventEmitter. Since it
-	  // doesn't, we manually listen for the events and so we have to enqueue and
-	  // process the abstract event manually.
-	  //
-	  // Batching is necessary here in order to ensure that all event handlers run
-	  // before the next rerender (including event handlers attached to ancestor
-	  // elements instead of directly on the input). Without this, controlled
-	  // components don't work properly in conjunction with event bubbling because
-	  // the component is rerendered and the value reverted before all the event
-	  // handlers can run. See https://github.com/facebook/react/issues/708.
-	  ReactUpdates.batchedUpdates(runEventInBatch, event);
-	}
-
-	function runEventInBatch(event) {
-	  EventPluginHub.enqueueEvents(event);
-	  EventPluginHub.processEventQueue(false);
-	}
-
-	function startWatchingForChangeEventIE8(target, targetInst) {
-	  activeElement = target;
-	  activeElementInst = targetInst;
-	  activeElement.attachEvent('onchange', manualDispatchChangeEvent);
-	}
-
-	function stopWatchingForChangeEventIE8() {
-	  if (!activeElement) {
-	    return;
-	  }
-	  activeElement.detachEvent('onchange', manualDispatchChangeEvent);
-	  activeElement = null;
-	  activeElementInst = null;
-	}
-
-	function getTargetInstForChangeEvent(topLevelType, targetInst) {
-	  if (topLevelType === 'topChange') {
-	    return targetInst;
-	  }
-	}
-	function handleEventsForChangeEventIE8(topLevelType, target, targetInst) {
-	  if (topLevelType === 'topFocus') {
-	    // stopWatching() should be a noop here but we call it just in case we
-	    // missed a blur event somehow.
-	    stopWatchingForChangeEventIE8();
-	    startWatchingForChangeEventIE8(target, targetInst);
-	  } else if (topLevelType === 'topBlur') {
-	    stopWatchingForChangeEventIE8();
-	  }
-	}
-
-	/**
-	 * 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.
-	  // IE10+ fire input events to often, such when a placeholder
-	  // changes or when an input with a placeholder is focused.
-	  isInputEventSupported = isEventSupported('input') && (!document.documentMode || document.documentMode > 11);
-	}
-
-	/**
-	 * (For IE <=11) Replacement getter/setter for the `value` property that gets
-	 * set on the active element.
-	 */
-	var newValueProp = {
-	  get: function () {
-	    return activeElementValueProp.get.call(this);
-	  },
-	  set: function (val) {
-	    // Cast to a string so we can do equality checks.
-	    activeElementValue = '' + val;
-	    activeElementValueProp.set.call(this, val);
-	  }
-	};
-
-	/**
-	 * (For IE <=11) Starts tracking propertychange events on the passed-in element
-	 * and override the value property so that we can distinguish user events from
-	 * value changes in JS.
-	 */
-	function startWatchingForValueChange(target, targetInst) {
-	  activeElement = target;
-	  activeElementInst = targetInst;
-	  activeElementValue = target.value;
-	  activeElementValueProp = Object.getOwnPropertyDescriptor(target.constructor.prototype, 'value');
-
-	  // Not guarded in a canDefineProperty check: IE8 supports defineProperty only
-	  // on DOM elements
-	  Object.defineProperty(activeElement, 'value', newValueProp);
-	  if (activeElement.attachEvent) {
-	    activeElement.attachEvent('onpropertychange', handlePropertyChange);
-	  } else {
-	    activeElement.addEventListener('propertychange', handlePropertyChange, false);
-	  }
-	}
-
-	/**
-	 * (For IE <=11) Removes the event listeners from the currently-tracked element,
-	 * if any exists.
-	 */
-	function stopWatchingForValueChange() {
-	  if (!activeElement) {
-	    return;
-	  }
-
-	  // delete restores the original property definition
-	  delete activeElement.value;
-
-	  if (activeElement.detachEvent) {
-	    activeElement.detachEvent('onpropertychange', handlePropertyChange);
-	  } else {
-	    activeElement.removeEventListener('propertychange', handlePropertyChange, false);
-	  }
-
-	  activeElement = null;
-	  activeElementInst = null;
-	  activeElementValue = null;
-	  activeElementValueProp = null;
-	}
-
-	/**
-	 * (For IE <=11) Handles a propertychange event, sending a `change` event if
-	 * the value of the active element has changed.
-	 */
-	function handlePropertyChange(nativeEvent) {
-	  if (nativeEvent.propertyName !== 'value') {
-	    return;
-	  }
-	  var value = nativeEvent.srcElement.value;
-	  if (value === activeElementValue) {
-	    return;
-	  }
-	  activeElementValue = value;
-
-	  manualDispatchChangeEvent(nativeEvent);
-	}
-
-	/**
-	 * If a `change` event should be fired, returns the target's ID.
-	 */
-	function getTargetInstForInputEvent(topLevelType, targetInst) {
-	  if (topLevelType === '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 targetInst;
-	  }
-	}
-
-	function handleEventsForInputEventIE(topLevelType, target, targetInst) {
-	  if (topLevelType === '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-11, 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(target, targetInst);
-	  } else if (topLevelType === 'topBlur') {
-	    stopWatchingForValueChange();
-	  }
-	}
-
-	// For IE8 and IE9.
-	function getTargetInstForInputEventIE(topLevelType, targetInst) {
-	  if (topLevelType === 'topSelectionChange' || topLevelType === 'topKeyUp' || topLevelType === '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 activeElementInst;
-	    }
-	  }
-	}
-
-	/**
-	 * SECTION: handle `click` event
-	 */
-	function shouldUseClickEvent(elem) {
-	  // Use the `click` event to detect changes to checkbox and radio inputs.
-	  // This approach works across all browsers, whereas `change` does not fire
-	  // until `blur` in IE8.
-	  return elem.nodeName && elem.nodeName.toLowerCase() === 'input' && (elem.type === 'checkbox' || elem.type === 'radio');
-	}
-
-	function getTargetInstForClickEvent(topLevelType, targetInst) {
-	  if (topLevelType === 'topClick') {
-	    return targetInst;
-	  }
-	}
-
-	/**
-	 * This plugin creates an `onChange` event that normalizes change events
-	 * across form elements. This event fires at a time when it's possible to
-	 * change the element's value without seeing a flicker.
-	 *
-	 * Supported elements are:
-	 * - input (see `isTextInputElement`)
-	 * - textarea
-	 * - select
-	 */
-	var ChangeEventPlugin = {
-
-	  eventTypes: eventTypes,
-
-	  extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-	    var targetNode = targetInst ? ReactDOMComponentTree.getNodeFromInstance(targetInst) : window;
-
-	    var getTargetInstFunc, handleEventFunc;
-	    if (shouldUseChangeEvent(targetNode)) {
-	      if (doesChangeEventBubble) {
-	        getTargetInstFunc = getTargetInstForChangeEvent;
-	      } else {
-	        handleEventFunc = handleEventsForChangeEventIE8;
-	      }
-	    } else if (isTextInputElement(targetNode)) {
-	      if (isInputEventSupported) {
-	        getTargetInstFunc = getTargetInstForInputEvent;
-	      } else {
-	        getTargetInstFunc = getTargetInstForInputEventIE;
-	        handleEventFunc = handleEventsForInputEventIE;
-	      }
-	    } else if (shouldUseClickEvent(targetNode)) {
-	      getTargetInstFunc = getTargetInstForClickEvent;
-	    }
-
-	    if (getTargetInstFunc) {
-	      var inst = getTargetInstFunc(topLevelType, targetInst);
-	      if (inst) {
-	        var event = SyntheticEvent.getPooled(eventTypes.change, inst, nativeEvent, nativeEventTarget);
-	        event.type = 'change';
-	        EventPropagators.accumulateTwoPhaseDispatches(event);
-	        return event;
-	      }
-	    }
-
-	    if (handleEventFunc) {
-	      handleEventFunc(topLevelType, targetNode, targetInst);
-	    }
-	  }
-
-	};
-
-	module.exports = ChangeEventPlugin;
-
-/***/ },
-/* 60 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35),
-	    _assign = __webpack_require__(53);
-
-	var CallbackQueue = __webpack_require__(61);
-	var PooledClass = __webpack_require__(54);
-	var ReactFeatureFlags = __webpack_require__(62);
-	var ReactReconciler = __webpack_require__(63);
-	var Transaction = __webpack_require__(72);
-
-	var invariant = __webpack_require__(37);
-
-	var dirtyComponents = [];
-	var updateBatchNumber = 0;
-	var asapCallbackQueue = CallbackQueue.getPooled();
-	var asapEnqueued = false;
-
-	var batchingStrategy = null;
-
-	function ensureInjected() {
-	  !(ReactUpdates.ReactReconcileTransaction && batchingStrategy) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must inject a reconcile transaction class and batching strategy') : _prodInvariant('123') : void 0;
-	}
-
-	var NESTED_UPDATES = {
-	  initialize: function () {
-	    this.dirtyComponentsLength = dirtyComponents.length;
-	  },
-	  close: function () {
-	    if (this.dirtyComponentsLength !== dirtyComponents.length) {
-	      // Additional updates were enqueued by componentDidUpdate handlers or
-	      // similar; before our own UPDATE_QUEUEING wrapper closes, we want to run
-	      // these new updates so that if A's componentDidUpdate calls setState on
-	      // B, B will update before the callback A's updater provided when calling
-	      // setState.
-	      dirtyComponents.splice(0, this.dirtyComponentsLength);
-	      flushBatchedUpdates();
-	    } else {
-	      dirtyComponents.length = 0;
-	    }
-	  }
-	};
-
-	var UPDATE_QUEUEING = {
-	  initialize: function () {
-	    this.callbackQueue.reset();
-	  },
-	  close: function () {
-	    this.callbackQueue.notifyAll();
-	  }
-	};
-
-	var TRANSACTION_WRAPPERS = [NESTED_UPDATES, UPDATE_QUEUEING];
-
-	function ReactUpdatesFlushTransaction() {
-	  this.reinitializeTransaction();
-	  this.dirtyComponentsLength = null;
-	  this.callbackQueue = CallbackQueue.getPooled();
-	  this.reconcileTransaction = ReactUpdates.ReactReconcileTransaction.getPooled(
-	  /* useCreateElement */true);
-	}
-
-	_assign(ReactUpdatesFlushTransaction.prototype, Transaction, {
-	  getTransactionWrappers: function () {
-	    return TRANSACTION_WRAPPERS;
-	  },
-
-	  destructor: function () {
-	    this.dirtyComponentsLength = null;
-	    CallbackQueue.release(this.callbackQueue);
-	    this.callbackQueue = null;
-	    ReactUpdates.ReactReconcileTransaction.release(this.reconcileTransaction);
-	    this.reconcileTransaction = null;
-	  },
-
-	  perform: function (method, scope, a) {
-	    // Essentially calls `this.reconcileTransaction.perform(method, scope, a)`
-	    // with this transaction's wrappers around it.
-	    return Transaction.perform.call(this, this.reconcileTransaction.perform, this.reconcileTransaction, method, scope, a);
-	  }
-	});
-
-	PooledClass.addPoolingTo(ReactUpdatesFlushTransaction);
-
-	function batchedUpdates(callback, a, b, c, d, e) {
-	  ensureInjected();
-	  return batchingStrategy.batchedUpdates(callback, a, b, c, d, e);
-	}
-
-	/**
-	 * Array comparator for ReactComponents by mount ordering.
-	 *
-	 * @param {ReactComponent} c1 first component you're comparing
-	 * @param {ReactComponent} c2 second component you're comparing
-	 * @return {number} Return value usable by Array.prototype.sort().
-	 */
-	function mountOrderComparator(c1, c2) {
-	  return c1._mountOrder - c2._mountOrder;
-	}
-
-	function runBatchedUpdates(transaction) {
-	  var len = transaction.dirtyComponentsLength;
-	  !(len === dirtyComponents.length) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected flush transaction\'s stored dirty-components length (%s) to match dirty-components array length (%s).', len, dirtyComponents.length) : _prodInvariant('124', len, dirtyComponents.length) : void 0;
-
-	  // Since reconciling a component higher in the owner hierarchy usually (not
-	  // always -- see shouldComponentUpdate()) will reconcile children, reconcile
-	  // them before their children by sorting the array.
-	  dirtyComponents.sort(mountOrderComparator);
-
-	  // Any updates enqueued while reconciling must be performed after this entire
-	  // batch. Otherwise, if dirtyComponents is [A, B] where A has children B and
-	  // C, B could update twice in a single batch if C's render enqueues an update
-	  // to B (since B would have already updated, we should skip it, and the only
-	  // way we can know to do so is by checking the batch counter).
-	  updateBatchNumber++;
-
-	  for (var i = 0; i < len; i++) {
-	    // If a component is unmounted before pending changes apply, it will still
-	    // be here, but we assume that it has cleared its _pendingCallbacks and
-	    // that performUpdateIfNecessary is a noop.
-	    var component = dirtyComponents[i];
-
-	    // If performUpdateIfNecessary happens to enqueue any new updates, we
-	    // shouldn't execute the callbacks until the next render happens, so
-	    // stash the callbacks first
-	    var callbacks = component._pendingCallbacks;
-	    component._pendingCallbacks = null;
-
-	    var markerName;
-	    if (ReactFeatureFlags.logTopLevelRenders) {
-	      var namedComponent = component;
-	      // Duck type TopLevelWrapper. This is probably always true.
-	      if (component._currentElement.type.isReactTopLevelWrapper) {
-	        namedComponent = component._renderedComponent;
-	      }
-	      markerName = 'React update: ' + namedComponent.getName();
-	      console.time(markerName);
-	    }
-
-	    ReactReconciler.performUpdateIfNecessary(component, transaction.reconcileTransaction, updateBatchNumber);
-
-	    if (markerName) {
-	      console.timeEnd(markerName);
-	    }
-
-	    if (callbacks) {
-	      for (var j = 0; j < callbacks.length; j++) {
-	        transaction.callbackQueue.enqueue(callbacks[j], component.getPublicInstance());
-	      }
-	    }
-	  }
-	}
-
-	var flushBatchedUpdates = function () {
-	  // ReactUpdatesFlushTransaction's wrappers will clear the dirtyComponents
-	  // array and perform any updates enqueued by mount-ready handlers (i.e.,
-	  // componentDidUpdate) but we need to check here too in order to catch
-	  // updates enqueued by setState callbacks and asap calls.
-	  while (dirtyComponents.length || asapEnqueued) {
-	    if (dirtyComponents.length) {
-	      var transaction = ReactUpdatesFlushTransaction.getPooled();
-	      transaction.perform(runBatchedUpdates, null, transaction);
-	      ReactUpdatesFlushTransaction.release(transaction);
-	    }
-
-	    if (asapEnqueued) {
-	      asapEnqueued = false;
-	      var queue = asapCallbackQueue;
-	      asapCallbackQueue = CallbackQueue.getPooled();
-	      queue.notifyAll();
-	      CallbackQueue.release(queue);
-	    }
-	  }
-	};
-
-	/**
-	 * Mark a component as needing a rerender, adding an optional callback to a
-	 * list of functions which will be executed once the rerender occurs.
-	 */
-	function enqueueUpdate(component) {
-	  ensureInjected();
-
-	  // Various parts of our code (such as ReactCompositeComponent's
-	  // _renderValidatedComponent) assume that calls to render aren't nested;
-	  // verify that that's the case. (This is called by each top-level update
-	  // function, like setState, forceUpdate, etc.; creation and
-	  // destruction of top-level components is guarded in ReactMount.)
-
-	  if (!batchingStrategy.isBatchingUpdates) {
-	    batchingStrategy.batchedUpdates(enqueueUpdate, component);
-	    return;
-	  }
-
-	  dirtyComponents.push(component);
-	  if (component._updateBatchNumber == null) {
-	    component._updateBatchNumber = updateBatchNumber + 1;
-	  }
-	}
-
-	/**
-	 * Enqueue a callback to be run at the end of the current batching cycle. Throws
-	 * if no updates are currently being performed.
-	 */
-	function asap(callback, context) {
-	  !batchingStrategy.isBatchingUpdates ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates.asap: Can\'t enqueue an asap callback in a context whereupdates are not being batched.') : _prodInvariant('125') : void 0;
-	  asapCallbackQueue.enqueue(callback, context);
-	  asapEnqueued = true;
-	}
-
-	var ReactUpdatesInjection = {
-	  injectReconcileTransaction: function (ReconcileTransaction) {
-	    !ReconcileTransaction ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide a reconcile transaction class') : _prodInvariant('126') : void 0;
-	    ReactUpdates.ReactReconcileTransaction = ReconcileTransaction;
-	  },
-
-	  injectBatchingStrategy: function (_batchingStrategy) {
-	    !_batchingStrategy ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide a batching strategy') : _prodInvariant('127') : void 0;
-	    !(typeof _batchingStrategy.batchedUpdates === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide a batchedUpdates() function') : _prodInvariant('128') : void 0;
-	    !(typeof _batchingStrategy.isBatchingUpdates === 'boolean') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide an isBatchingUpdates boolean attribute') : _prodInvariant('129') : void 0;
-	    batchingStrategy = _batchingStrategy;
-	  }
-	};
-
-	var ReactUpdates = {
-	  /**
-	   * React references `ReactReconcileTransaction` using this property in order
-	   * to allow dependency injection.
-	   *
-	   * @internal
-	   */
-	  ReactReconcileTransaction: null,
-
-	  batchedUpdates: batchedUpdates,
-	  enqueueUpdate: enqueueUpdate,
-	  flushBatchedUpdates: flushBatchedUpdates,
-	  injection: ReactUpdatesInjection,
-	  asap: asap
-	};
-
-	module.exports = ReactUpdates;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 61 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-	var PooledClass = __webpack_require__(54);
-
-	var invariant = __webpack_require__(37);
-
-	/**
-	 * A specialized pseudo-event module to help keep track of components waiting to
-	 * be notified when their DOM representations are available for use.
-	 *
-	 * This implements `PooledClass`, so you should never need to instantiate this.
-	 * Instead, use `CallbackQueue.getPooled()`.
-	 *
-	 * @class ReactMountReady
-	 * @implements PooledClass
-	 * @internal
-	 */
-
-	var CallbackQueue = function () {
-	  function CallbackQueue(arg) {
-	    _classCallCheck(this, CallbackQueue);
-
-	    this._callbacks = null;
-	    this._contexts = null;
-	    this._arg = arg;
-	  }
-
-	  /**
-	   * Enqueues a callback to be invoked when `notifyAll` is invoked.
-	   *
-	   * @param {function} callback Invoked when `notifyAll` is invoked.
-	   * @param {?object} context Context to call `callback` with.
-	   * @internal
-	   */
-
-
-	  CallbackQueue.prototype.enqueue = function enqueue(callback, context) {
-	    this._callbacks = this._callbacks || [];
-	    this._callbacks.push(callback);
-	    this._contexts = this._contexts || [];
-	    this._contexts.push(context);
-	  };
-
-	  /**
-	   * Invokes all enqueued callbacks and clears the queue. This is invoked after
-	   * the DOM representation of a component has been created or updated.
-	   *
-	   * @internal
-	   */
-
-
-	  CallbackQueue.prototype.notifyAll = function notifyAll() {
-	    var callbacks = this._callbacks;
-	    var contexts = this._contexts;
-	    var arg = this._arg;
-	    if (callbacks && contexts) {
-	      !(callbacks.length === contexts.length) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Mismatched list of contexts in callback queue') : _prodInvariant('24') : void 0;
-	      this._callbacks = null;
-	      this._contexts = null;
-	      for (var i = 0; i < callbacks.length; i++) {
-	        callbacks[i].call(contexts[i], arg);
-	      }
-	      callbacks.length = 0;
-	      contexts.length = 0;
-	    }
-	  };
-
-	  CallbackQueue.prototype.checkpoint = function checkpoint() {
-	    return this._callbacks ? this._callbacks.length : 0;
-	  };
-
-	  CallbackQueue.prototype.rollback = function rollback(len) {
-	    if (this._callbacks && this._contexts) {
-	      this._callbacks.length = len;
-	      this._contexts.length = len;
-	    }
-	  };
-
-	  /**
-	   * Resets the internal queue.
-	   *
-	   * @internal
-	   */
-
-
-	  CallbackQueue.prototype.reset = function reset() {
-	    this._callbacks = null;
-	    this._contexts = null;
-	  };
-
-	  /**
-	   * `PooledClass` looks for this.
-	   */
-
-
-	  CallbackQueue.prototype.destructor = function destructor() {
-	    this.reset();
-	  };
-
-	  return CallbackQueue;
-	}();
-
-	module.exports = PooledClass.addPoolingTo(CallbackQueue);
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 62 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var ReactFeatureFlags = {
-	  // When true, call console.time() before and .timeEnd() after each top-level
-	  // render (both initial renders and updates). Useful when looking at prod-mode
-	  // timeline profiles in Chrome, for example.
-	  logTopLevelRenders: false
-	};
-
-	module.exports = ReactFeatureFlags;
-
-/***/ },
-/* 63 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ReactRef = __webpack_require__(64);
-	var ReactInstrumentation = __webpack_require__(66);
-
-	var warning = __webpack_require__(47);
-
-	/**
-	 * Helper to call ReactRef.attachRefs with this composite component, split out
-	 * to avoid allocations in the transaction mount-ready queue.
-	 */
-	function attachRefs() {
-	  ReactRef.attachRefs(this, this._currentElement);
-	}
-
-	var ReactReconciler = {
-
-	  /**
-	   * Initializes the component, renders markup, and registers event listeners.
-	   *
-	   * @param {ReactComponent} internalInstance
-	   * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
-	   * @param {?object} the containing host component instance
-	   * @param {?object} info about the host container
-	   * @return {?string} Rendered markup to be inserted into the DOM.
-	   * @final
-	   * @internal
-	   */
-	  mountComponent: function (internalInstance, transaction, hostParent, hostContainerInfo, context, parentDebugID // 0 in production and for roots
-	  ) {
-	    if (process.env.NODE_ENV !== 'production') {
-	      if (internalInstance._debugID !== 0) {
-	        ReactInstrumentation.debugTool.onBeforeMountComponent(internalInstance._debugID, internalInstance._currentElement, parentDebugID);
-	      }
-	    }
-	    var markup = internalInstance.mountComponent(transaction, hostParent, hostContainerInfo, context, parentDebugID);
-	    if (internalInstance._currentElement && internalInstance._currentElement.ref != null) {
-	      transaction.getReactMountReady().enqueue(attachRefs, internalInstance);
-	    }
-	    if (process.env.NODE_ENV !== 'production') {
-	      if (internalInstance._debugID !== 0) {
-	        ReactInstrumentation.debugTool.onMountComponent(internalInstance._debugID);
-	      }
-	    }
-	    return markup;
-	  },
-
-	  /**
-	   * Returns a value that can be passed to
-	   * ReactComponentEnvironment.replaceNodeWithMarkup.
-	   */
-	  getHostNode: function (internalInstance) {
-	    return internalInstance.getHostNode();
-	  },
-
-	  /**
-	   * Releases any resources allocated by `mountComponent`.
-	   *
-	   * @final
-	   * @internal
-	   */
-	  unmountComponent: function (internalInstance, safely) {
-	    if (process.env.NODE_ENV !== 'production') {
-	      if (internalInstance._debugID !== 0) {
-	        ReactInstrumentation.debugTool.onBeforeUnmountComponent(internalInstance._debugID);
-	      }
-	    }
-	    ReactRef.detachRefs(internalInstance, internalInstance._currentElement);
-	    internalInstance.unmountComponent(safely);
-	    if (process.env.NODE_ENV !== 'production') {
-	      if (internalInstance._debugID !== 0) {
-	        ReactInstrumentation.debugTool.onUnmountComponent(internalInstance._debugID);
-	      }
-	    }
-	  },
-
-	  /**
-	   * Update a component using a new element.
-	   *
-	   * @param {ReactComponent} internalInstance
-	   * @param {ReactElement} nextElement
-	   * @param {ReactReconcileTransaction} transaction
-	   * @param {object} context
-	   * @internal
-	   */
-	  receiveComponent: function (internalInstance, nextElement, transaction, context) {
-	    var prevElement = internalInstance._currentElement;
-
-	    if (nextElement === prevElement && context === internalInstance._context) {
-	      // Since elements are immutable after the owner is rendered,
-	      // we can do a cheap identity compare here to determine if this is a
-	      // superfluous reconcile. It's possible for state to be mutable but such
-	      // change should trigger an update of the owner which would recreate
-	      // the element. We explicitly check for the existence of an owner since
-	      // it's possible for an element created outside a composite to be
-	      // deeply mutated and reused.
-
-	      // TODO: Bailing out early is just a perf optimization right?
-	      // TODO: Removing the return statement should affect correctness?
-	      return;
-	    }
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      if (internalInstance._debugID !== 0) {
-	        ReactInstrumentation.debugTool.onBeforeUpdateComponent(internalInstance._debugID, nextElement);
-	      }
-	    }
-
-	    var refsChanged = ReactRef.shouldUpdateRefs(prevElement, nextElement);
-
-	    if (refsChanged) {
-	      ReactRef.detachRefs(internalInstance, prevElement);
-	    }
-
-	    internalInstance.receiveComponent(nextElement, transaction, context);
-
-	    if (refsChanged && internalInstance._currentElement && internalInstance._currentElement.ref != null) {
-	      transaction.getReactMountReady().enqueue(attachRefs, internalInstance);
-	    }
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      if (internalInstance._debugID !== 0) {
-	        ReactInstrumentation.debugTool.onUpdateComponent(internalInstance._debugID);
-	      }
-	    }
-	  },
-
-	  /**
-	   * Flush any dirty changes in a component.
-	   *
-	   * @param {ReactComponent} internalInstance
-	   * @param {ReactReconcileTransaction} transaction
-	   * @internal
-	   */
-	  performUpdateIfNecessary: function (internalInstance, transaction, updateBatchNumber) {
-	    if (internalInstance._updateBatchNumber !== updateBatchNumber) {
-	      // The component's enqueued batch number should always be the current
-	      // batch or the following one.
-	      process.env.NODE_ENV !== 'production' ? warning(internalInstance._updateBatchNumber == null || internalInstance._updateBatchNumber === updateBatchNumber + 1, 'performUpdateIfNecessary: Unexpected batch number (current %s, ' + 'pending %s)', updateBatchNumber, internalInstance._updateBatchNumber) : void 0;
-	      return;
-	    }
-	    if (process.env.NODE_ENV !== 'production') {
-	      if (internalInstance._debugID !== 0) {
-	        ReactInstrumentation.debugTool.onBeforeUpdateComponent(internalInstance._debugID, internalInstance._currentElement);
-	      }
-	    }
-	    internalInstance.performUpdateIfNecessary(transaction);
-	    if (process.env.NODE_ENV !== 'production') {
-	      if (internalInstance._debugID !== 0) {
-	        ReactInstrumentation.debugTool.onUpdateComponent(internalInstance._debugID);
-	      }
-	    }
-	  }
-
-	};
-
-	module.exports = ReactReconciler;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 64 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var ReactOwner = __webpack_require__(65);
-
-	var ReactRef = {};
-
-	function attachRef(ref, component, owner) {
-	  if (typeof ref === 'function') {
-	    ref(component.getPublicInstance());
-	  } else {
-	    // Legacy ref
-	    ReactOwner.addComponentAsRefTo(component, ref, owner);
-	  }
-	}
-
-	function detachRef(ref, component, owner) {
-	  if (typeof ref === 'function') {
-	    ref(null);
-	  } else {
-	    // Legacy ref
-	    ReactOwner.removeComponentAsRefFrom(component, ref, owner);
-	  }
-	}
-
-	ReactRef.attachRefs = function (instance, element) {
-	  if (element === null || typeof element !== 'object') {
-	    return;
-	  }
-	  var ref = element.ref;
-	  if (ref != null) {
-	    attachRef(ref, instance, element._owner);
-	  }
-	};
-
-	ReactRef.shouldUpdateRefs = function (prevElement, nextElement) {
-	  // 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`. We use the element instead
-	  // of the public this.props because the post processing cannot determine
-	  // a ref. The ref conceptually lives on the element.
-
-	  // TODO: Should this even be possible? The owner cannot change because
-	  // it's forbidden by shouldUpdateReactComponent. The ref can change
-	  // if you swap the keys of but not the refs. Reconsider where this check
-	  // is made. It probably belongs where the key checking and
-	  // instantiateReactComponent is done.
-
-	  var prevRef = null;
-	  var prevOwner = null;
-	  if (prevElement !== null && typeof prevElement === 'object') {
-	    prevRef = prevElement.ref;
-	    prevOwner = prevElement._owner;
-	  }
-
-	  var nextRef = null;
-	  var nextOwner = null;
-	  if (nextElement !== null && typeof nextElement === 'object') {
-	    nextRef = nextElement.ref;
-	    nextOwner = nextElement._owner;
-	  }
-
-	  return prevRef !== nextRef ||
-	  // If owner changes but we have an unchanged function ref, don't update refs
-	  typeof nextRef === 'string' && nextOwner !== prevOwner;
-	};
-
-	ReactRef.detachRefs = function (instance, element) {
-	  if (element === null || typeof element !== 'object') {
-	    return;
-	  }
-	  var ref = element.ref;
-	  if (ref != null) {
-	    detachRef(ref, instance, element._owner);
-	  }
-	};
-
-	module.exports = ReactRef;
-
-/***/ },
-/* 65 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var invariant = __webpack_require__(37);
-
-	/**
-	 * @param {?object} object
-	 * @return {boolean} True if `object` is a valid owner.
-	 * @final
-	 */
-	function isValidOwner(object) {
-	  return !!(object && typeof object.attachRef === 'function' && typeof object.detachRef === 'function');
-	}
-
-	/**
-	 * 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: 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 = {
-	  /**
-	   * 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) {
-	    !isValidOwner(owner) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'addComponentAsRefTo(...): Only a ReactOwner can have refs. You might be adding a ref to a component that was not created inside a component\'s `render` method, or you have multiple copies of React loaded (details: https://fb.me/react-refs-must-have-owner).') : _prodInvariant('119') : void 0;
-	    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) {
-	    !isValidOwner(owner) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'removeComponentAsRefFrom(...): Only a ReactOwner can have refs. You might be removing a ref to a component that was not created inside a component\'s `render` method, or you have multiple copies of React loaded (details: https://fb.me/react-refs-must-have-owner).') : _prodInvariant('120') : void 0;
-	    var ownerPublicInstance = owner.getPublicInstance();
-	    // Check that `component`'s owner is still alive and that `component` is still the current ref
-	    // because we do not want to detach the ref if another component stole it.
-	    if (ownerPublicInstance && ownerPublicInstance.refs[ref] === component.getPublicInstance()) {
-	      owner.detachRef(ref);
-	    }
-	  }
-
-	};
-
-	module.exports = ReactOwner;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 66 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2016-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	// Trust the developer to only use ReactInstrumentation with a __DEV__ check
-
-	var debugTool = null;
-
-	if (process.env.NODE_ENV !== 'production') {
-	  var ReactDebugTool = __webpack_require__(67);
-	  debugTool = ReactDebugTool;
-	}
-
-	module.exports = { debugTool: debugTool };
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 67 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2016-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var ReactInvalidSetStateWarningHook = __webpack_require__(68);
-	var ReactHostOperationHistoryHook = __webpack_require__(69);
-	var ReactComponentTreeHook = __webpack_require__(26);
-	var ExecutionEnvironment = __webpack_require__(51);
-
-	var performanceNow = __webpack_require__(70);
-	var warning = __webpack_require__(47);
-
-	var hooks = [];
-	var didHookThrowForEvent = {};
-
-	function callHook(event, fn, context, arg1, arg2, arg3, arg4, arg5) {
-	  try {
-	    fn.call(context, arg1, arg2, arg3, arg4, arg5);
-	  } catch (e) {
-	    process.env.NODE_ENV !== 'production' ? warning(didHookThrowForEvent[event], 'Exception thrown by hook while handling %s: %s', event, e + '\n' + e.stack) : void 0;
-	    didHookThrowForEvent[event] = true;
-	  }
-	}
-
-	function emitEvent(event, arg1, arg2, arg3, arg4, arg5) {
-	  for (var i = 0; i < hooks.length; i++) {
-	    var hook = hooks[i];
-	    var fn = hook[event];
-	    if (fn) {
-	      callHook(event, fn, hook, arg1, arg2, arg3, arg4, arg5);
-	    }
-	  }
-	}
-
-	var isProfiling = false;
-	var flushHistory = [];
-	var lifeCycleTimerStack = [];
-	var currentFlushNesting = 0;
-	var currentFlushMeasurements = [];
-	var currentFlushStartTime = 0;
-	var currentTimerDebugID = null;
-	var currentTimerStartTime = 0;
-	var currentTimerNestedFlushDuration = 0;
-	var currentTimerType = null;
-
-	var lifeCycleTimerHasWarned = false;
-
-	function clearHistory() {
-	  ReactComponentTreeHook.purgeUnmountedComponents();
-	  ReactHostOperationHistoryHook.clearHistory();
-	}
-
-	function getTreeSnapshot(registeredIDs) {
-	  return registeredIDs.reduce(function (tree, id) {
-	    var ownerID = ReactComponentTreeHook.getOwnerID(id);
-	    var parentID = ReactComponentTreeHook.getParentID(id);
-	    tree[id] = {
-	      displayName: ReactComponentTreeHook.getDisplayName(id),
-	      text: ReactComponentTreeHook.getText(id),
-	      updateCount: ReactComponentTreeHook.getUpdateCount(id),
-	      childIDs: ReactComponentTreeHook.getChildIDs(id),
-	      // Text nodes don't have owners but this is close enough.
-	      ownerID: ownerID || parentID && ReactComponentTreeHook.getOwnerID(parentID) || 0,
-	      parentID: parentID
-	    };
-	    return tree;
-	  }, {});
-	}
-
-	function resetMeasurements() {
-	  var previousStartTime = currentFlushStartTime;
-	  var previousMeasurements = currentFlushMeasurements;
-	  var previousOperations = ReactHostOperationHistoryHook.getHistory();
-
-	  if (currentFlushNesting === 0) {
-	    currentFlushStartTime = 0;
-	    currentFlushMeasurements = [];
-	    clearHistory();
-	    return;
-	  }
-
-	  if (previousMeasurements.length || previousOperations.length) {
-	    var registeredIDs = ReactComponentTreeHook.getRegisteredIDs();
-	    flushHistory.push({
-	      duration: performanceNow() - previousStartTime,
-	      measurements: previousMeasurements || [],
-	      operations: previousOperations || [],
-	      treeSnapshot: getTreeSnapshot(registeredIDs)
-	    });
-	  }
-
-	  clearHistory();
-	  currentFlushStartTime = performanceNow();
-	  currentFlushMeasurements = [];
-	}
-
-	function checkDebugID(debugID) {
-	  var allowRoot = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-
-	  if (allowRoot && debugID === 0) {
-	    return;
-	  }
-	  if (!debugID) {
-	    process.env.NODE_ENV !== 'production' ? warning(false, 'ReactDebugTool: debugID may not be empty.') : void 0;
-	  }
-	}
-
-	function beginLifeCycleTimer(debugID, timerType) {
-	  if (currentFlushNesting === 0) {
-	    return;
-	  }
-	  if (currentTimerType && !lifeCycleTimerHasWarned) {
-	    process.env.NODE_ENV !== 'production' ? warning(false, 'There is an internal error in the React performance measurement code. ' + 'Did not expect %s timer to start while %s timer is still in ' + 'progress for %s instance.', timerType, currentTimerType || 'no', debugID === currentTimerDebugID ? 'the same' : 'another') : void 0;
-	    lifeCycleTimerHasWarned = true;
-	  }
-	  currentTimerStartTime = performanceNow();
-	  currentTimerNestedFlushDuration = 0;
-	  currentTimerDebugID = debugID;
-	  currentTimerType = timerType;
-	}
-
-	function endLifeCycleTimer(debugID, timerType) {
-	  if (currentFlushNesting === 0) {
-	    return;
-	  }
-	  if (currentTimerType !== timerType && !lifeCycleTimerHasWarned) {
-	    process.env.NODE_ENV !== 'production' ? warning(false, 'There is an internal error in the React performance measurement code. ' + 'We did not expect %s timer to stop while %s timer is still in ' + 'progress for %s instance. Please report this as a bug in React.', timerType, currentTimerType || 'no', debugID === currentTimerDebugID ? 'the same' : 'another') : void 0;
-	    lifeCycleTimerHasWarned = true;
-	  }
-	  if (isProfiling) {
-	    currentFlushMeasurements.push({
-	      timerType: timerType,
-	      instanceID: debugID,
-	      duration: performanceNow() - currentTimerStartTime - currentTimerNestedFlushDuration
-	    });
-	  }
-	  currentTimerStartTime = 0;
-	  currentTimerNestedFlushDuration = 0;
-	  currentTimerDebugID = null;
-	  currentTimerType = null;
-	}
-
-	function pauseCurrentLifeCycleTimer() {
-	  var currentTimer = {
-	    startTime: currentTimerStartTime,
-	    nestedFlushStartTime: performanceNow(),
-	    debugID: currentTimerDebugID,
-	    timerType: currentTimerType
-	  };
-	  lifeCycleTimerStack.push(currentTimer);
-	  currentTimerStartTime = 0;
-	  currentTimerNestedFlushDuration = 0;
-	  currentTimerDebugID = null;
-	  currentTimerType = null;
-	}
-
-	function resumeCurrentLifeCycleTimer() {
-	  var _lifeCycleTimerStack$ = lifeCycleTimerStack.pop(),
-	      startTime = _lifeCycleTimerStack$.startTime,
-	      nestedFlushStartTime = _lifeCycleTimerStack$.nestedFlushStartTime,
-	      debugID = _lifeCycleTimerStack$.debugID,
-	      timerType = _lifeCycleTimerStack$.timerType;
-
-	  var nestedFlushDuration = performanceNow() - nestedFlushStartTime;
-	  currentTimerStartTime = startTime;
-	  currentTimerNestedFlushDuration += nestedFlushDuration;
-	  currentTimerDebugID = debugID;
-	  currentTimerType = timerType;
-	}
-
-	var lastMarkTimeStamp = 0;
-	var canUsePerformanceMeasure =
-	// $FlowFixMe https://github.com/facebook/flow/issues/2345
-	typeof performance !== 'undefined' && typeof performance.mark === 'function' && typeof performance.clearMarks === 'function' && typeof performance.measure === 'function' && typeof performance.clearMeasures === 'function';
-
-	function shouldMark(debugID) {
-	  if (!isProfiling || !canUsePerformanceMeasure) {
-	    return false;
-	  }
-	  var element = ReactComponentTreeHook.getElement(debugID);
-	  if (element == null || typeof element !== 'object') {
-	    return false;
-	  }
-	  var isHostElement = typeof element.type === 'string';
-	  if (isHostElement) {
-	    return false;
-	  }
-	  return true;
-	}
-
-	function markBegin(debugID, markType) {
-	  if (!shouldMark(debugID)) {
-	    return;
-	  }
-
-	  var markName = debugID + '::' + markType;
-	  lastMarkTimeStamp = performanceNow();
-	  performance.mark(markName);
-	}
-
-	function markEnd(debugID, markType) {
-	  if (!shouldMark(debugID)) {
-	    return;
-	  }
-
-	  var markName = debugID + '::' + markType;
-	  var displayName = ReactComponentTreeHook.getDisplayName(debugID) || 'Unknown';
-
-	  // Chrome has an issue of dropping markers recorded too fast:
-	  // https://bugs.chromium.org/p/chromium/issues/detail?id=640652
-	  // To work around this, we will not report very small measurements.
-	  // I determined the magic number by tweaking it back and forth.
-	  // 0.05ms was enough to prevent the issue, but I set it to 0.1ms to be safe.
-	  // When the bug is fixed, we can `measure()` unconditionally if we want to.
-	  var timeStamp = performanceNow();
-	  if (timeStamp - lastMarkTimeStamp > 0.1) {
-	    var measurementName = displayName + ' [' + markType + ']';
-	    performance.measure(measurementName, markName);
-	  }
-
-	  performance.clearMarks(markName);
-	  performance.clearMeasures(measurementName);
-	}
-
-	var ReactDebugTool = {
-	  addHook: function (hook) {
-	    hooks.push(hook);
-	  },
-	  removeHook: function (hook) {
-	    for (var i = 0; i < hooks.length; i++) {
-	      if (hooks[i] === hook) {
-	        hooks.splice(i, 1);
-	        i--;
-	      }
-	    }
-	  },
-	  isProfiling: function () {
-	    return isProfiling;
-	  },
-	  beginProfiling: function () {
-	    if (isProfiling) {
-	      return;
-	    }
-
-	    isProfiling = true;
-	    flushHistory.length = 0;
-	    resetMeasurements();
-	    ReactDebugTool.addHook(ReactHostOperationHistoryHook);
-	  },
-	  endProfiling: function () {
-	    if (!isProfiling) {
-	      return;
-	    }
-
-	    isProfiling = false;
-	    resetMeasurements();
-	    ReactDebugTool.removeHook(ReactHostOperationHistoryHook);
-	  },
-	  getFlushHistory: function () {
-	    return flushHistory;
-	  },
-	  onBeginFlush: function () {
-	    currentFlushNesting++;
-	    resetMeasurements();
-	    pauseCurrentLifeCycleTimer();
-	    emitEvent('onBeginFlush');
-	  },
-	  onEndFlush: function () {
-	    resetMeasurements();
-	    currentFlushNesting--;
-	    resumeCurrentLifeCycleTimer();
-	    emitEvent('onEndFlush');
-	  },
-	  onBeginLifeCycleTimer: function (debugID, timerType) {
-	    checkDebugID(debugID);
-	    emitEvent('onBeginLifeCycleTimer', debugID, timerType);
-	    markBegin(debugID, timerType);
-	    beginLifeCycleTimer(debugID, timerType);
-	  },
-	  onEndLifeCycleTimer: function (debugID, timerType) {
-	    checkDebugID(debugID);
-	    endLifeCycleTimer(debugID, timerType);
-	    markEnd(debugID, timerType);
-	    emitEvent('onEndLifeCycleTimer', debugID, timerType);
-	  },
-	  onBeginProcessingChildContext: function () {
-	    emitEvent('onBeginProcessingChildContext');
-	  },
-	  onEndProcessingChildContext: function () {
-	    emitEvent('onEndProcessingChildContext');
-	  },
-	  onHostOperation: function (operation) {
-	    checkDebugID(operation.instanceID);
-	    emitEvent('onHostOperation', operation);
-	  },
-	  onSetState: function () {
-	    emitEvent('onSetState');
-	  },
-	  onSetChildren: function (debugID, childDebugIDs) {
-	    checkDebugID(debugID);
-	    childDebugIDs.forEach(checkDebugID);
-	    emitEvent('onSetChildren', debugID, childDebugIDs);
-	  },
-	  onBeforeMountComponent: function (debugID, element, parentDebugID) {
-	    checkDebugID(debugID);
-	    checkDebugID(parentDebugID, true);
-	    emitEvent('onBeforeMountComponent', debugID, element, parentDebugID);
-	    markBegin(debugID, 'mount');
-	  },
-	  onMountComponent: function (debugID) {
-	    checkDebugID(debugID);
-	    markEnd(debugID, 'mount');
-	    emitEvent('onMountComponent', debugID);
-	  },
-	  onBeforeUpdateComponent: function (debugID, element) {
-	    checkDebugID(debugID);
-	    emitEvent('onBeforeUpdateComponent', debugID, element);
-	    markBegin(debugID, 'update');
-	  },
-	  onUpdateComponent: function (debugID) {
-	    checkDebugID(debugID);
-	    markEnd(debugID, 'update');
-	    emitEvent('onUpdateComponent', debugID);
-	  },
-	  onBeforeUnmountComponent: function (debugID) {
-	    checkDebugID(debugID);
-	    emitEvent('onBeforeUnmountComponent', debugID);
-	    markBegin(debugID, 'unmount');
-	  },
-	  onUnmountComponent: function (debugID) {
-	    checkDebugID(debugID);
-	    markEnd(debugID, 'unmount');
-	    emitEvent('onUnmountComponent', debugID);
-	  },
-	  onTestEvent: function () {
-	    emitEvent('onTestEvent');
-	  }
-	};
-
-	// TODO remove these when RN/www gets updated
-	ReactDebugTool.addDevtool = ReactDebugTool.addHook;
-	ReactDebugTool.removeDevtool = ReactDebugTool.removeHook;
-
-	ReactDebugTool.addHook(ReactInvalidSetStateWarningHook);
-	ReactDebugTool.addHook(ReactComponentTreeHook);
-	var url = ExecutionEnvironment.canUseDOM && window.location.href || '';
-	if (/[?&]react_perf\b/.test(url)) {
-	  ReactDebugTool.beginProfiling();
-	}
-
-	module.exports = ReactDebugTool;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 68 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2016-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var warning = __webpack_require__(47);
-
-	if (process.env.NODE_ENV !== 'production') {
-	  var processingChildContext = false;
-
-	  var warnInvalidSetState = function () {
-	    process.env.NODE_ENV !== 'production' ? warning(!processingChildContext, 'setState(...): Cannot call setState() inside getChildContext()') : void 0;
-	  };
-	}
-
-	var ReactInvalidSetStateWarningHook = {
-	  onBeginProcessingChildContext: function () {
-	    processingChildContext = true;
-	  },
-	  onEndProcessingChildContext: function () {
-	    processingChildContext = false;
-	  },
-	  onSetState: function () {
-	    warnInvalidSetState();
-	  }
-	};
-
-	module.exports = ReactInvalidSetStateWarningHook;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 69 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2016-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var history = [];
-
-	var ReactHostOperationHistoryHook = {
-	  onHostOperation: function (operation) {
-	    history.push(operation);
-	  },
-	  clearHistory: function () {
-	    if (ReactHostOperationHistoryHook._preventClearing) {
-	      // Should only be used for tests.
-	      return;
-	    }
-
-	    history = [];
-	  },
-	  getHistory: function () {
-	    return history;
-	  }
-	};
-
-	module.exports = ReactHostOperationHistoryHook;
-
-/***/ },
-/* 70 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * @typechecks
-	 */
-
-	var performance = __webpack_require__(71);
-
-	var performanceNow;
-
-	/**
-	 * Detect if we can use `window.performance.now()` and gracefully fallback to
-	 * `Date.now()` if it doesn't exist. We need to support Firefox < 15 for now
-	 * because of Facebook's testing infrastructure.
-	 */
-	if (performance.now) {
-	  performanceNow = function performanceNow() {
-	    return performance.now();
-	  };
-	} else {
-	  performanceNow = function performanceNow() {
-	    return Date.now();
-	  };
-	}
-
-	module.exports = performanceNow;
-
-/***/ },
-/* 71 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * @typechecks
-	 */
-
-	'use strict';
-
-	var ExecutionEnvironment = __webpack_require__(51);
-
-	var performance;
-
-	if (ExecutionEnvironment.canUseDOM) {
-	  performance = window.performance || window.msPerformance || window.webkitPerformance;
-	}
-
-	module.exports = performance || {};
-
-/***/ },
-/* 72 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var invariant = __webpack_require__(37);
-
-	var OBSERVED_ERROR = {};
-
-	/**
-	 * `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 run while it is already being run. 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>
-	 *
-	 * 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 `componentDidUpdate` 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 updates.
-	 *
-	 * 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 TransactionImpl = {
-	  /**
-	   * 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.length = 0;
-	    } else {
-	      this.wrapperInitData = [];
-	    }
-	    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. The optional arguments helps prevent the need
-	   * to bind in many cases.
-	   *
-	   * @param {function} method Member of scope to call.
-	   * @param {Object} scope Scope to invoke from.
-	   * @param {Object?=} a Argument to pass to the method.
-	   * @param {Object?=} b Argument to pass to the method.
-	   * @param {Object?=} c Argument to pass to the method.
-	   * @param {Object?=} d Argument to pass to the method.
-	   * @param {Object?=} e Argument to pass to the method.
-	   * @param {Object?=} f Argument to pass to the method.
-	   *
-	   * @return {*} Return value from `method`.
-	   */
-	  perform: function (method, scope, a, b, c, d, e, f) {
-	    !!this.isInTransaction() ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Transaction.perform(...): Cannot initialize a transaction when there is already an outstanding transaction.') : _prodInvariant('27') : void 0;
-	    var errorThrown;
-	    var ret;
-	    try {
-	      this._isInTransaction = true;
-	      // Catching errors makes debugging more difficult, so we start with
-	      // errorThrown set to true before setting it to false after calling
-	      // close -- if it's still set to true in the finally block, it means
-	      // one of these calls threw.
-	      errorThrown = true;
-	      this.initializeAll(0);
-	      ret = method.call(scope, a, b, c, d, e, f);
-	      errorThrown = false;
-	    } finally {
-	      try {
-	        if (errorThrown) {
-	          // If `method` throws, prefer to show that stack trace over any thrown
-	          // by invoking `closeAll`.
-	          try {
-	            this.closeAll(0);
-	          } catch (err) {}
-	        } else {
-	          // Since `method` didn't throw, we don't want to silence the exception
-	          // here.
-	          this.closeAll(0);
-	        }
-	      } finally {
-	        this._isInTransaction = false;
-	      }
-	    }
-	    return ret;
-	  },
-
-	  initializeAll: function (startIndex) {
-	    var transactionWrappers = this.transactionWrappers;
-	    for (var i = startIndex; i < transactionWrappers.length; i++) {
-	      var wrapper = transactionWrappers[i];
-	      try {
-	        // Catching errors makes debugging more difficult, so we start with the
-	        // OBSERVED_ERROR state before overwriting it with the real return value
-	        // of initialize -- if it's still set to OBSERVED_ERROR in the finally
-	        // block, it means wrapper.initialize threw.
-	        this.wrapperInitData[i] = OBSERVED_ERROR;
-	        this.wrapperInitData[i] = wrapper.initialize ? wrapper.initialize.call(this) : null;
-	      } finally {
-	        if (this.wrapperInitData[i] === OBSERVED_ERROR) {
-	          // The initializer for wrapper i threw an error; initialize the
-	          // remaining wrappers but silence any exceptions from them to ensure
-	          // that the first error is the one to bubble up.
-	          try {
-	            this.initializeAll(i + 1);
-	          } catch (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 (startIndex) {
-	    !this.isInTransaction() ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Transaction.closeAll(): Cannot close transaction when none are open.') : _prodInvariant('28') : void 0;
-	    var transactionWrappers = this.transactionWrappers;
-	    for (var i = startIndex; i < transactionWrappers.length; i++) {
-	      var wrapper = transactionWrappers[i];
-	      var initData = this.wrapperInitData[i];
-	      var errorThrown;
-	      try {
-	        // Catching errors makes debugging more difficult, so we start with
-	        // errorThrown set to true before setting it to false after calling
-	        // close -- if it's still set to true in the finally block, it means
-	        // wrapper.close threw.
-	        errorThrown = true;
-	        if (initData !== OBSERVED_ERROR && wrapper.close) {
-	          wrapper.close.call(this, initData);
-	        }
-	        errorThrown = false;
-	      } finally {
-	        if (errorThrown) {
-	          // The closer for wrapper i threw an error; close the remaining
-	          // wrappers but silence any exceptions from them to ensure that the
-	          // first error is the one to bubble up.
-	          try {
-	            this.closeAll(i + 1);
-	          } catch (e) {}
-	        }
-	      }
-	    }
-	    this.wrapperInitData.length = 0;
-	  }
-	};
-
-	module.exports = TransactionImpl;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 73 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	/**
-	 * Gets the target node from a native browser event by accounting for
-	 * inconsistencies in browser DOM APIs.
-	 *
-	 * @param {object} nativeEvent Native browser event.
-	 * @return {DOMEventTarget} Target node.
-	 */
-
-	function getEventTarget(nativeEvent) {
-	  var target = nativeEvent.target || nativeEvent.srcElement || window;
-
-	  // Normalize SVG <use> element events #4963
-	  if (target.correspondingUseElement) {
-	    target = target.correspondingUseElement;
-	  }
-
-	  // Safari may fire events on text nodes (Node.TEXT_NODE is 3).
-	  // @see http://www.quirksmode.org/js/events_properties.html
-	  return target.nodeType === 3 ? target.parentNode : target;
-	}
-
-	module.exports = getEventTarget;
-
-/***/ },
-/* 74 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ExecutionEnvironment = __webpack_require__(51);
-
-	var useHasFeature;
-	if (ExecutionEnvironment.canUseDOM) {
-	  useHasFeature = document.implementation && document.implementation.hasFeature &&
-	  // always returns true in newer browsers as per the standard.
-	  // @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature
-	  document.implementation.hasFeature('', '') !== true;
-	}
-
-	/**
-	 * 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 (!ExecutionEnvironment.canUseDOM || capture && !('addEventListener' in document)) {
-	    return false;
-	  }
-
-	  var eventName = 'on' + eventNameSuffix;
-	  var isSupported = eventName in document;
-
-	  if (!isSupported) {
-	    var element = document.createElement('div');
-	    element.setAttribute(eventName, 'return;');
-	    isSupported = typeof element[eventName] === 'function';
-	  }
-
-	  if (!isSupported && useHasFeature && eventNameSuffix === 'wheel') {
-	    // This is the only way to test support for the `wheel` event in IE9+.
-	    isSupported = document.implementation.hasFeature('Events.wheel', '3.0');
-	  }
-
-	  return isSupported;
-	}
-
-	module.exports = isEventSupported;
-
-/***/ },
-/* 75 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	/**
-	 * @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
-	};
-
-	function isTextInputElement(elem) {
-	  var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
-
-	  if (nodeName === 'input') {
-	    return !!supportedInputTypes[elem.type];
-	  }
-
-	  if (nodeName === 'textarea') {
-	    return true;
-	  }
-
-	  return false;
-	}
-
-	module.exports = isTextInputElement;
-
-/***/ },
-/* 76 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	/**
-	 * 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 = ['ResponderEventPlugin', 'SimpleEventPlugin', 'TapEventPlugin', 'EnterLeaveEventPlugin', 'ChangeEventPlugin', 'SelectEventPlugin', 'BeforeInputEventPlugin'];
-
-	module.exports = DefaultEventPluginOrder;
-
-/***/ },
-/* 77 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var EventPropagators = __webpack_require__(42);
-	var ReactDOMComponentTree = __webpack_require__(34);
-	var SyntheticMouseEvent = __webpack_require__(78);
-
-	var eventTypes = {
-	  mouseEnter: {
-	    registrationName: 'onMouseEnter',
-	    dependencies: ['topMouseOut', 'topMouseOver']
-	  },
-	  mouseLeave: {
-	    registrationName: 'onMouseLeave',
-	    dependencies: ['topMouseOut', 'topMouseOver']
-	  }
-	};
-
-	var EnterLeaveEventPlugin = {
-
-	  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.
-	   */
-	  extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-	    if (topLevelType === 'topMouseOver' && (nativeEvent.relatedTarget || nativeEvent.fromElement)) {
-	      return null;
-	    }
-	    if (topLevelType !== 'topMouseOut' && topLevelType !== 'topMouseOver') {
-	      // Must not be a mouse in or mouse out - ignoring.
-	      return null;
-	    }
-
-	    var win;
-	    if (nativeEventTarget.window === nativeEventTarget) {
-	      // `nativeEventTarget` is probably a window object.
-	      win = nativeEventTarget;
-	    } else {
-	      // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
-	      var doc = nativeEventTarget.ownerDocument;
-	      if (doc) {
-	        win = doc.defaultView || doc.parentWindow;
-	      } else {
-	        win = window;
-	      }
-	    }
-
-	    var from;
-	    var to;
-	    if (topLevelType === 'topMouseOut') {
-	      from = targetInst;
-	      var related = nativeEvent.relatedTarget || nativeEvent.toElement;
-	      to = related ? ReactDOMComponentTree.getClosestInstanceFromNode(related) : null;
-	    } else {
-	      // Moving to a node from outside the window.
-	      from = null;
-	      to = targetInst;
-	    }
-
-	    if (from === to) {
-	      // Nothing pertains to our managed components.
-	      return null;
-	    }
-
-	    var fromNode = from == null ? win : ReactDOMComponentTree.getNodeFromInstance(from);
-	    var toNode = to == null ? win : ReactDOMComponentTree.getNodeFromInstance(to);
-
-	    var leave = SyntheticMouseEvent.getPooled(eventTypes.mouseLeave, from, nativeEvent, nativeEventTarget);
-	    leave.type = 'mouseleave';
-	    leave.target = fromNode;
-	    leave.relatedTarget = toNode;
-
-	    var enter = SyntheticMouseEvent.getPooled(eventTypes.mouseEnter, to, nativeEvent, nativeEventTarget);
-	    enter.type = 'mouseenter';
-	    enter.target = toNode;
-	    enter.relatedTarget = fromNode;
-
-	    EventPropagators.accumulateEnterLeaveDispatches(leave, enter, from, to);
-
-	    return [leave, enter];
-	  }
-
-	};
-
-	module.exports = EnterLeaveEventPlugin;
-
-/***/ },
-/* 78 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var SyntheticUIEvent = __webpack_require__(79);
-	var ViewportMetrics = __webpack_require__(80);
-
-	var getEventModifierState = __webpack_require__(81);
-
-	/**
-	 * @interface MouseEvent
-	 * @see http://www.w3.org/TR/DOM-Level-3-Events/
-	 */
-	var MouseEventInterface = {
-	  screenX: null,
-	  screenY: null,
-	  clientX: null,
-	  clientY: null,
-	  ctrlKey: null,
-	  shiftKey: null,
-	  altKey: null,
-	  metaKey: null,
-	  getModifierState: getEventModifierState,
-	  button: function (event) {
-	    // Webkit, Firefox, IE9+
-	    // which:  1 2 3
-	    // button: 0 1 2 (standard)
-	    var button = event.button;
-	    if ('which' in event) {
-	      return button;
-	    }
-	    // IE<9
-	    // which:  undefined
-	    // button: 0 0 0
-	    // button: 1 4 2 (onmouseup)
-	    return button === 2 ? 2 : button === 4 ? 1 : 0;
-	  },
-	  buttons: null,
-	  relatedTarget: function (event) {
-	    return event.relatedTarget || (event.fromElement === event.srcElement ? event.toElement : event.fromElement);
-	  },
-	  // "Proprietary" Interface.
-	  pageX: function (event) {
-	    return 'pageX' in event ? event.pageX : event.clientX + ViewportMetrics.currentScrollLeft;
-	  },
-	  pageY: function (event) {
-	    return 'pageY' in event ? event.pageY : event.clientY + ViewportMetrics.currentScrollTop;
-	  }
-	};
-
-	/**
-	 * @param {object} dispatchConfig Configuration used to dispatch this event.
-	 * @param {string} dispatchMarker Marker identifying the event target.
-	 * @param {object} nativeEvent Native browser event.
-	 * @extends {SyntheticUIEvent}
-	 */
-	function SyntheticMouseEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
-	  return SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
-	}
-
-	SyntheticUIEvent.augmentClass(SyntheticMouseEvent, MouseEventInterface);
-
-	module.exports = SyntheticMouseEvent;
-
-/***/ },
-/* 79 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var SyntheticEvent = __webpack_require__(57);
-
-	var getEventTarget = __webpack_require__(73);
-
-	/**
-	 * @interface UIEvent
-	 * @see http://www.w3.org/TR/DOM-Level-3-Events/
-	 */
-	var UIEventInterface = {
-	  view: function (event) {
-	    if (event.view) {
-	      return event.view;
-	    }
-
-	    var target = getEventTarget(event);
-	    if (target.window === target) {
-	      // target is a window object
-	      return target;
-	    }
-
-	    var doc = target.ownerDocument;
-	    // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
-	    if (doc) {
-	      return doc.defaultView || doc.parentWindow;
-	    } else {
-	      return window;
-	    }
-	  },
-	  detail: function (event) {
-	    return event.detail || 0;
-	  }
-	};
-
-	/**
-	 * @param {object} dispatchConfig Configuration used to dispatch this event.
-	 * @param {string} dispatchMarker Marker identifying the event target.
-	 * @param {object} nativeEvent Native browser event.
-	 * @extends {SyntheticEvent}
-	 */
-	function SyntheticUIEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
-	  return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
-	}
-
-	SyntheticEvent.augmentClass(SyntheticUIEvent, UIEventInterface);
-
-	module.exports = SyntheticUIEvent;
-
-/***/ },
-/* 80 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ViewportMetrics = {
-
-	  currentScrollLeft: 0,
-
-	  currentScrollTop: 0,
-
-	  refreshScrollValues: function (scrollPosition) {
-	    ViewportMetrics.currentScrollLeft = scrollPosition.x;
-	    ViewportMetrics.currentScrollTop = scrollPosition.y;
-	  }
-
-	};
-
-	module.exports = ViewportMetrics;
-
-/***/ },
-/* 81 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	/**
-	 * Translation from modifier key to the associated property in the event.
-	 * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
-	 */
-
-	var modifierKeyToProp = {
-	  'Alt': 'altKey',
-	  'Control': 'ctrlKey',
-	  'Meta': 'metaKey',
-	  'Shift': 'shiftKey'
-	};
-
-	// IE8 does not implement getModifierState so we simply map it to the only
-	// modifier keys exposed by the event itself, does not support Lock-keys.
-	// Currently, all major browsers except Chrome seems to support Lock-keys.
-	function modifierStateGetter(keyArg) {
-	  var syntheticEvent = this;
-	  var nativeEvent = syntheticEvent.nativeEvent;
-	  if (nativeEvent.getModifierState) {
-	    return nativeEvent.getModifierState(keyArg);
-	  }
-	  var keyProp = modifierKeyToProp[keyArg];
-	  return keyProp ? !!nativeEvent[keyProp] : false;
-	}
-
-	function getEventModifierState(nativeEvent) {
-	  return modifierStateGetter;
-	}
-
-	module.exports = getEventModifierState;
-
-/***/ },
-/* 82 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var DOMProperty = __webpack_require__(36);
-
-	var MUST_USE_PROPERTY = DOMProperty.injection.MUST_USE_PROPERTY;
-	var HAS_BOOLEAN_VALUE = DOMProperty.injection.HAS_BOOLEAN_VALUE;
-	var HAS_NUMERIC_VALUE = DOMProperty.injection.HAS_NUMERIC_VALUE;
-	var HAS_POSITIVE_NUMERIC_VALUE = DOMProperty.injection.HAS_POSITIVE_NUMERIC_VALUE;
-	var HAS_OVERLOADED_BOOLEAN_VALUE = DOMProperty.injection.HAS_OVERLOADED_BOOLEAN_VALUE;
-
-	var HTMLDOMPropertyConfig = {
-	  isCustomAttribute: RegExp.prototype.test.bind(new RegExp('^(data|aria)-[' + DOMProperty.ATTRIBUTE_NAME_CHAR + ']*$')),
-	  Properties: {
-	    /**
-	     * Standard Properties
-	     */
-	    accept: 0,
-	    acceptCharset: 0,
-	    accessKey: 0,
-	    action: 0,
-	    allowFullScreen: HAS_BOOLEAN_VALUE,
-	    allowTransparency: 0,
-	    alt: 0,
-	    // specifies target context for links with `preload` type
-	    as: 0,
-	    async: HAS_BOOLEAN_VALUE,
-	    autoComplete: 0,
-	    // autoFocus is polyfilled/normalized by AutoFocusUtils
-	    // autoFocus: HAS_BOOLEAN_VALUE,
-	    autoPlay: HAS_BOOLEAN_VALUE,
-	    capture: HAS_BOOLEAN_VALUE,
-	    cellPadding: 0,
-	    cellSpacing: 0,
-	    charSet: 0,
-	    challenge: 0,
-	    checked: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
-	    cite: 0,
-	    classID: 0,
-	    className: 0,
-	    cols: HAS_POSITIVE_NUMERIC_VALUE,
-	    colSpan: 0,
-	    content: 0,
-	    contentEditable: 0,
-	    contextMenu: 0,
-	    controls: HAS_BOOLEAN_VALUE,
-	    coords: 0,
-	    crossOrigin: 0,
-	    data: 0, // For `<object />` acts as `src`.
-	    dateTime: 0,
-	    'default': HAS_BOOLEAN_VALUE,
-	    defer: HAS_BOOLEAN_VALUE,
-	    dir: 0,
-	    disabled: HAS_BOOLEAN_VALUE,
-	    download: HAS_OVERLOADED_BOOLEAN_VALUE,
-	    draggable: 0,
-	    encType: 0,
-	    form: 0,
-	    formAction: 0,
-	    formEncType: 0,
-	    formMethod: 0,
-	    formNoValidate: HAS_BOOLEAN_VALUE,
-	    formTarget: 0,
-	    frameBorder: 0,
-	    headers: 0,
-	    height: 0,
-	    hidden: HAS_BOOLEAN_VALUE,
-	    high: 0,
-	    href: 0,
-	    hrefLang: 0,
-	    htmlFor: 0,
-	    httpEquiv: 0,
-	    icon: 0,
-	    id: 0,
-	    inputMode: 0,
-	    integrity: 0,
-	    is: 0,
-	    keyParams: 0,
-	    keyType: 0,
-	    kind: 0,
-	    label: 0,
-	    lang: 0,
-	    list: 0,
-	    loop: HAS_BOOLEAN_VALUE,
-	    low: 0,
-	    manifest: 0,
-	    marginHeight: 0,
-	    marginWidth: 0,
-	    max: 0,
-	    maxLength: 0,
-	    media: 0,
-	    mediaGroup: 0,
-	    method: 0,
-	    min: 0,
-	    minLength: 0,
-	    // Caution; `option.selected` is not updated if `select.multiple` is
-	    // disabled with `removeAttribute`.
-	    multiple: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
-	    muted: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
-	    name: 0,
-	    nonce: 0,
-	    noValidate: HAS_BOOLEAN_VALUE,
-	    open: HAS_BOOLEAN_VALUE,
-	    optimum: 0,
-	    pattern: 0,
-	    placeholder: 0,
-	    playsInline: HAS_BOOLEAN_VALUE,
-	    poster: 0,
-	    preload: 0,
-	    profile: 0,
-	    radioGroup: 0,
-	    readOnly: HAS_BOOLEAN_VALUE,
-	    referrerPolicy: 0,
-	    rel: 0,
-	    required: HAS_BOOLEAN_VALUE,
-	    reversed: HAS_BOOLEAN_VALUE,
-	    role: 0,
-	    rows: HAS_POSITIVE_NUMERIC_VALUE,
-	    rowSpan: HAS_NUMERIC_VALUE,
-	    sandbox: 0,
-	    scope: 0,
-	    scoped: HAS_BOOLEAN_VALUE,
-	    scrolling: 0,
-	    seamless: HAS_BOOLEAN_VALUE,
-	    selected: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
-	    shape: 0,
-	    size: HAS_POSITIVE_NUMERIC_VALUE,
-	    sizes: 0,
-	    span: HAS_POSITIVE_NUMERIC_VALUE,
-	    spellCheck: 0,
-	    src: 0,
-	    srcDoc: 0,
-	    srcLang: 0,
-	    srcSet: 0,
-	    start: HAS_NUMERIC_VALUE,
-	    step: 0,
-	    style: 0,
-	    summary: 0,
-	    tabIndex: 0,
-	    target: 0,
-	    title: 0,
-	    // Setting .type throws on non-<input> tags
-	    type: 0,
-	    useMap: 0,
-	    value: 0,
-	    width: 0,
-	    wmode: 0,
-	    wrap: 0,
-
-	    /**
-	     * RDFa Properties
-	     */
-	    about: 0,
-	    datatype: 0,
-	    inlist: 0,
-	    prefix: 0,
-	    // property is also supported for OpenGraph in meta tags.
-	    property: 0,
-	    resource: 0,
-	    'typeof': 0,
-	    vocab: 0,
-
-	    /**
-	     * Non-standard Properties
-	     */
-	    // autoCapitalize and autoCorrect are supported in Mobile Safari for
-	    // keyboard hints.
-	    autoCapitalize: 0,
-	    autoCorrect: 0,
-	    // autoSave allows WebKit/Blink to persist values of input fields on page reloads
-	    autoSave: 0,
-	    // color is for Safari mask-icon link
-	    color: 0,
-	    // itemProp, itemScope, itemType are for
-	    // Microdata support. See http://schema.org/docs/gs.html
-	    itemProp: 0,
-	    itemScope: HAS_BOOLEAN_VALUE,
-	    itemType: 0,
-	    // itemID and itemRef are for Microdata support as well but
-	    // only specified in the WHATWG spec document. See
-	    // https://html.spec.whatwg.org/multipage/microdata.html#microdata-dom-api
-	    itemID: 0,
-	    itemRef: 0,
-	    // results show looking glass icon and recent searches on input
-	    // search fields in WebKit/Blink
-	    results: 0,
-	    // IE-only attribute that specifies security restrictions on an iframe
-	    // as an alternative to the sandbox attribute on IE<10
-	    security: 0,
-	    // IE-only attribute that controls focus behavior
-	    unselectable: 0
-	  },
-	  DOMAttributeNames: {
-	    acceptCharset: 'accept-charset',
-	    className: 'class',
-	    htmlFor: 'for',
-	    httpEquiv: 'http-equiv'
-	  },
-	  DOMPropertyNames: {}
-	};
-
-	module.exports = HTMLDOMPropertyConfig;
-
-/***/ },
-/* 83 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var DOMChildrenOperations = __webpack_require__(84);
-	var ReactDOMIDOperations = __webpack_require__(95);
-
-	/**
-	 * Abstracts away all functionality of the reconciler that requires knowledge of
-	 * the browser context. TODO: These callers should be refactored to avoid the
-	 * need for this injection.
-	 */
-	var ReactComponentBrowserEnvironment = {
-
-	  processChildrenUpdates: ReactDOMIDOperations.dangerouslyProcessChildrenUpdates,
-
-	  replaceNodeWithMarkup: DOMChildrenOperations.dangerouslyReplaceNodeWithMarkup
-
-	};
-
-	module.exports = ReactComponentBrowserEnvironment;
-
-/***/ },
-/* 84 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var DOMLazyTree = __webpack_require__(85);
-	var Danger = __webpack_require__(91);
-	var ReactDOMComponentTree = __webpack_require__(34);
-	var ReactInstrumentation = __webpack_require__(66);
-
-	var createMicrosoftUnsafeLocalFunction = __webpack_require__(88);
-	var setInnerHTML = __webpack_require__(87);
-	var setTextContent = __webpack_require__(89);
-
-	function getNodeAfter(parentNode, node) {
-	  // Special case for text components, which return [open, close] comments
-	  // from getHostNode.
-	  if (Array.isArray(node)) {
-	    node = node[1];
-	  }
-	  return node ? node.nextSibling : parentNode.firstChild;
-	}
-
-	/**
-	 * Inserts `childNode` as a child of `parentNode` at the `index`.
-	 *
-	 * @param {DOMElement} parentNode Parent node in which to insert.
-	 * @param {DOMElement} childNode Child node to insert.
-	 * @param {number} index Index at which to insert the child.
-	 * @internal
-	 */
-	var insertChildAt = createMicrosoftUnsafeLocalFunction(function (parentNode, childNode, referenceNode) {
-	  // We rely exclusively on `insertBefore(node, null)` instead of also using
-	  // `appendChild(node)`. (Using `undefined` is not allowed by all browsers so
-	  // we are careful to use `null`.)
-	  parentNode.insertBefore(childNode, referenceNode);
-	});
-
-	function insertLazyTreeChildAt(parentNode, childTree, referenceNode) {
-	  DOMLazyTree.insertTreeBefore(parentNode, childTree, referenceNode);
-	}
-
-	function moveChild(parentNode, childNode, referenceNode) {
-	  if (Array.isArray(childNode)) {
-	    moveDelimitedText(parentNode, childNode[0], childNode[1], referenceNode);
-	  } else {
-	    insertChildAt(parentNode, childNode, referenceNode);
-	  }
-	}
-
-	function removeChild(parentNode, childNode) {
-	  if (Array.isArray(childNode)) {
-	    var closingComment = childNode[1];
-	    childNode = childNode[0];
-	    removeDelimitedText(parentNode, childNode, closingComment);
-	    parentNode.removeChild(closingComment);
-	  }
-	  parentNode.removeChild(childNode);
-	}
-
-	function moveDelimitedText(parentNode, openingComment, closingComment, referenceNode) {
-	  var node = openingComment;
-	  while (true) {
-	    var nextNode = node.nextSibling;
-	    insertChildAt(parentNode, node, referenceNode);
-	    if (node === closingComment) {
-	      break;
-	    }
-	    node = nextNode;
-	  }
-	}
-
-	function removeDelimitedText(parentNode, startNode, closingComment) {
-	  while (true) {
-	    var node = startNode.nextSibling;
-	    if (node === closingComment) {
-	      // The closing comment is removed by ReactMultiChild.
-	      break;
-	    } else {
-	      parentNode.removeChild(node);
-	    }
-	  }
-	}
-
-	function replaceDelimitedText(openingComment, closingComment, stringText) {
-	  var parentNode = openingComment.parentNode;
-	  var nodeAfterComment = openingComment.nextSibling;
-	  if (nodeAfterComment === closingComment) {
-	    // There are no text nodes between the opening and closing comments; insert
-	    // a new one if stringText isn't empty.
-	    if (stringText) {
-	      insertChildAt(parentNode, document.createTextNode(stringText), nodeAfterComment);
-	    }
-	  } else {
-	    if (stringText) {
-	      // Set the text content of the first node after the opening comment, and
-	      // remove all following nodes up until the closing comment.
-	      setTextContent(nodeAfterComment, stringText);
-	      removeDelimitedText(parentNode, nodeAfterComment, closingComment);
-	    } else {
-	      removeDelimitedText(parentNode, openingComment, closingComment);
-	    }
-	  }
-
-	  if (process.env.NODE_ENV !== 'production') {
-	    ReactInstrumentation.debugTool.onHostOperation({
-	      instanceID: ReactDOMComponentTree.getInstanceFromNode(openingComment)._debugID,
-	      type: 'replace text',
-	      payload: stringText
-	    });
-	  }
-	}
-
-	var dangerouslyReplaceNodeWithMarkup = Danger.dangerouslyReplaceNodeWithMarkup;
-	if (process.env.NODE_ENV !== 'production') {
-	  dangerouslyReplaceNodeWithMarkup = function (oldChild, markup, prevInstance) {
-	    Danger.dangerouslyReplaceNodeWithMarkup(oldChild, markup);
-	    if (prevInstance._debugID !== 0) {
-	      ReactInstrumentation.debugTool.onHostOperation({
-	        instanceID: prevInstance._debugID,
-	        type: 'replace with',
-	        payload: markup.toString()
-	      });
-	    } else {
-	      var nextInstance = ReactDOMComponentTree.getInstanceFromNode(markup.node);
-	      if (nextInstance._debugID !== 0) {
-	        ReactInstrumentation.debugTool.onHostOperation({
-	          instanceID: nextInstance._debugID,
-	          type: 'mount',
-	          payload: markup.toString()
-	        });
-	      }
-	    }
-	  };
-	}
-
-	/**
-	 * Operations for updating with DOM children.
-	 */
-	var DOMChildrenOperations = {
-
-	  dangerouslyReplaceNodeWithMarkup: dangerouslyReplaceNodeWithMarkup,
-
-	  replaceDelimitedText: replaceDelimitedText,
-
-	  /**
-	   * Updates a component's children by processing a series of updates. The
-	   * update configurations are each expected to have a `parentNode` property.
-	   *
-	   * @param {array<object>} updates List of update configurations.
-	   * @internal
-	   */
-	  processUpdates: function (parentNode, updates) {
-	    if (process.env.NODE_ENV !== 'production') {
-	      var parentNodeDebugID = ReactDOMComponentTree.getInstanceFromNode(parentNode)._debugID;
-	    }
-
-	    for (var k = 0; k < updates.length; k++) {
-	      var update = updates[k];
-	      switch (update.type) {
-	        case 'INSERT_MARKUP':
-	          insertLazyTreeChildAt(parentNode, update.content, getNodeAfter(parentNode, update.afterNode));
-	          if (process.env.NODE_ENV !== 'production') {
-	            ReactInstrumentation.debugTool.onHostOperation({
-	              instanceID: parentNodeDebugID,
-	              type: 'insert child',
-	              payload: { toIndex: update.toIndex, content: update.content.toString() }
-	            });
-	          }
-	          break;
-	        case 'MOVE_EXISTING':
-	          moveChild(parentNode, update.fromNode, getNodeAfter(parentNode, update.afterNode));
-	          if (process.env.NODE_ENV !== 'production') {
-	            ReactInstrumentation.debugTool.onHostOperation({
-	              instanceID: parentNodeDebugID,
-	              type: 'move child',
-	              payload: { fromIndex: update.fromIndex, toIndex: update.toIndex }
-	            });
-	          }
-	          break;
-	        case 'SET_MARKUP':
-	          setInnerHTML(parentNode, update.content);
-	          if (process.env.NODE_ENV !== 'production') {
-	            ReactInstrumentation.debugTool.onHostOperation({
-	              instanceID: parentNodeDebugID,
-	              type: 'replace children',
-	              payload: update.content.toString()
-	            });
-	          }
-	          break;
-	        case 'TEXT_CONTENT':
-	          setTextContent(parentNode, update.content);
-	          if (process.env.NODE_ENV !== 'production') {
-	            ReactInstrumentation.debugTool.onHostOperation({
-	              instanceID: parentNodeDebugID,
-	              type: 'replace text',
-	              payload: update.content.toString()
-	            });
-	          }
-	          break;
-	        case 'REMOVE_NODE':
-	          removeChild(parentNode, update.fromNode);
-	          if (process.env.NODE_ENV !== 'production') {
-	            ReactInstrumentation.debugTool.onHostOperation({
-	              instanceID: parentNodeDebugID,
-	              type: 'remove child',
-	              payload: { fromIndex: update.fromIndex }
-	            });
-	          }
-	          break;
-	      }
-	    }
-	  }
-
-	};
-
-	module.exports = DOMChildrenOperations;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 85 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2015-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var DOMNamespaces = __webpack_require__(86);
-	var setInnerHTML = __webpack_require__(87);
-
-	var createMicrosoftUnsafeLocalFunction = __webpack_require__(88);
-	var setTextContent = __webpack_require__(89);
-
-	var ELEMENT_NODE_TYPE = 1;
-	var DOCUMENT_FRAGMENT_NODE_TYPE = 11;
-
-	/**
-	 * In IE (8-11) and Edge, appending nodes with no children is dramatically
-	 * faster than appending a full subtree, so we essentially queue up the
-	 * .appendChild calls here and apply them so each node is added to its parent
-	 * before any children are added.
-	 *
-	 * In other browsers, doing so is slower or neutral compared to the other order
-	 * (in Firefox, twice as slow) so we only do this inversion in IE.
-	 *
-	 * See https://github.com/spicyj/innerhtml-vs-createelement-vs-clonenode.
-	 */
-	var enableLazy = typeof document !== 'undefined' && typeof document.documentMode === 'number' || typeof navigator !== 'undefined' && typeof navigator.userAgent === 'string' && /\bEdge\/\d/.test(navigator.userAgent);
-
-	function insertTreeChildren(tree) {
-	  if (!enableLazy) {
-	    return;
-	  }
-	  var node = tree.node;
-	  var children = tree.children;
-	  if (children.length) {
-	    for (var i = 0; i < children.length; i++) {
-	      insertTreeBefore(node, children[i], null);
-	    }
-	  } else if (tree.html != null) {
-	    setInnerHTML(node, tree.html);
-	  } else if (tree.text != null) {
-	    setTextContent(node, tree.text);
-	  }
-	}
-
-	var insertTreeBefore = createMicrosoftUnsafeLocalFunction(function (parentNode, tree, referenceNode) {
-	  // DocumentFragments aren't actually part of the DOM after insertion so
-	  // appending children won't update the DOM. We need to ensure the fragment
-	  // is properly populated first, breaking out of our lazy approach for just
-	  // this level. Also, some <object> plugins (like Flash Player) will read
-	  // <param> nodes immediately upon insertion into the DOM, so <object>
-	  // must also be populated prior to insertion into the DOM.
-	  if (tree.node.nodeType === DOCUMENT_FRAGMENT_NODE_TYPE || tree.node.nodeType === ELEMENT_NODE_TYPE && tree.node.nodeName.toLowerCase() === 'object' && (tree.node.namespaceURI == null || tree.node.namespaceURI === DOMNamespaces.html)) {
-	    insertTreeChildren(tree);
-	    parentNode.insertBefore(tree.node, referenceNode);
-	  } else {
-	    parentNode.insertBefore(tree.node, referenceNode);
-	    insertTreeChildren(tree);
-	  }
-	});
-
-	function replaceChildWithTree(oldNode, newTree) {
-	  oldNode.parentNode.replaceChild(newTree.node, oldNode);
-	  insertTreeChildren(newTree);
-	}
-
-	function queueChild(parentTree, childTree) {
-	  if (enableLazy) {
-	    parentTree.children.push(childTree);
-	  } else {
-	    parentTree.node.appendChild(childTree.node);
-	  }
-	}
-
-	function queueHTML(tree, html) {
-	  if (enableLazy) {
-	    tree.html = html;
-	  } else {
-	    setInnerHTML(tree.node, html);
-	  }
-	}
-
-	function queueText(tree, text) {
-	  if (enableLazy) {
-	    tree.text = text;
-	  } else {
-	    setTextContent(tree.node, text);
-	  }
-	}
-
-	function toString() {
-	  return this.node.nodeName;
-	}
-
-	function DOMLazyTree(node) {
-	  return {
-	    node: node,
-	    children: [],
-	    html: null,
-	    text: null,
-	    toString: toString
-	  };
-	}
-
-	DOMLazyTree.insertTreeBefore = insertTreeBefore;
-	DOMLazyTree.replaceChildWithTree = replaceChildWithTree;
-	DOMLazyTree.queueChild = queueChild;
-	DOMLazyTree.queueHTML = queueHTML;
-	DOMLazyTree.queueText = queueText;
-
-	module.exports = DOMLazyTree;
-
-/***/ },
-/* 86 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var DOMNamespaces = {
-	  html: 'http://www.w3.org/1999/xhtml',
-	  mathml: 'http://www.w3.org/1998/Math/MathML',
-	  svg: 'http://www.w3.org/2000/svg'
-	};
-
-	module.exports = DOMNamespaces;
-
-/***/ },
-/* 87 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ExecutionEnvironment = __webpack_require__(51);
-	var DOMNamespaces = __webpack_require__(86);
-
-	var WHITESPACE_TEST = /^[ \r\n\t\f]/;
-	var NONVISIBLE_TEST = /<(!--|link|noscript|meta|script|style)[ \r\n\t\f\/>]/;
-
-	var createMicrosoftUnsafeLocalFunction = __webpack_require__(88);
-
-	// SVG temp container for IE lacking innerHTML
-	var reusableSVGContainer;
-
-	/**
-	 * Set the innerHTML property of a node, ensuring that whitespace is preserved
-	 * even in IE8.
-	 *
-	 * @param {DOMElement} node
-	 * @param {string} html
-	 * @internal
-	 */
-	var setInnerHTML = createMicrosoftUnsafeLocalFunction(function (node, html) {
-	  // IE does not have innerHTML for SVG nodes, so instead we inject the
-	  // new markup in a temp node and then move the child nodes across into
-	  // the target node
-	  if (node.namespaceURI === DOMNamespaces.svg && !('innerHTML' in node)) {
-	    reusableSVGContainer = reusableSVGContainer || document.createElement('div');
-	    reusableSVGContainer.innerHTML = '<svg>' + html + '</svg>';
-	    var svgNode = reusableSVGContainer.firstChild;
-	    while (svgNode.firstChild) {
-	      node.appendChild(svgNode.firstChild);
-	    }
-	  } else {
-	    node.innerHTML = html;
-	  }
-	});
-
-	if (ExecutionEnvironment.canUseDOM) {
-	  // IE8: When updating a just created node with innerHTML only leading
-	  // whitespace is removed. When updating an existing node with innerHTML
-	  // whitespace in root TextNodes is also collapsed.
-	  // @see quirksmode.org/bugreports/archives/2004/11/innerhtml_and_t.html
-
-	  // Feature detection; only IE8 is known to behave improperly like this.
-	  var testElement = document.createElement('div');
-	  testElement.innerHTML = ' ';
-	  if (testElement.innerHTML === '') {
-	    setInnerHTML = function (node, html) {
-	      // Magic theory: IE8 supposedly differentiates between added and updated
-	      // nodes when processing innerHTML, innerHTML on updated nodes suffers
-	      // from worse whitespace behavior. Re-adding a node like this triggers
-	      // the initial and more favorable whitespace behavior.
-	      // TODO: What to do on a detached node?
-	      if (node.parentNode) {
-	        node.parentNode.replaceChild(node, node);
-	      }
-
-	      // We also implement a workaround for non-visible tags disappearing into
-	      // thin air on IE8, this only happens if there is no visible text
-	      // in-front of the non-visible tags. Piggyback on the whitespace fix
-	      // and simply check if any non-visible tags appear in the source.
-	      if (WHITESPACE_TEST.test(html) || html[0] === '<' && NONVISIBLE_TEST.test(html)) {
-	        // Recover leading whitespace by temporarily prepending any character.
-	        // \uFEFF has the potential advantage of being zero-width/invisible.
-	        // UglifyJS drops U+FEFF chars when parsing, so use String.fromCharCode
-	        // in hopes that this is preserved even if "\uFEFF" is transformed to
-	        // the actual Unicode character (by Babel, for example).
-	        // https://github.com/mishoo/UglifyJS2/blob/v2.4.20/lib/parse.js#L216
-	        node.innerHTML = String.fromCharCode(0xFEFF) + html;
-
-	        // deleteData leaves an empty `TextNode` which offsets the index of all
-	        // children. Definitely want to avoid this.
-	        var textNode = node.firstChild;
-	        if (textNode.data.length === 1) {
-	          node.removeChild(textNode);
-	        } else {
-	          textNode.deleteData(0, 1);
-	        }
-	      } else {
-	        node.innerHTML = html;
-	      }
-	    };
-	  }
-	  testElement = null;
-	}
-
-	module.exports = setInnerHTML;
-
-/***/ },
-/* 88 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	/* globals MSApp */
-
-	'use strict';
-
-	/**
-	 * Create a function which has 'unsafe' privileges (required by windows8 apps)
-	 */
-
-	var createMicrosoftUnsafeLocalFunction = function (func) {
-	  if (typeof MSApp !== 'undefined' && MSApp.execUnsafeLocalFunction) {
-	    return function (arg0, arg1, arg2, arg3) {
-	      MSApp.execUnsafeLocalFunction(function () {
-	        return func(arg0, arg1, arg2, arg3);
-	      });
-	    };
-	  } else {
-	    return func;
-	  }
-	};
-
-	module.exports = createMicrosoftUnsafeLocalFunction;
-
-/***/ },
-/* 89 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ExecutionEnvironment = __webpack_require__(51);
-	var escapeTextContentForBrowser = __webpack_require__(90);
-	var setInnerHTML = __webpack_require__(87);
-
-	/**
-	 * Set the textContent property of a node, ensuring that whitespace is preserved
-	 * even in IE8. innerText is a poor substitute for textContent and, among many
-	 * issues, inserts <br> instead of the literal newline chars. innerHTML behaves
-	 * as it should.
-	 *
-	 * @param {DOMElement} node
-	 * @param {string} text
-	 * @internal
-	 */
-	var setTextContent = function (node, text) {
-	  if (text) {
-	    var firstChild = node.firstChild;
-
-	    if (firstChild && firstChild === node.lastChild && firstChild.nodeType === 3) {
-	      firstChild.nodeValue = text;
-	      return;
-	    }
-	  }
-	  node.textContent = text;
-	};
-
-	if (ExecutionEnvironment.canUseDOM) {
-	  if (!('textContent' in document.documentElement)) {
-	    setTextContent = function (node, text) {
-	      if (node.nodeType === 3) {
-	        node.nodeValue = text;
-	        return;
-	      }
-	      setInnerHTML(node, escapeTextContentForBrowser(text));
-	    };
-	  }
-	}
-
-	module.exports = setTextContent;
-
-/***/ },
-/* 90 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2016-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * Based on the escape-html library, which is used under the MIT License below:
-	 *
-	 * Copyright (c) 2012-2013 TJ Holowaychuk
-	 * Copyright (c) 2015 Andreas Lubbe
-	 * Copyright (c) 2015 Tiancheng "Timothy" Gu
-	 *
-	 * Permission is hereby granted, free of charge, to any person obtaining
-	 * a copy of this software and associated documentation files (the
-	 * 'Software'), to deal in the Software without restriction, including
-	 * without limitation the rights to use, copy, modify, merge, publish,
-	 * distribute, sublicense, and/or sell copies of the Software, and to
-	 * permit persons to whom the Software is furnished to do so, subject to
-	 * the following conditions:
-	 *
-	 * The above copyright notice and this permission notice shall be
-	 * included in all copies or substantial portions of the Software.
-	 *
-	 * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-	 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-	 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-	 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-	 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-	 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-	 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-	 *
-	 */
-
-	'use strict';
-
-	// code copied and modified from escape-html
-	/**
-	 * Module variables.
-	 * @private
-	 */
-
-	var matchHtmlRegExp = /["'&<>]/;
-
-	/**
-	 * Escape special characters in the given string of html.
-	 *
-	 * @param  {string} string The string to escape for inserting into HTML
-	 * @return {string}
-	 * @public
-	 */
-
-	function escapeHtml(string) {
-	  var str = '' + string;
-	  var match = matchHtmlRegExp.exec(str);
-
-	  if (!match) {
-	    return str;
-	  }
-
-	  var escape;
-	  var html = '';
-	  var index = 0;
-	  var lastIndex = 0;
-
-	  for (index = match.index; index < str.length; index++) {
-	    switch (str.charCodeAt(index)) {
-	      case 34:
-	        // "
-	        escape = '&quot;';
-	        break;
-	      case 38:
-	        // &
-	        escape = '&amp;';
-	        break;
-	      case 39:
-	        // '
-	        escape = '&#x27;'; // modified from escape-html; used to be '&#39'
-	        break;
-	      case 60:
-	        // <
-	        escape = '&lt;';
-	        break;
-	      case 62:
-	        // >
-	        escape = '&gt;';
-	        break;
-	      default:
-	        continue;
-	    }
-
-	    if (lastIndex !== index) {
-	      html += str.substring(lastIndex, index);
-	    }
-
-	    lastIndex = index + 1;
-	    html += escape;
-	  }
-
-	  return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
-	}
-	// end code copied and modified from escape-html
-
-
-	/**
-	 * Escapes text to prevent scripting attacks.
-	 *
-	 * @param {*} text Text value to escape.
-	 * @return {string} An escaped string.
-	 */
-	function escapeTextContentForBrowser(text) {
-	  if (typeof text === 'boolean' || typeof text === 'number') {
-	    // this shortcircuit helps perf for types that we know will never have
-	    // special characters, especially given that this function is used often
-	    // for numeric dom ids.
-	    return '' + text;
-	  }
-	  return escapeHtml(text);
-	}
-
-	module.exports = escapeTextContentForBrowser;
-
-/***/ },
-/* 91 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var DOMLazyTree = __webpack_require__(85);
-	var ExecutionEnvironment = __webpack_require__(51);
-
-	var createNodesFromMarkup = __webpack_require__(92);
-	var emptyFunction = __webpack_require__(48);
-	var invariant = __webpack_require__(37);
-
-	var Danger = {
-
-	  /**
-	   * Replaces a node with a string of markup at its current position within its
-	   * parent. The markup must render into a single root node.
-	   *
-	   * @param {DOMElement} oldChild Child node to replace.
-	   * @param {string} markup Markup to render in place of the child node.
-	   * @internal
-	   */
-	  dangerouslyReplaceNodeWithMarkup: function (oldChild, markup) {
-	    !ExecutionEnvironment.canUseDOM ? process.env.NODE_ENV !== 'production' ? invariant(false, 'dangerouslyReplaceNodeWithMarkup(...): Cannot render markup in a worker thread. Make sure `window` and `document` are available globally before requiring React when unit testing or use ReactDOMServer.renderToString() for server rendering.') : _prodInvariant('56') : void 0;
-	    !markup ? process.env.NODE_ENV !== 'production' ? invariant(false, 'dangerouslyReplaceNodeWithMarkup(...): Missing markup.') : _prodInvariant('57') : void 0;
-	    !(oldChild.nodeName !== 'HTML') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'dangerouslyReplaceNodeWithMarkup(...): Cannot replace markup of the <html> node. This is because browser quirks make this unreliable and/or slow. If you want to render to the root you must use server rendering. See ReactDOMServer.renderToString().') : _prodInvariant('58') : void 0;
-
-	    if (typeof markup === 'string') {
-	      var newChild = createNodesFromMarkup(markup, emptyFunction)[0];
-	      oldChild.parentNode.replaceChild(newChild, oldChild);
-	    } else {
-	      DOMLazyTree.replaceChildWithTree(oldChild, markup);
-	    }
-	  }
-
-	};
-
-	module.exports = Danger;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 92 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * @typechecks
-	 */
-
-	/*eslint-disable fb-www/unsafe-html*/
-
-	var ExecutionEnvironment = __webpack_require__(51);
-
-	var createArrayFromMixed = __webpack_require__(93);
-	var getMarkupWrap = __webpack_require__(94);
-	var invariant = __webpack_require__(37);
-
-	/**
-	 * Dummy container used to render all markup.
-	 */
-	var dummyNode = ExecutionEnvironment.canUseDOM ? document.createElement('div') : null;
-
-	/**
-	 * Pattern used by `getNodeName`.
-	 */
-	var nodeNamePattern = /^\s*<(\w+)/;
-
-	/**
-	 * Extracts the `nodeName` of the first element in a string of markup.
-	 *
-	 * @param {string} markup String of markup.
-	 * @return {?string} Node name of the supplied markup.
-	 */
-	function getNodeName(markup) {
-	  var nodeNameMatch = markup.match(nodeNamePattern);
-	  return nodeNameMatch && nodeNameMatch[1].toLowerCase();
-	}
-
-	/**
-	 * Creates an array containing the nodes rendered from the supplied markup. The
-	 * optionally supplied `handleScript` function will be invoked once for each
-	 * <script> element that is rendered. If no `handleScript` function is supplied,
-	 * an exception is thrown if any <script> elements are rendered.
-	 *
-	 * @param {string} markup A string of valid HTML markup.
-	 * @param {?function} handleScript Invoked once for each rendered <script>.
-	 * @return {array<DOMElement|DOMTextNode>} An array of rendered nodes.
-	 */
-	function createNodesFromMarkup(markup, handleScript) {
-	  var node = dummyNode;
-	  !!!dummyNode ? process.env.NODE_ENV !== 'production' ? invariant(false, 'createNodesFromMarkup dummy not initialized') : invariant(false) : void 0;
-	  var nodeName = getNodeName(markup);
-
-	  var wrap = nodeName && getMarkupWrap(nodeName);
-	  if (wrap) {
-	    node.innerHTML = wrap[1] + markup + wrap[2];
-
-	    var wrapDepth = wrap[0];
-	    while (wrapDepth--) {
-	      node = node.lastChild;
-	    }
-	  } else {
-	    node.innerHTML = markup;
-	  }
-
-	  var scripts = node.getElementsByTagName('script');
-	  if (scripts.length) {
-	    !handleScript ? process.env.NODE_ENV !== 'production' ? invariant(false, 'createNodesFromMarkup(...): Unexpected <script> element rendered.') : invariant(false) : void 0;
-	    createArrayFromMixed(scripts).forEach(handleScript);
-	  }
-
-	  var nodes = Array.from(node.childNodes);
-	  while (node.lastChild) {
-	    node.removeChild(node.lastChild);
-	  }
-	  return nodes;
-	}
-
-	module.exports = createNodesFromMarkup;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 93 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * @typechecks
-	 */
-
-	var invariant = __webpack_require__(37);
-
-	/**
-	 * Convert array-like objects to arrays.
-	 *
-	 * This API assumes the caller knows the contents of the data type. For less
-	 * well defined inputs use createArrayFromMixed.
-	 *
-	 * @param {object|function|filelist} obj
-	 * @return {array}
-	 */
-	function toArray(obj) {
-	  var length = obj.length;
-
-	  // Some browsers builtin objects can report typeof 'function' (e.g. NodeList
-	  // in old versions of Safari).
-	  !(!Array.isArray(obj) && (typeof obj === 'object' || typeof obj === 'function')) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Array-like object expected') : invariant(false) : void 0;
-
-	  !(typeof length === 'number') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object needs a length property') : invariant(false) : void 0;
-
-	  !(length === 0 || length - 1 in obj) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object should have keys for indices') : invariant(false) : void 0;
-
-	  !(typeof obj.callee !== 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object can\'t be `arguments`. Use rest params ' + '(function(...args) {}) or Array.from() instead.') : invariant(false) : void 0;
-
-	  // Old IE doesn't give collections access to hasOwnProperty. Assume inputs
-	  // without method will throw during the slice call and skip straight to the
-	  // fallback.
-	  if (obj.hasOwnProperty) {
-	    try {
-	      return Array.prototype.slice.call(obj);
-	    } catch (e) {
-	      // IE < 9 does not support Array#slice on collections objects
-	    }
-	  }
-
-	  // Fall back to copying key by key. This assumes all keys have a value,
-	  // so will not preserve sparsely populated inputs.
-	  var ret = Array(length);
-	  for (var ii = 0; ii < length; ii++) {
-	    ret[ii] = obj[ii];
-	  }
-	  return ret;
-	}
-
-	/**
-	 * 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()).
-	 *
-	 * It will return false for other array-like objects like Filelist.
-	 *
-	 * @param {*} obj
-	 * @return {boolean}
-	 */
-	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) &&
-	    // no DOM node should be considered an array-like
-	    // a 'select' element has 'length' and 'item' properties on IE8
-	    typeof obj.nodeType != 'number' && (
-	    // a real array
-	    Array.isArray(obj) ||
-	    // arguments
-	    'callee' in obj ||
-	    // HTMLCollection/NodeList
-	    'item' in obj)
-	  );
-	}
-
-	/**
-	 * Ensure that the argument is an array by wrapping it in an array if it is not.
-	 * Creates a copy of the argument if it is already an array.
-	 *
-	 * This is mostly useful idiomatically:
-	 *
-	 *   var createArrayFromMixed = require('createArrayFromMixed');
-	 *
-	 *   function takesOneOrMoreThings(things) {
-	 *     things = createArrayFromMixed(things);
-	 *     ...
-	 *   }
-	 *
-	 * This allows you to treat `things' as an array, but accept scalars in the API.
-	 *
-	 * If you need to convert an array-like object, like `arguments`, into an array
-	 * use toArray instead.
-	 *
-	 * @param {*} obj
-	 * @return {array}
-	 */
-	function createArrayFromMixed(obj) {
-	  if (!hasArrayNature(obj)) {
-	    return [obj];
-	  } else if (Array.isArray(obj)) {
-	    return obj.slice();
-	  } else {
-	    return toArray(obj);
-	  }
-	}
-
-	module.exports = createArrayFromMixed;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 94 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	/*eslint-disable fb-www/unsafe-html */
-
-	var ExecutionEnvironment = __webpack_require__(51);
-
-	var invariant = __webpack_require__(37);
-
-	/**
-	 * Dummy container used to detect which wraps are necessary.
-	 */
-	var dummyNode = ExecutionEnvironment.canUseDOM ? document.createElement('div') : null;
-
-	/**
-	 * Some browsers cannot use `innerHTML` to render certain elements standalone,
-	 * so we wrap them, render the wrapped nodes, then extract the desired node.
-	 *
-	 * In IE8, certain elements cannot render alone, so wrap all elements ('*').
-	 */
-
-	var shouldWrap = {};
-
-	var selectWrap = [1, '<select multiple="true">', '</select>'];
-	var tableWrap = [1, '<table>', '</table>'];
-	var trWrap = [3, '<table><tbody><tr>', '</tr></tbody></table>'];
-
-	var svgWrap = [1, '<svg xmlns="http://www.w3.org/2000/svg">', '</svg>'];
-
-	var markupWrap = {
-	  '*': [1, '?<div>', '</div>'],
-
-	  'area': [1, '<map>', '</map>'],
-	  'col': [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],
-	  'legend': [1, '<fieldset>', '</fieldset>'],
-	  'param': [1, '<object>', '</object>'],
-	  'tr': [2, '<table><tbody>', '</tbody></table>'],
-
-	  'optgroup': selectWrap,
-	  'option': selectWrap,
-
-	  'caption': tableWrap,
-	  'colgroup': tableWrap,
-	  'tbody': tableWrap,
-	  'tfoot': tableWrap,
-	  'thead': tableWrap,
-
-	  'td': trWrap,
-	  'th': trWrap
-	};
-
-	// Initialize the SVG elements since we know they'll always need to be wrapped
-	// consistently. If they are created inside a <div> they will be initialized in
-	// the wrong namespace (and will not display).
-	var svgElements = ['circle', 'clipPath', 'defs', 'ellipse', 'g', 'image', 'line', 'linearGradient', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'text', 'tspan'];
-	svgElements.forEach(function (nodeName) {
-	  markupWrap[nodeName] = svgWrap;
-	  shouldWrap[nodeName] = true;
-	});
-
-	/**
-	 * Gets the markup wrap configuration for the supplied `nodeName`.
-	 *
-	 * NOTE: This lazily detects which wraps are necessary for the current browser.
-	 *
-	 * @param {string} nodeName Lowercase `nodeName`.
-	 * @return {?array} Markup wrap configuration, if applicable.
-	 */
-	function getMarkupWrap(nodeName) {
-	  !!!dummyNode ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Markup wrapping node not initialized') : invariant(false) : void 0;
-	  if (!markupWrap.hasOwnProperty(nodeName)) {
-	    nodeName = '*';
-	  }
-	  if (!shouldWrap.hasOwnProperty(nodeName)) {
-	    if (nodeName === '*') {
-	      dummyNode.innerHTML = '<link />';
-	    } else {
-	      dummyNode.innerHTML = '<' + nodeName + '></' + nodeName + '>';
-	    }
-	    shouldWrap[nodeName] = !dummyNode.firstChild;
-	  }
-	  return shouldWrap[nodeName] ? markupWrap[nodeName] : null;
-	}
-
-	module.exports = getMarkupWrap;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 95 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var DOMChildrenOperations = __webpack_require__(84);
-	var ReactDOMComponentTree = __webpack_require__(34);
-
-	/**
-	 * Operations used to process updates to DOM nodes.
-	 */
-	var ReactDOMIDOperations = {
-
-	  /**
-	   * Updates a component's children by processing a series of updates.
-	   *
-	   * @param {array<object>} updates List of update configurations.
-	   * @internal
-	   */
-	  dangerouslyProcessChildrenUpdates: function (parentInst, updates) {
-	    var node = ReactDOMComponentTree.getNodeFromInstance(parentInst);
-	    DOMChildrenOperations.processUpdates(node, updates);
-	  }
-	};
-
-	module.exports = ReactDOMIDOperations;
-
-/***/ },
-/* 96 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	/* global hasOwnProperty:true */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35),
-	    _assign = __webpack_require__(53);
-
-	var AutoFocusUtils = __webpack_require__(97);
-	var CSSPropertyOperations = __webpack_require__(99);
-	var DOMLazyTree = __webpack_require__(85);
-	var DOMNamespaces = __webpack_require__(86);
-	var DOMProperty = __webpack_require__(36);
-	var DOMPropertyOperations = __webpack_require__(107);
-	var EventPluginHub = __webpack_require__(43);
-	var EventPluginRegistry = __webpack_require__(44);
-	var ReactBrowserEventEmitter = __webpack_require__(109);
-	var ReactDOMComponentFlags = __webpack_require__(38);
-	var ReactDOMComponentTree = __webpack_require__(34);
-	var ReactDOMInput = __webpack_require__(112);
-	var ReactDOMOption = __webpack_require__(115);
-	var ReactDOMSelect = __webpack_require__(116);
-	var ReactDOMTextarea = __webpack_require__(117);
-	var ReactInstrumentation = __webpack_require__(66);
-	var ReactMultiChild = __webpack_require__(118);
-	var ReactServerRenderingTransaction = __webpack_require__(138);
-
-	var emptyFunction = __webpack_require__(48);
-	var escapeTextContentForBrowser = __webpack_require__(90);
-	var invariant = __webpack_require__(37);
-	var isEventSupported = __webpack_require__(74);
-	var shallowEqual = __webpack_require__(128);
-	var validateDOMNesting = __webpack_require__(141);
-	var warning = __webpack_require__(47);
-
-	var Flags = ReactDOMComponentFlags;
-	var deleteListener = EventPluginHub.deleteListener;
-	var getNode = ReactDOMComponentTree.getNodeFromInstance;
-	var listenTo = ReactBrowserEventEmitter.listenTo;
-	var registrationNameModules = EventPluginRegistry.registrationNameModules;
-
-	// For quickly matching children type, to test if can be treated as content.
-	var CONTENT_TYPES = { 'string': true, 'number': true };
-
-	var STYLE = 'style';
-	var HTML = '__html';
-	var RESERVED_PROPS = {
-	  children: null,
-	  dangerouslySetInnerHTML: null,
-	  suppressContentEditableWarning: null
-	};
-
-	// Node type for document fragments (Node.DOCUMENT_FRAGMENT_NODE).
-	var DOC_FRAGMENT_TYPE = 11;
-
-	function getDeclarationErrorAddendum(internalInstance) {
-	  if (internalInstance) {
-	    var owner = internalInstance._currentElement._owner || null;
-	    if (owner) {
-	      var name = owner.getName();
-	      if (name) {
-	        return ' This DOM node was rendered by `' + name + '`.';
-	      }
-	    }
-	  }
-	  return '';
-	}
-
-	function friendlyStringify(obj) {
-	  if (typeof obj === 'object') {
-	    if (Array.isArray(obj)) {
-	      return '[' + obj.map(friendlyStringify).join(', ') + ']';
-	    } else {
-	      var pairs = [];
-	      for (var key in obj) {
-	        if (Object.prototype.hasOwnProperty.call(obj, key)) {
-	          var keyEscaped = /^[a-z$_][\w$_]*$/i.test(key) ? key : JSON.stringify(key);
-	          pairs.push(keyEscaped + ': ' + friendlyStringify(obj[key]));
-	        }
-	      }
-	      return '{' + pairs.join(', ') + '}';
-	    }
-	  } else if (typeof obj === 'string') {
-	    return JSON.stringify(obj);
-	  } else if (typeof obj === 'function') {
-	    return '[function object]';
-	  }
-	  // Differs from JSON.stringify in that undefined because undefined and that
-	  // inf and nan don't become null
-	  return String(obj);
-	}
-
-	var styleMutationWarning = {};
-
-	function checkAndWarnForMutatedStyle(style1, style2, component) {
-	  if (style1 == null || style2 == null) {
-	    return;
-	  }
-	  if (shallowEqual(style1, style2)) {
-	    return;
-	  }
-
-	  var componentName = component._tag;
-	  var owner = component._currentElement._owner;
-	  var ownerName;
-	  if (owner) {
-	    ownerName = owner.getName();
-	  }
-
-	  var hash = ownerName + '|' + componentName;
-
-	  if (styleMutationWarning.hasOwnProperty(hash)) {
-	    return;
-	  }
-
-	  styleMutationWarning[hash] = true;
-
-	  process.env.NODE_ENV !== 'production' ? warning(false, '`%s` was passed a style object that has previously been mutated. ' + 'Mutating `style` is deprecated. Consider cloning it beforehand. Check ' + 'the `render` %s. Previous style: %s. Mutated style: %s.', componentName, owner ? 'of `' + ownerName + '`' : 'using <' + componentName + '>', friendlyStringify(style1), friendlyStringify(style2)) : void 0;
-	}
-
-	/**
-	 * @param {object} component
-	 * @param {?object} props
-	 */
-	function assertValidProps(component, props) {
-	  if (!props) {
-	    return;
-	  }
-	  // Note the use of `==` which checks for null or undefined.
-	  if (voidElementTags[component._tag]) {
-	    !(props.children == null && props.dangerouslySetInnerHTML == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`.%s', component._tag, component._currentElement._owner ? ' Check the render method of ' + component._currentElement._owner.getName() + '.' : '') : _prodInvariant('137', component._tag, component._currentElement._owner ? ' Check the render method of ' + component._currentElement._owner.getName() + '.' : '') : void 0;
-	  }
-	  if (props.dangerouslySetInnerHTML != null) {
-	    !(props.children == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Can only set one of `children` or `props.dangerouslySetInnerHTML`.') : _prodInvariant('60') : void 0;
-	    !(typeof props.dangerouslySetInnerHTML === 'object' && HTML in props.dangerouslySetInnerHTML) ? process.env.NODE_ENV !== 'production' ? invariant(false, '`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://fb.me/react-invariant-dangerously-set-inner-html for more information.') : _prodInvariant('61') : void 0;
-	  }
-	  if (process.env.NODE_ENV !== 'production') {
-	    process.env.NODE_ENV !== 'production' ? warning(props.innerHTML == null, 'Directly setting property `innerHTML` is not permitted. ' + 'For more information, lookup documentation on `dangerouslySetInnerHTML`.') : void 0;
-	    process.env.NODE_ENV !== 'production' ? warning(props.suppressContentEditableWarning || !props.contentEditable || props.children == null, 'A component is `contentEditable` and contains `children` managed by ' + 'React. It is now your responsibility to guarantee that none of ' + 'those nodes are unexpectedly modified or duplicated. This is ' + 'probably not intentional.') : void 0;
-	    process.env.NODE_ENV !== 'production' ? warning(props.onFocusIn == null && props.onFocusOut == null, 'React uses onFocus and onBlur instead of onFocusIn and onFocusOut. ' + 'All React events are normalized to bubble, so onFocusIn and onFocusOut ' + 'are not needed/supported by React.') : void 0;
-	  }
-	  !(props.style == null || typeof props.style === 'object') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + \'em\'}} when using JSX.%s', getDeclarationErrorAddendum(component)) : _prodInvariant('62', getDeclarationErrorAddendum(component)) : void 0;
-	}
-
-	function enqueuePutListener(inst, registrationName, listener, transaction) {
-	  if (transaction instanceof ReactServerRenderingTransaction) {
-	    return;
-	  }
-	  if (process.env.NODE_ENV !== 'production') {
-	    // IE8 has no API for event capturing and the `onScroll` event doesn't
-	    // bubble.
-	    process.env.NODE_ENV !== 'production' ? warning(registrationName !== 'onScroll' || isEventSupported('scroll', true), 'This browser doesn\'t support the `onScroll` event') : void 0;
-	  }
-	  var containerInfo = inst._hostContainerInfo;
-	  var isDocumentFragment = containerInfo._node && containerInfo._node.nodeType === DOC_FRAGMENT_TYPE;
-	  var doc = isDocumentFragment ? containerInfo._node : containerInfo._ownerDocument;
-	  listenTo(registrationName, doc);
-	  transaction.getReactMountReady().enqueue(putListener, {
-	    inst: inst,
-	    registrationName: registrationName,
-	    listener: listener
-	  });
-	}
-
-	function putListener() {
-	  var listenerToPut = this;
-	  EventPluginHub.putListener(listenerToPut.inst, listenerToPut.registrationName, listenerToPut.listener);
-	}
-
-	function inputPostMount() {
-	  var inst = this;
-	  ReactDOMInput.postMountWrapper(inst);
-	}
-
-	function textareaPostMount() {
-	  var inst = this;
-	  ReactDOMTextarea.postMountWrapper(inst);
-	}
-
-	function optionPostMount() {
-	  var inst = this;
-	  ReactDOMOption.postMountWrapper(inst);
-	}
-
-	var setAndValidateContentChildDev = emptyFunction;
-	if (process.env.NODE_ENV !== 'production') {
-	  setAndValidateContentChildDev = function (content) {
-	    var hasExistingContent = this._contentDebugID != null;
-	    var debugID = this._debugID;
-	    // This ID represents the inlined child that has no backing instance:
-	    var contentDebugID = -debugID;
-
-	    if (content == null) {
-	      if (hasExistingContent) {
-	        ReactInstrumentation.debugTool.onUnmountComponent(this._contentDebugID);
-	      }
-	      this._contentDebugID = null;
-	      return;
-	    }
-
-	    validateDOMNesting(null, String(content), this, this._ancestorInfo);
-	    this._contentDebugID = contentDebugID;
-	    if (hasExistingContent) {
-	      ReactInstrumentation.debugTool.onBeforeUpdateComponent(contentDebugID, content);
-	      ReactInstrumentation.debugTool.onUpdateComponent(contentDebugID);
-	    } else {
-	      ReactInstrumentation.debugTool.onBeforeMountComponent(contentDebugID, content, debugID);
-	      ReactInstrumentation.debugTool.onMountComponent(contentDebugID);
-	      ReactInstrumentation.debugTool.onSetChildren(debugID, [contentDebugID]);
-	    }
-	  };
-	}
-
-	// There are so many media events, it makes sense to just
-	// maintain a list rather than create a `trapBubbledEvent` for each
-	var mediaEvents = {
-	  topAbort: 'abort',
-	  topCanPlay: 'canplay',
-	  topCanPlayThrough: 'canplaythrough',
-	  topDurationChange: 'durationchange',
-	  topEmptied: 'emptied',
-	  topEncrypted: 'encrypted',
-	  topEnded: 'ended',
-	  topError: 'error',
-	  topLoadedData: 'loadeddata',
-	  topLoadedMetadata: 'loadedmetadata',
-	  topLoadStart: 'loadstart',
-	  topPause: 'pause',
-	  topPlay: 'play',
-	  topPlaying: 'playing',
-	  topProgress: 'progress',
-	  topRateChange: 'ratechange',
-	  topSeeked: 'seeked',
-	  topSeeking: 'seeking',
-	  topStalled: 'stalled',
-	  topSuspend: 'suspend',
-	  topTimeUpdate: 'timeupdate',
-	  topVolumeChange: 'volumechange',
-	  topWaiting: 'waiting'
-	};
-
-	function trapBubbledEventsLocal() {
-	  var inst = this;
-	  // If a component renders to null or if another component fatals and causes
-	  // the state of the tree to be corrupted, `node` here can be null.
-	  !inst._rootNodeID ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Must be mounted to trap events') : _prodInvariant('63') : void 0;
-	  var node = getNode(inst);
-	  !node ? process.env.NODE_ENV !== 'production' ? invariant(false, 'trapBubbledEvent(...): Requires node to be rendered.') : _prodInvariant('64') : void 0;
-
-	  switch (inst._tag) {
-	    case 'iframe':
-	    case 'object':
-	      inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent('topLoad', 'load', node)];
-	      break;
-	    case 'video':
-	    case 'audio':
-
-	      inst._wrapperState.listeners = [];
-	      // Create listener for each media event
-	      for (var event in mediaEvents) {
-	        if (mediaEvents.hasOwnProperty(event)) {
-	          inst._wrapperState.listeners.push(ReactBrowserEventEmitter.trapBubbledEvent(event, mediaEvents[event], node));
-	        }
-	      }
-	      break;
-	    case 'source':
-	      inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent('topError', 'error', node)];
-	      break;
-	    case 'img':
-	      inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent('topError', 'error', node), ReactBrowserEventEmitter.trapBubbledEvent('topLoad', 'load', node)];
-	      break;
-	    case 'form':
-	      inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent('topReset', 'reset', node), ReactBrowserEventEmitter.trapBubbledEvent('topSubmit', 'submit', node)];
-	      break;
-	    case 'input':
-	    case 'select':
-	    case 'textarea':
-	      inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent('topInvalid', 'invalid', node)];
-	      break;
-	  }
-	}
-
-	function postUpdateSelectWrapper() {
-	  ReactDOMSelect.postUpdateWrapper(this);
-	}
-
-	// For HTML, certain tags should omit their close tag. We keep a whitelist for
-	// those special-case tags.
-
-	var omittedCloseTags = {
-	  'area': true,
-	  'base': true,
-	  'br': true,
-	  'col': true,
-	  'embed': true,
-	  'hr': true,
-	  'img': true,
-	  'input': true,
-	  'keygen': true,
-	  'link': true,
-	  'meta': true,
-	  'param': true,
-	  'source': true,
-	  'track': true,
-	  'wbr': true
-	};
-
-	var newlineEatingTags = {
-	  'listing': true,
-	  'pre': true,
-	  'textarea': true
-	};
-
-	// For HTML, certain tags cannot have children. This has the same purpose as
-	// `omittedCloseTags` except that `menuitem` should still have its closing tag.
-
-	var voidElementTags = _assign({
-	  'menuitem': true
-	}, omittedCloseTags);
-
-	// We accept any tag to be rendered but since this gets injected into arbitrary
-	// HTML, we want to make sure that it's a safe tag.
-	// http://www.w3.org/TR/REC-xml/#NT-Name
-
-	var VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/; // Simplified subset
-	var validatedTagCache = {};
-	var hasOwnProperty = {}.hasOwnProperty;
-
-	function validateDangerousTag(tag) {
-	  if (!hasOwnProperty.call(validatedTagCache, tag)) {
-	    !VALID_TAG_REGEX.test(tag) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Invalid tag: %s', tag) : _prodInvariant('65', tag) : void 0;
-	    validatedTagCache[tag] = true;
-	  }
-	}
-
-	function isCustomComponent(tagName, props) {
-	  return tagName.indexOf('-') >= 0 || props.is != null;
-	}
-
-	var globalIdCounter = 1;
-
-	/**
-	 * 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.
-	 *
-	 * @constructor ReactDOMComponent
-	 * @extends ReactMultiChild
-	 */
-	function ReactDOMComponent(element) {
-	  var tag = element.type;
-	  validateDangerousTag(tag);
-	  this._currentElement = element;
-	  this._tag = tag.toLowerCase();
-	  this._namespaceURI = null;
-	  this._renderedChildren = null;
-	  this._previousStyle = null;
-	  this._previousStyleCopy = null;
-	  this._hostNode = null;
-	  this._hostParent = null;
-	  this._rootNodeID = 0;
-	  this._domID = 0;
-	  this._hostContainerInfo = null;
-	  this._wrapperState = null;
-	  this._topLevelWrapper = null;
-	  this._flags = 0;
-	  if (process.env.NODE_ENV !== 'production') {
-	    this._ancestorInfo = null;
-	    setAndValidateContentChildDev.call(this, null);
-	  }
-	}
-
-	ReactDOMComponent.displayName = 'ReactDOMComponent';
-
-	ReactDOMComponent.Mixin = {
-
-	  /**
-	   * Generates root tag markup then recurses. This method has side effects and
-	   * is not idempotent.
-	   *
-	   * @internal
-	   * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
-	   * @param {?ReactDOMComponent} the parent component instance
-	   * @param {?object} info about the host container
-	   * @param {object} context
-	   * @return {string} The computed markup.
-	   */
-	  mountComponent: function (transaction, hostParent, hostContainerInfo, context) {
-	    this._rootNodeID = globalIdCounter++;
-	    this._domID = hostContainerInfo._idCounter++;
-	    this._hostParent = hostParent;
-	    this._hostContainerInfo = hostContainerInfo;
-
-	    var props = this._currentElement.props;
-
-	    switch (this._tag) {
-	      case 'audio':
-	      case 'form':
-	      case 'iframe':
-	      case 'img':
-	      case 'link':
-	      case 'object':
-	      case 'source':
-	      case 'video':
-	        this._wrapperState = {
-	          listeners: null
-	        };
-	        transaction.getReactMountReady().enqueue(trapBubbledEventsLocal, this);
-	        break;
-	      case 'input':
-	        ReactDOMInput.mountWrapper(this, props, hostParent);
-	        props = ReactDOMInput.getHostProps(this, props);
-	        transaction.getReactMountReady().enqueue(trapBubbledEventsLocal, this);
-	        break;
-	      case 'option':
-	        ReactDOMOption.mountWrapper(this, props, hostParent);
-	        props = ReactDOMOption.getHostProps(this, props);
-	        break;
-	      case 'select':
-	        ReactDOMSelect.mountWrapper(this, props, hostParent);
-	        props = ReactDOMSelect.getHostProps(this, props);
-	        transaction.getReactMountReady().enqueue(trapBubbledEventsLocal, this);
-	        break;
-	      case 'textarea':
-	        ReactDOMTextarea.mountWrapper(this, props, hostParent);
-	        props = ReactDOMTextarea.getHostProps(this, props);
-	        transaction.getReactMountReady().enqueue(trapBubbledEventsLocal, this);
-	        break;
-	    }
-
-	    assertValidProps(this, props);
-
-	    // We create tags in the namespace of their parent container, except HTML
-	    // tags get no namespace.
-	    var namespaceURI;
-	    var parentTag;
-	    if (hostParent != null) {
-	      namespaceURI = hostParent._namespaceURI;
-	      parentTag = hostParent._tag;
-	    } else if (hostContainerInfo._tag) {
-	      namespaceURI = hostContainerInfo._namespaceURI;
-	      parentTag = hostContainerInfo._tag;
-	    }
-	    if (namespaceURI == null || namespaceURI === DOMNamespaces.svg && parentTag === 'foreignobject') {
-	      namespaceURI = DOMNamespaces.html;
-	    }
-	    if (namespaceURI === DOMNamespaces.html) {
-	      if (this._tag === 'svg') {
-	        namespaceURI = DOMNamespaces.svg;
-	      } else if (this._tag === 'math') {
-	        namespaceURI = DOMNamespaces.mathml;
-	      }
-	    }
-	    this._namespaceURI = namespaceURI;
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      var parentInfo;
-	      if (hostParent != null) {
-	        parentInfo = hostParent._ancestorInfo;
-	      } else if (hostContainerInfo._tag) {
-	        parentInfo = hostContainerInfo._ancestorInfo;
-	      }
-	      if (parentInfo) {
-	        // parentInfo should always be present except for the top-level
-	        // component when server rendering
-	        validateDOMNesting(this._tag, null, this, parentInfo);
-	      }
-	      this._ancestorInfo = validateDOMNesting.updatedAncestorInfo(parentInfo, this._tag, this);
-	    }
-
-	    var mountImage;
-	    if (transaction.useCreateElement) {
-	      var ownerDocument = hostContainerInfo._ownerDocument;
-	      var el;
-	      if (namespaceURI === DOMNamespaces.html) {
-	        if (this._tag === 'script') {
-	          // Create the script via .innerHTML so its "parser-inserted" flag is
-	          // set to true and it does not execute
-	          var div = ownerDocument.createElement('div');
-	          var type = this._currentElement.type;
-	          div.innerHTML = '<' + type + '></' + type + '>';
-	          el = div.removeChild(div.firstChild);
-	        } else if (props.is) {
-	          el = ownerDocument.createElement(this._currentElement.type, props.is);
-	        } else {
-	          // Separate else branch instead of using `props.is || undefined` above becuase of a Firefox bug.
-	          // See discussion in https://github.com/facebook/react/pull/6896
-	          // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240
-	          el = ownerDocument.createElement(this._currentElement.type);
-	        }
-	      } else {
-	        el = ownerDocument.createElementNS(namespaceURI, this._currentElement.type);
-	      }
-	      ReactDOMComponentTree.precacheNode(this, el);
-	      this._flags |= Flags.hasCachedChildNodes;
-	      if (!this._hostParent) {
-	        DOMPropertyOperations.setAttributeForRoot(el);
-	      }
-	      this._updateDOMProperties(null, props, transaction);
-	      var lazyTree = DOMLazyTree(el);
-	      this._createInitialChildren(transaction, props, context, lazyTree);
-	      mountImage = lazyTree;
-	    } else {
-	      var tagOpen = this._createOpenTagMarkupAndPutListeners(transaction, props);
-	      var tagContent = this._createContentMarkup(transaction, props, context);
-	      if (!tagContent && omittedCloseTags[this._tag]) {
-	        mountImage = tagOpen + '/>';
-	      } else {
-	        mountImage = tagOpen + '>' + tagContent + '</' + this._currentElement.type + '>';
-	      }
-	    }
-
-	    switch (this._tag) {
-	      case 'input':
-	        transaction.getReactMountReady().enqueue(inputPostMount, this);
-	        if (props.autoFocus) {
-	          transaction.getReactMountReady().enqueue(AutoFocusUtils.focusDOMComponent, this);
-	        }
-	        break;
-	      case 'textarea':
-	        transaction.getReactMountReady().enqueue(textareaPostMount, this);
-	        if (props.autoFocus) {
-	          transaction.getReactMountReady().enqueue(AutoFocusUtils.focusDOMComponent, this);
-	        }
-	        break;
-	      case 'select':
-	        if (props.autoFocus) {
-	          transaction.getReactMountReady().enqueue(AutoFocusUtils.focusDOMComponent, this);
-	        }
-	        break;
-	      case 'button':
-	        if (props.autoFocus) {
-	          transaction.getReactMountReady().enqueue(AutoFocusUtils.focusDOMComponent, this);
-	        }
-	        break;
-	      case 'option':
-	        transaction.getReactMountReady().enqueue(optionPostMount, this);
-	        break;
-	    }
-
-	    return mountImage;
-	  },
-
-	  /**
-	   * 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
-	   * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
-	   * @param {object} props
-	   * @return {string} Markup of opening tag.
-	   */
-	  _createOpenTagMarkupAndPutListeners: function (transaction, props) {
-	    var ret = '<' + this._currentElement.type;
-
-	    for (var propKey in props) {
-	      if (!props.hasOwnProperty(propKey)) {
-	        continue;
-	      }
-	      var propValue = props[propKey];
-	      if (propValue == null) {
-	        continue;
-	      }
-	      if (registrationNameModules.hasOwnProperty(propKey)) {
-	        if (propValue) {
-	          enqueuePutListener(this, propKey, propValue, transaction);
-	        }
-	      } else {
-	        if (propKey === STYLE) {
-	          if (propValue) {
-	            if (process.env.NODE_ENV !== 'production') {
-	              // See `_updateDOMProperties`. style block
-	              this._previousStyle = propValue;
-	            }
-	            propValue = this._previousStyleCopy = _assign({}, props.style);
-	          }
-	          propValue = CSSPropertyOperations.createMarkupForStyles(propValue, this);
-	        }
-	        var markup = null;
-	        if (this._tag != null && isCustomComponent(this._tag, props)) {
-	          if (!RESERVED_PROPS.hasOwnProperty(propKey)) {
-	            markup = DOMPropertyOperations.createMarkupForCustomAttribute(propKey, propValue);
-	          }
-	        } else {
-	          markup = DOMPropertyOperations.createMarkupForProperty(propKey, propValue);
-	        }
-	        if (markup) {
-	          ret += ' ' + markup;
-	        }
-	      }
-	    }
-
-	    // For static pages, no need to put React ID and checksum. Saves lots of
-	    // bytes.
-	    if (transaction.renderToStaticMarkup) {
-	      return ret;
-	    }
-
-	    if (!this._hostParent) {
-	      ret += ' ' + DOMPropertyOperations.createMarkupForRoot();
-	    }
-	    ret += ' ' + DOMPropertyOperations.createMarkupForID(this._domID);
-	    return ret;
-	  },
-
-	  /**
-	   * Creates markup for the content between the tags.
-	   *
-	   * @private
-	   * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
-	   * @param {object} props
-	   * @param {object} context
-	   * @return {string} Content markup.
-	   */
-	  _createContentMarkup: function (transaction, props, context) {
-	    var ret = '';
-
-	    // Intentional use of != to avoid catching zero/false.
-	    var innerHTML = props.dangerouslySetInnerHTML;
-	    if (innerHTML != null) {
-	      if (innerHTML.__html != null) {
-	        ret = innerHTML.__html;
-	      }
-	    } else {
-	      var contentToUse = CONTENT_TYPES[typeof props.children] ? props.children : null;
-	      var childrenToUse = contentToUse != null ? null : props.children;
-	      if (contentToUse != null) {
-	        // TODO: Validate that text is allowed as a child of this node
-	        ret = escapeTextContentForBrowser(contentToUse);
-	        if (process.env.NODE_ENV !== 'production') {
-	          setAndValidateContentChildDev.call(this, contentToUse);
-	        }
-	      } else if (childrenToUse != null) {
-	        var mountImages = this.mountChildren(childrenToUse, transaction, context);
-	        ret = mountImages.join('');
-	      }
-	    }
-	    if (newlineEatingTags[this._tag] && ret.charAt(0) === '\n') {
-	      // text/html ignores the first character in these tags if it's a newline
-	      // Prefer to break application/xml over text/html (for now) by adding
-	      // a newline specifically to get eaten by the parser. (Alternately for
-	      // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first
-	      // \r is normalized out by HTMLTextAreaElement#value.)
-	      // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>
-	      // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>
-	      // See: <http://www.w3.org/TR/html5/syntax.html#newlines>
-	      // See: Parsing of "textarea" "listing" and "pre" elements
-	      //  from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>
-	      return '\n' + ret;
-	    } else {
-	      return ret;
-	    }
-	  },
-
-	  _createInitialChildren: function (transaction, props, context, lazyTree) {
-	    // Intentional use of != to avoid catching zero/false.
-	    var innerHTML = props.dangerouslySetInnerHTML;
-	    if (innerHTML != null) {
-	      if (innerHTML.__html != null) {
-	        DOMLazyTree.queueHTML(lazyTree, innerHTML.__html);
-	      }
-	    } else {
-	      var contentToUse = CONTENT_TYPES[typeof props.children] ? props.children : null;
-	      var childrenToUse = contentToUse != null ? null : props.children;
-	      if (contentToUse != null) {
-	        // TODO: Validate that text is allowed as a child of this node
-	        if (process.env.NODE_ENV !== 'production') {
-	          setAndValidateContentChildDev.call(this, contentToUse);
-	        }
-	        DOMLazyTree.queueText(lazyTree, contentToUse);
-	      } else if (childrenToUse != null) {
-	        var mountImages = this.mountChildren(childrenToUse, transaction, context);
-	        for (var i = 0; i < mountImages.length; i++) {
-	          DOMLazyTree.queueChild(lazyTree, mountImages[i]);
-	        }
-	      }
-	    }
-	  },
-
-	  /**
-	   * Receives a next element and updates the component.
-	   *
-	   * @internal
-	   * @param {ReactElement} nextElement
-	   * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
-	   * @param {object} context
-	   */
-	  receiveComponent: function (nextElement, transaction, context) {
-	    var prevElement = this._currentElement;
-	    this._currentElement = nextElement;
-	    this.updateComponent(transaction, prevElement, nextElement, context);
-	  },
-
-	  /**
-	   * Updates a DOM component after it has already been allocated and
-	   * attached to the DOM. Reconciles the root DOM node, then recurses.
-	   *
-	   * @param {ReactReconcileTransaction} transaction
-	   * @param {ReactElement} prevElement
-	   * @param {ReactElement} nextElement
-	   * @internal
-	   * @overridable
-	   */
-	  updateComponent: function (transaction, prevElement, nextElement, context) {
-	    var lastProps = prevElement.props;
-	    var nextProps = this._currentElement.props;
-
-	    switch (this._tag) {
-	      case 'input':
-	        lastProps = ReactDOMInput.getHostProps(this, lastProps);
-	        nextProps = ReactDOMInput.getHostProps(this, nextProps);
-	        break;
-	      case 'option':
-	        lastProps = ReactDOMOption.getHostProps(this, lastProps);
-	        nextProps = ReactDOMOption.getHostProps(this, nextProps);
-	        break;
-	      case 'select':
-	        lastProps = ReactDOMSelect.getHostProps(this, lastProps);
-	        nextProps = ReactDOMSelect.getHostProps(this, nextProps);
-	        break;
-	      case 'textarea':
-	        lastProps = ReactDOMTextarea.getHostProps(this, lastProps);
-	        nextProps = ReactDOMTextarea.getHostProps(this, nextProps);
-	        break;
-	    }
-
-	    assertValidProps(this, nextProps);
-	    this._updateDOMProperties(lastProps, nextProps, transaction);
-	    this._updateDOMChildren(lastProps, nextProps, transaction, context);
-
-	    switch (this._tag) {
-	      case 'input':
-	        // Update the wrapper around inputs *after* updating props. This has to
-	        // happen after `_updateDOMProperties`. Otherwise HTML5 input validations
-	        // raise warnings and prevent the new value from being assigned.
-	        ReactDOMInput.updateWrapper(this);
-	        break;
-	      case 'textarea':
-	        ReactDOMTextarea.updateWrapper(this);
-	        break;
-	      case 'select':
-	        // <select> value update needs to occur after <option> children
-	        // reconciliation
-	        transaction.getReactMountReady().enqueue(postUpdateSelectWrapper, this);
-	        break;
-	    }
-	  },
-
-	  /**
-	   * 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} lastProps
-	   * @param {object} nextProps
-	   * @param {?DOMElement} node
-	   */
-	  _updateDOMProperties: function (lastProps, nextProps, transaction) {
-	    var propKey;
-	    var styleName;
-	    var styleUpdates;
-	    for (propKey in lastProps) {
-	      if (nextProps.hasOwnProperty(propKey) || !lastProps.hasOwnProperty(propKey) || lastProps[propKey] == null) {
-	        continue;
-	      }
-	      if (propKey === STYLE) {
-	        var lastStyle = this._previousStyleCopy;
-	        for (styleName in lastStyle) {
-	          if (lastStyle.hasOwnProperty(styleName)) {
-	            styleUpdates = styleUpdates || {};
-	            styleUpdates[styleName] = '';
-	          }
-	        }
-	        this._previousStyleCopy = null;
-	      } else if (registrationNameModules.hasOwnProperty(propKey)) {
-	        if (lastProps[propKey]) {
-	          // Only call deleteListener if there was a listener previously or
-	          // else willDeleteListener gets called when there wasn't actually a
-	          // listener (e.g., onClick={null})
-	          deleteListener(this, propKey);
-	        }
-	      } else if (isCustomComponent(this._tag, lastProps)) {
-	        if (!RESERVED_PROPS.hasOwnProperty(propKey)) {
-	          DOMPropertyOperations.deleteValueForAttribute(getNode(this), propKey);
-	        }
-	      } else if (DOMProperty.properties[propKey] || DOMProperty.isCustomAttribute(propKey)) {
-	        DOMPropertyOperations.deleteValueForProperty(getNode(this), propKey);
-	      }
-	    }
-	    for (propKey in nextProps) {
-	      var nextProp = nextProps[propKey];
-	      var lastProp = propKey === STYLE ? this._previousStyleCopy : lastProps != null ? lastProps[propKey] : undefined;
-	      if (!nextProps.hasOwnProperty(propKey) || nextProp === lastProp || nextProp == null && lastProp == null) {
-	        continue;
-	      }
-	      if (propKey === STYLE) {
-	        if (nextProp) {
-	          if (process.env.NODE_ENV !== 'production') {
-	            checkAndWarnForMutatedStyle(this._previousStyleCopy, this._previousStyle, this);
-	            this._previousStyle = nextProp;
-	          }
-	          nextProp = this._previousStyleCopy = _assign({}, nextProp);
-	        } else {
-	          this._previousStyleCopy = null;
-	        }
-	        if (lastProp) {
-	          // Unset styles on `lastProp` but not on `nextProp`.
-	          for (styleName in lastProp) {
-	            if (lastProp.hasOwnProperty(styleName) && (!nextProp || !nextProp.hasOwnProperty(styleName))) {
-	              styleUpdates = styleUpdates || {};
-	              styleUpdates[styleName] = '';
-	            }
-	          }
-	          // Update styles that changed since `lastProp`.
-	          for (styleName in nextProp) {
-	            if (nextProp.hasOwnProperty(styleName) && lastProp[styleName] !== nextProp[styleName]) {
-	              styleUpdates = styleUpdates || {};
-	              styleUpdates[styleName] = nextProp[styleName];
-	            }
-	          }
-	        } else {
-	          // Relies on `updateStylesByID` not mutating `styleUpdates`.
-	          styleUpdates = nextProp;
-	        }
-	      } else if (registrationNameModules.hasOwnProperty(propKey)) {
-	        if (nextProp) {
-	          enqueuePutListener(this, propKey, nextProp, transaction);
-	        } else if (lastProp) {
-	          deleteListener(this, propKey);
-	        }
-	      } else if (isCustomComponent(this._tag, nextProps)) {
-	        if (!RESERVED_PROPS.hasOwnProperty(propKey)) {
-	          DOMPropertyOperations.setValueForAttribute(getNode(this), propKey, nextProp);
-	        }
-	      } else if (DOMProperty.properties[propKey] || DOMProperty.isCustomAttribute(propKey)) {
-	        var node = getNode(this);
-	        // If we're updating to null or undefined, we should remove the property
-	        // from the DOM node instead of inadvertently setting to a string. This
-	        // brings us in line with the same behavior we have on initial render.
-	        if (nextProp != null) {
-	          DOMPropertyOperations.setValueForProperty(node, propKey, nextProp);
-	        } else {
-	          DOMPropertyOperations.deleteValueForProperty(node, propKey);
-	        }
-	      }
-	    }
-	    if (styleUpdates) {
-	      CSSPropertyOperations.setValueForStyles(getNode(this), styleUpdates, this);
-	    }
-	  },
-
-	  /**
-	   * Reconciles the children with the various properties that affect the
-	   * children content.
-	   *
-	   * @param {object} lastProps
-	   * @param {object} nextProps
-	   * @param {ReactReconcileTransaction} transaction
-	   * @param {object} context
-	   */
-	  _updateDOMChildren: function (lastProps, nextProps, transaction, context) {
-	    var lastContent = CONTENT_TYPES[typeof lastProps.children] ? lastProps.children : null;
-	    var nextContent = CONTENT_TYPES[typeof nextProps.children] ? nextProps.children : null;
-
-	    var lastHtml = lastProps.dangerouslySetInnerHTML && lastProps.dangerouslySetInnerHTML.__html;
-	    var nextHtml = nextProps.dangerouslySetInnerHTML && nextProps.dangerouslySetInnerHTML.__html;
-
-	    // Note the use of `!=` which checks for null or undefined.
-	    var lastChildren = lastContent != null ? null : lastProps.children;
-	    var nextChildren = nextContent != null ? null : nextProps.children;
-
-	    // If we're switching from children to content/html or vice versa, remove
-	    // the old content
-	    var lastHasContentOrHtml = lastContent != null || lastHtml != null;
-	    var nextHasContentOrHtml = nextContent != null || nextHtml != null;
-	    if (lastChildren != null && nextChildren == null) {
-	      this.updateChildren(null, transaction, context);
-	    } else if (lastHasContentOrHtml && !nextHasContentOrHtml) {
-	      this.updateTextContent('');
-	      if (process.env.NODE_ENV !== 'production') {
-	        ReactInstrumentation.debugTool.onSetChildren(this._debugID, []);
-	      }
-	    }
-
-	    if (nextContent != null) {
-	      if (lastContent !== nextContent) {
-	        this.updateTextContent('' + nextContent);
-	        if (process.env.NODE_ENV !== 'production') {
-	          setAndValidateContentChildDev.call(this, nextContent);
-	        }
-	      }
-	    } else if (nextHtml != null) {
-	      if (lastHtml !== nextHtml) {
-	        this.updateMarkup('' + nextHtml);
-	      }
-	      if (process.env.NODE_ENV !== 'production') {
-	        ReactInstrumentation.debugTool.onSetChildren(this._debugID, []);
-	      }
-	    } else if (nextChildren != null) {
-	      if (process.env.NODE_ENV !== 'production') {
-	        setAndValidateContentChildDev.call(this, null);
-	      }
-
-	      this.updateChildren(nextChildren, transaction, context);
-	    }
-	  },
-
-	  getHostNode: function () {
-	    return getNode(this);
-	  },
-
-	  /**
-	   * Destroys all event registrations for this instance. Does not remove from
-	   * the DOM. That must be done by the parent.
-	   *
-	   * @internal
-	   */
-	  unmountComponent: function (safely) {
-	    switch (this._tag) {
-	      case 'audio':
-	      case 'form':
-	      case 'iframe':
-	      case 'img':
-	      case 'link':
-	      case 'object':
-	      case 'source':
-	      case 'video':
-	        var listeners = this._wrapperState.listeners;
-	        if (listeners) {
-	          for (var i = 0; i < listeners.length; i++) {
-	            listeners[i].remove();
-	          }
-	        }
-	        break;
-	      case 'html':
-	      case 'head':
-	      case 'body':
-	        /**
-	         * Components like <html> <head> and <body> can't be removed or added
-	         * easily in a cross-browser way, however it's valuable to be able to
-	         * take advantage of React's reconciliation for styling and <title>
-	         * management. So we just document it and throw in dangerous cases.
-	         */
-	         true ? process.env.NODE_ENV !== 'production' ? invariant(false, '<%s> tried to unmount. Because of cross-browser quirks it is impossible to unmount some top-level components (eg <html>, <head>, and <body>) reliably and efficiently. To fix this, have a single top-level component that never unmounts render these elements.', this._tag) : _prodInvariant('66', this._tag) : void 0;
-	        break;
-	    }
-
-	    this.unmountChildren(safely);
-	    ReactDOMComponentTree.uncacheNode(this);
-	    EventPluginHub.deleteAllListeners(this);
-	    this._rootNodeID = 0;
-	    this._domID = 0;
-	    this._wrapperState = null;
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      setAndValidateContentChildDev.call(this, null);
-	    }
-	  },
-
-	  getPublicInstance: function () {
-	    return getNode(this);
-	  }
-
-	};
-
-	_assign(ReactDOMComponent.prototype, ReactDOMComponent.Mixin, ReactMultiChild.Mixin);
-
-	module.exports = ReactDOMComponent;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 97 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ReactDOMComponentTree = __webpack_require__(34);
-
-	var focusNode = __webpack_require__(98);
-
-	var AutoFocusUtils = {
-	  focusDOMComponent: function () {
-	    focusNode(ReactDOMComponentTree.getNodeFromInstance(this));
-	  }
-	};
-
-	module.exports = AutoFocusUtils;
-
-/***/ },
-/* 98 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	/**
-	 * @param {DOMElement} node input/textarea to focus
-	 */
-
-	function focusNode(node) {
-	  // IE8 can throw "Can't move focus to the control because it is invisible,
-	  // not enabled, or of a type that does not accept the focus." for all kinds of
-	  // reasons that are too expensive and fragile to test.
-	  try {
-	    node.focus();
-	  } catch (e) {}
-	}
-
-	module.exports = focusNode;
-
-/***/ },
-/* 99 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var CSSProperty = __webpack_require__(100);
-	var ExecutionEnvironment = __webpack_require__(51);
-	var ReactInstrumentation = __webpack_require__(66);
-
-	var camelizeStyleName = __webpack_require__(101);
-	var dangerousStyleValue = __webpack_require__(103);
-	var hyphenateStyleName = __webpack_require__(104);
-	var memoizeStringOnly = __webpack_require__(106);
-	var warning = __webpack_require__(47);
-
-	var processStyleName = memoizeStringOnly(function (styleName) {
-	  return hyphenateStyleName(styleName);
-	});
-
-	var hasShorthandPropertyBug = false;
-	var styleFloatAccessor = 'cssFloat';
-	if (ExecutionEnvironment.canUseDOM) {
-	  var tempStyle = document.createElement('div').style;
-	  try {
-	    // IE8 throws "Invalid argument." if resetting shorthand style properties.
-	    tempStyle.font = '';
-	  } catch (e) {
-	    hasShorthandPropertyBug = true;
-	  }
-	  // IE8 only supports accessing cssFloat (standard) as styleFloat
-	  if (document.documentElement.style.cssFloat === undefined) {
-	    styleFloatAccessor = 'styleFloat';
-	  }
-	}
-
-	if (process.env.NODE_ENV !== 'production') {
-	  // 'msTransform' is correct, but the other prefixes should be capitalized
-	  var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;
-
-	  // style values shouldn't contain a semicolon
-	  var badStyleValueWithSemicolonPattern = /;\s*$/;
-
-	  var warnedStyleNames = {};
-	  var warnedStyleValues = {};
-	  var warnedForNaNValue = false;
-
-	  var warnHyphenatedStyleName = function (name, owner) {
-	    if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
-	      return;
-	    }
-
-	    warnedStyleNames[name] = true;
-	    process.env.NODE_ENV !== 'production' ? warning(false, 'Unsupported style property %s. Did you mean %s?%s', name, camelizeStyleName(name), checkRenderMessage(owner)) : void 0;
-	  };
-
-	  var warnBadVendoredStyleName = function (name, owner) {
-	    if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
-	      return;
-	    }
-
-	    warnedStyleNames[name] = true;
-	    process.env.NODE_ENV !== 'production' ? warning(false, 'Unsupported vendor-prefixed style property %s. Did you mean %s?%s', name, name.charAt(0).toUpperCase() + name.slice(1), checkRenderMessage(owner)) : void 0;
-	  };
-
-	  var warnStyleValueWithSemicolon = function (name, value, owner) {
-	    if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {
-	      return;
-	    }
-
-	    warnedStyleValues[value] = true;
-	    process.env.NODE_ENV !== 'production' ? warning(false, 'Style property values shouldn\'t contain a semicolon.%s ' + 'Try "%s: %s" instead.', checkRenderMessage(owner), name, value.replace(badStyleValueWithSemicolonPattern, '')) : void 0;
-	  };
-
-	  var warnStyleValueIsNaN = function (name, value, owner) {
-	    if (warnedForNaNValue) {
-	      return;
-	    }
-
-	    warnedForNaNValue = true;
-	    process.env.NODE_ENV !== 'production' ? warning(false, '`NaN` is an invalid value for the `%s` css style property.%s', name, checkRenderMessage(owner)) : void 0;
-	  };
-
-	  var checkRenderMessage = function (owner) {
-	    if (owner) {
-	      var name = owner.getName();
-	      if (name) {
-	        return ' Check the render method of `' + name + '`.';
-	      }
-	    }
-	    return '';
-	  };
-
-	  /**
-	   * @param {string} name
-	   * @param {*} value
-	   * @param {ReactDOMComponent} component
-	   */
-	  var warnValidStyle = function (name, value, component) {
-	    var owner;
-	    if (component) {
-	      owner = component._currentElement._owner;
-	    }
-	    if (name.indexOf('-') > -1) {
-	      warnHyphenatedStyleName(name, owner);
-	    } else if (badVendoredStyleNamePattern.test(name)) {
-	      warnBadVendoredStyleName(name, owner);
-	    } else if (badStyleValueWithSemicolonPattern.test(value)) {
-	      warnStyleValueWithSemicolon(name, value, owner);
-	    }
-
-	    if (typeof value === 'number' && isNaN(value)) {
-	      warnStyleValueIsNaN(name, value, owner);
-	    }
-	  };
-	}
-
-	/**
-	 * 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.
-	   * The result should be HTML-escaped before insertion into the DOM.
-	   *
-	   * @param {object} styles
-	   * @param {ReactDOMComponent} component
-	   * @return {?string}
-	   */
-	  createMarkupForStyles: function (styles, component) {
-	    var serialized = '';
-	    for (var styleName in styles) {
-	      if (!styles.hasOwnProperty(styleName)) {
-	        continue;
-	      }
-	      var styleValue = styles[styleName];
-	      if (process.env.NODE_ENV !== 'production') {
-	        warnValidStyle(styleName, styleValue, component);
-	      }
-	      if (styleValue != null) {
-	        serialized += processStyleName(styleName) + ':';
-	        serialized += dangerousStyleValue(styleName, styleValue, component) + ';';
-	      }
-	    }
-	    return serialized || null;
-	  },
-
-	  /**
-	   * Sets the value for multiple styles on a node.  If a value is specified as
-	   * '' (empty string), the corresponding style property will be unset.
-	   *
-	   * @param {DOMElement} node
-	   * @param {object} styles
-	   * @param {ReactDOMComponent} component
-	   */
-	  setValueForStyles: function (node, styles, component) {
-	    if (process.env.NODE_ENV !== 'production') {
-	      ReactInstrumentation.debugTool.onHostOperation({
-	        instanceID: component._debugID,
-	        type: 'update styles',
-	        payload: styles
-	      });
-	    }
-
-	    var style = node.style;
-	    for (var styleName in styles) {
-	      if (!styles.hasOwnProperty(styleName)) {
-	        continue;
-	      }
-	      if (process.env.NODE_ENV !== 'production') {
-	        warnValidStyle(styleName, styles[styleName], component);
-	      }
-	      var styleValue = dangerousStyleValue(styleName, styles[styleName], component);
-	      if (styleName === 'float' || styleName === 'cssFloat') {
-	        styleName = styleFloatAccessor;
-	      }
-	      if (styleValue) {
-	        style[styleName] = styleValue;
-	      } else {
-	        var expansion = hasShorthandPropertyBug && CSSProperty.shorthandPropertyExpansions[styleName];
-	        if (expansion) {
-	          // Shorthand property that IE8 won't like unsetting, so unset each
-	          // component to placate it
-	          for (var individualStyleName in expansion) {
-	            style[individualStyleName] = '';
-	          }
-	        } else {
-	          style[styleName] = '';
-	        }
-	      }
-	    }
-	  }
-
-	};
-
-	module.exports = CSSPropertyOperations;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 100 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	/**
-	 * CSS properties which accept numbers but are not in units of "px".
-	 */
-
-	var isUnitlessNumber = {
-	  animationIterationCount: true,
-	  borderImageOutset: true,
-	  borderImageSlice: true,
-	  borderImageWidth: true,
-	  boxFlex: true,
-	  boxFlexGroup: true,
-	  boxOrdinalGroup: true,
-	  columnCount: true,
-	  flex: true,
-	  flexGrow: true,
-	  flexPositive: true,
-	  flexShrink: true,
-	  flexNegative: true,
-	  flexOrder: true,
-	  gridRow: true,
-	  gridColumn: true,
-	  fontWeight: true,
-	  lineClamp: true,
-	  lineHeight: true,
-	  opacity: true,
-	  order: true,
-	  orphans: true,
-	  tabSize: true,
-	  widows: true,
-	  zIndex: true,
-	  zoom: true,
-
-	  // SVG-related properties
-	  fillOpacity: true,
-	  floodOpacity: true,
-	  stopOpacity: true,
-	  strokeDasharray: true,
-	  strokeDashoffset: true,
-	  strokeMiterlimit: true,
-	  strokeOpacity: true,
-	  strokeWidth: true
-	};
-
-	/**
-	 * @param {string} prefix vendor-specific prefix, eg: Webkit
-	 * @param {string} key style name, eg: transitionDuration
-	 * @return {string} style name prefixed with `prefix`, properly camelCased, eg:
-	 * WebkitTransitionDuration
-	 */
-	function prefixKey(prefix, key) {
-	  return prefix + key.charAt(0).toUpperCase() + key.substring(1);
-	}
-
-	/**
-	 * Support style names that may come passed in prefixed by adding permutations
-	 * of vendor prefixes.
-	 */
-	var prefixes = ['Webkit', 'ms', 'Moz', 'O'];
-
-	// Using Object.keys here, or else the vanilla for-in loop makes IE8 go into an
-	// infinite loop, because it iterates over the newly added props too.
-	Object.keys(isUnitlessNumber).forEach(function (prop) {
-	  prefixes.forEach(function (prefix) {
-	    isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];
-	  });
-	});
-
-	/**
-	 * Most style properties can be unset by doing .style[prop] = '' but IE8
-	 * doesn't like doing that with shorthand properties so for the properties that
-	 * IE8 breaks on, which are listed here, we instead unset each of the
-	 * individual properties. See http://bugs.jquery.com/ticket/12385.
-	 * The 4-value 'clock' properties like margin, padding, border-width seem to
-	 * behave without any problems. Curiously, list-style works too without any
-	 * special prodding.
-	 */
-	var shorthandPropertyExpansions = {
-	  background: {
-	    backgroundAttachment: true,
-	    backgroundColor: true,
-	    backgroundImage: true,
-	    backgroundPositionX: true,
-	    backgroundPositionY: true,
-	    backgroundRepeat: true
-	  },
-	  backgroundPosition: {
-	    backgroundPositionX: true,
-	    backgroundPositionY: true
-	  },
-	  border: {
-	    borderWidth: true,
-	    borderStyle: true,
-	    borderColor: true
-	  },
-	  borderBottom: {
-	    borderBottomWidth: true,
-	    borderBottomStyle: true,
-	    borderBottomColor: true
-	  },
-	  borderLeft: {
-	    borderLeftWidth: true,
-	    borderLeftStyle: true,
-	    borderLeftColor: true
-	  },
-	  borderRight: {
-	    borderRightWidth: true,
-	    borderRightStyle: true,
-	    borderRightColor: true
-	  },
-	  borderTop: {
-	    borderTopWidth: true,
-	    borderTopStyle: true,
-	    borderTopColor: true
-	  },
-	  font: {
-	    fontStyle: true,
-	    fontVariant: true,
-	    fontWeight: true,
-	    fontSize: true,
-	    lineHeight: true,
-	    fontFamily: true
-	  },
-	  outline: {
-	    outlineWidth: true,
-	    outlineStyle: true,
-	    outlineColor: true
-	  }
-	};
-
-	var CSSProperty = {
-	  isUnitlessNumber: isUnitlessNumber,
-	  shorthandPropertyExpansions: shorthandPropertyExpansions
-	};
-
-	module.exports = CSSProperty;
-
-/***/ },
-/* 101 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * @typechecks
-	 */
-
-	'use strict';
-
-	var camelize = __webpack_require__(102);
-
-	var msPattern = /^-ms-/;
-
-	/**
-	 * Camelcases a hyphenated CSS property name, for example:
-	 *
-	 *   > camelizeStyleName('background-color')
-	 *   < "backgroundColor"
-	 *   > camelizeStyleName('-moz-transition')
-	 *   < "MozTransition"
-	 *   > camelizeStyleName('-ms-transition')
-	 *   < "msTransition"
-	 *
-	 * As Andi Smith suggests
-	 * (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix
-	 * is converted to lowercase `ms`.
-	 *
-	 * @param {string} string
-	 * @return {string}
-	 */
-	function camelizeStyleName(string) {
-	  return camelize(string.replace(msPattern, 'ms-'));
-	}
-
-	module.exports = camelizeStyleName;
-
-/***/ },
-/* 102 */
-/***/ function(module, exports) {
-
-	"use strict";
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * @typechecks
-	 */
-
-	var _hyphenPattern = /-(.)/g;
-
-	/**
-	 * Camelcases a hyphenated string, for example:
-	 *
-	 *   > camelize('background-color')
-	 *   < "backgroundColor"
-	 *
-	 * @param {string} string
-	 * @return {string}
-	 */
-	function camelize(string) {
-	  return string.replace(_hyphenPattern, function (_, character) {
-	    return character.toUpperCase();
-	  });
-	}
-
-	module.exports = camelize;
-
-/***/ },
-/* 103 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var CSSProperty = __webpack_require__(100);
-	var warning = __webpack_require__(47);
-
-	var isUnitlessNumber = CSSProperty.isUnitlessNumber;
-	var styleWarnings = {};
-
-	/**
-	 * Convert a value into the proper css writable value. The style name `name`
-	 * should be logical (no hyphens), as specified
-	 * in `CSSProperty.isUnitlessNumber`.
-	 *
-	 * @param {string} name CSS property name such as `topMargin`.
-	 * @param {*} value CSS property value such as `10px`.
-	 * @param {ReactDOMComponent} component
-	 * @return {string} Normalized style value with dimensions applied.
-	 */
-	function dangerousStyleValue(name, value, component) {
-	  // 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
-
-	  var isEmpty = value == null || typeof value === 'boolean' || value === '';
-	  if (isEmpty) {
-	    return '';
-	  }
-
-	  var isNonNumeric = isNaN(value);
-	  if (isNonNumeric || value === 0 || isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name]) {
-	    return '' + value; // cast to string
-	  }
-
-	  if (typeof value === 'string') {
-	    if (process.env.NODE_ENV !== 'production') {
-	      // Allow '0' to pass through without warning. 0 is already special and
-	      // doesn't require units, so we don't need to warn about it.
-	      if (component && value !== '0') {
-	        var owner = component._currentElement._owner;
-	        var ownerName = owner ? owner.getName() : null;
-	        if (ownerName && !styleWarnings[ownerName]) {
-	          styleWarnings[ownerName] = {};
-	        }
-	        var warned = false;
-	        if (ownerName) {
-	          var warnings = styleWarnings[ownerName];
-	          warned = warnings[name];
-	          if (!warned) {
-	            warnings[name] = true;
-	          }
-	        }
-	        if (!warned) {
-	          process.env.NODE_ENV !== 'production' ? warning(false, 'a `%s` tag (owner: `%s`) was passed a numeric string value ' + 'for CSS property `%s` (value: `%s`) which will be treated ' + 'as a unitless number in a future version of React.', component._currentElement.type, ownerName || 'unknown', name, value) : void 0;
-	        }
-	      }
-	    }
-	    value = value.trim();
-	  }
-	  return value + 'px';
-	}
-
-	module.exports = dangerousStyleValue;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 104 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * @typechecks
-	 */
-
-	'use strict';
-
-	var hyphenate = __webpack_require__(105);
-
-	var msPattern = /^ms-/;
-
-	/**
-	 * Hyphenates a camelcased CSS property name, for example:
-	 *
-	 *   > hyphenateStyleName('backgroundColor')
-	 *   < "background-color"
-	 *   > hyphenateStyleName('MozTransition')
-	 *   < "-moz-transition"
-	 *   > hyphenateStyleName('msTransition')
-	 *   < "-ms-transition"
-	 *
-	 * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
-	 * is converted to `-ms-`.
-	 *
-	 * @param {string} string
-	 * @return {string}
-	 */
-	function hyphenateStyleName(string) {
-	  return hyphenate(string).replace(msPattern, '-ms-');
-	}
-
-	module.exports = hyphenateStyleName;
-
-/***/ },
-/* 105 */
-/***/ function(module, exports) {
-
-	'use strict';
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * @typechecks
-	 */
-
-	var _uppercasePattern = /([A-Z])/g;
-
-	/**
-	 * Hyphenates a camelcased string, for example:
-	 *
-	 *   > hyphenate('backgroundColor')
-	 *   < "background-color"
-	 *
-	 * For CSS style names, use `hyphenateStyleName` instead which works properly
-	 * with all vendor prefixes, including `ms`.
-	 *
-	 * @param {string} string
-	 * @return {string}
-	 */
-	function hyphenate(string) {
-	  return string.replace(_uppercasePattern, '-$1').toLowerCase();
-	}
-
-	module.exports = hyphenate;
-
-/***/ },
-/* 106 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 * @typechecks static-only
-	 */
-
-	'use strict';
-
-	/**
-	 * Memoizes the return value of a function that accepts one string argument.
-	 */
-
-	function memoizeStringOnly(callback) {
-	  var cache = {};
-	  return function (string) {
-	    if (!cache.hasOwnProperty(string)) {
-	      cache[string] = callback.call(this, string);
-	    }
-	    return cache[string];
-	  };
-	}
-
-	module.exports = memoizeStringOnly;
-
-/***/ },
-/* 107 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var DOMProperty = __webpack_require__(36);
-	var ReactDOMComponentTree = __webpack_require__(34);
-	var ReactInstrumentation = __webpack_require__(66);
-
-	var quoteAttributeValueForBrowser = __webpack_require__(108);
-	var warning = __webpack_require__(47);
-
-	var VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + DOMProperty.ATTRIBUTE_NAME_START_CHAR + '][' + DOMProperty.ATTRIBUTE_NAME_CHAR + ']*$');
-	var illegalAttributeNameCache = {};
-	var validatedAttributeNameCache = {};
-
-	function isAttributeNameSafe(attributeName) {
-	  if (validatedAttributeNameCache.hasOwnProperty(attributeName)) {
-	    return true;
-	  }
-	  if (illegalAttributeNameCache.hasOwnProperty(attributeName)) {
-	    return false;
-	  }
-	  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
-	    validatedAttributeNameCache[attributeName] = true;
-	    return true;
-	  }
-	  illegalAttributeNameCache[attributeName] = true;
-	  process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid attribute name: `%s`', attributeName) : void 0;
-	  return false;
-	}
-
-	function shouldIgnoreValue(propertyInfo, value) {
-	  return value == null || propertyInfo.hasBooleanValue && !value || propertyInfo.hasNumericValue && isNaN(value) || propertyInfo.hasPositiveNumericValue && value < 1 || propertyInfo.hasOverloadedBooleanValue && value === false;
-	}
-
-	/**
-	 * Operations for dealing with DOM properties.
-	 */
-	var DOMPropertyOperations = {
-
-	  /**
-	   * Creates markup for the ID property.
-	   *
-	   * @param {string} id Unescaped ID.
-	   * @return {string} Markup string.
-	   */
-	  createMarkupForID: function (id) {
-	    return DOMProperty.ID_ATTRIBUTE_NAME + '=' + quoteAttributeValueForBrowser(id);
-	  },
-
-	  setAttributeForID: function (node, id) {
-	    node.setAttribute(DOMProperty.ID_ATTRIBUTE_NAME, id);
-	  },
-
-	  createMarkupForRoot: function () {
-	    return DOMProperty.ROOT_ATTRIBUTE_NAME + '=""';
-	  },
-
-	  setAttributeForRoot: function (node) {
-	    node.setAttribute(DOMProperty.ROOT_ATTRIBUTE_NAME, '');
-	  },
-
-	  /**
-	   * 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) {
-	    var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null;
-	    if (propertyInfo) {
-	      if (shouldIgnoreValue(propertyInfo, value)) {
-	        return '';
-	      }
-	      var attributeName = propertyInfo.attributeName;
-	      if (propertyInfo.hasBooleanValue || propertyInfo.hasOverloadedBooleanValue && value === true) {
-	        return attributeName + '=""';
-	      }
-	      return attributeName + '=' + quoteAttributeValueForBrowser(value);
-	    } else if (DOMProperty.isCustomAttribute(name)) {
-	      if (value == null) {
-	        return '';
-	      }
-	      return name + '=' + quoteAttributeValueForBrowser(value);
-	    }
-	    return null;
-	  },
-
-	  /**
-	   * Creates markup for a custom property.
-	   *
-	   * @param {string} name
-	   * @param {*} value
-	   * @return {string} Markup string, or empty string if the property was invalid.
-	   */
-	  createMarkupForCustomAttribute: function (name, value) {
-	    if (!isAttributeNameSafe(name) || value == null) {
-	      return '';
-	    }
-	    return name + '=' + quoteAttributeValueForBrowser(value);
-	  },
-
-	  /**
-	   * Sets the value for a property on a node.
-	   *
-	   * @param {DOMElement} node
-	   * @param {string} name
-	   * @param {*} value
-	   */
-	  setValueForProperty: function (node, name, value) {
-	    var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null;
-	    if (propertyInfo) {
-	      var mutationMethod = propertyInfo.mutationMethod;
-	      if (mutationMethod) {
-	        mutationMethod(node, value);
-	      } else if (shouldIgnoreValue(propertyInfo, value)) {
-	        this.deleteValueForProperty(node, name);
-	        return;
-	      } else if (propertyInfo.mustUseProperty) {
-	        // Contrary to `setAttribute`, object properties are properly
-	        // `toString`ed by IE8/9.
-	        node[propertyInfo.propertyName] = value;
-	      } else {
-	        var attributeName = propertyInfo.attributeName;
-	        var namespace = propertyInfo.attributeNamespace;
-	        // `setAttribute` with objects becomes only `[object]` in IE8/9,
-	        // ('' + value) makes it output the correct toString()-value.
-	        if (namespace) {
-	          node.setAttributeNS(namespace, attributeName, '' + value);
-	        } else if (propertyInfo.hasBooleanValue || propertyInfo.hasOverloadedBooleanValue && value === true) {
-	          node.setAttribute(attributeName, '');
-	        } else {
-	          node.setAttribute(attributeName, '' + value);
-	        }
-	      }
-	    } else if (DOMProperty.isCustomAttribute(name)) {
-	      DOMPropertyOperations.setValueForAttribute(node, name, value);
-	      return;
-	    }
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      var payload = {};
-	      payload[name] = value;
-	      ReactInstrumentation.debugTool.onHostOperation({
-	        instanceID: ReactDOMComponentTree.getInstanceFromNode(node)._debugID,
-	        type: 'update attribute',
-	        payload: payload
-	      });
-	    }
-	  },
-
-	  setValueForAttribute: function (node, name, value) {
-	    if (!isAttributeNameSafe(name)) {
-	      return;
-	    }
-	    if (value == null) {
-	      node.removeAttribute(name);
-	    } else {
-	      node.setAttribute(name, '' + value);
-	    }
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      var payload = {};
-	      payload[name] = value;
-	      ReactInstrumentation.debugTool.onHostOperation({
-	        instanceID: ReactDOMComponentTree.getInstanceFromNode(node)._debugID,
-	        type: 'update attribute',
-	        payload: payload
-	      });
-	    }
-	  },
-
-	  /**
-	   * Deletes an attributes from a node.
-	   *
-	   * @param {DOMElement} node
-	   * @param {string} name
-	   */
-	  deleteValueForAttribute: function (node, name) {
-	    node.removeAttribute(name);
-	    if (process.env.NODE_ENV !== 'production') {
-	      ReactInstrumentation.debugTool.onHostOperation({
-	        instanceID: ReactDOMComponentTree.getInstanceFromNode(node)._debugID,
-	        type: 'remove attribute',
-	        payload: name
-	      });
-	    }
-	  },
-
-	  /**
-	   * Deletes the value for a property on a node.
-	   *
-	   * @param {DOMElement} node
-	   * @param {string} name
-	   */
-	  deleteValueForProperty: function (node, name) {
-	    var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null;
-	    if (propertyInfo) {
-	      var mutationMethod = propertyInfo.mutationMethod;
-	      if (mutationMethod) {
-	        mutationMethod(node, undefined);
-	      } else if (propertyInfo.mustUseProperty) {
-	        var propName = propertyInfo.propertyName;
-	        if (propertyInfo.hasBooleanValue) {
-	          node[propName] = false;
-	        } else {
-	          node[propName] = '';
-	        }
-	      } else {
-	        node.removeAttribute(propertyInfo.attributeName);
-	      }
-	    } else if (DOMProperty.isCustomAttribute(name)) {
-	      node.removeAttribute(name);
-	    }
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      ReactInstrumentation.debugTool.onHostOperation({
-	        instanceID: ReactDOMComponentTree.getInstanceFromNode(node)._debugID,
-	        type: 'remove attribute',
-	        payload: name
-	      });
-	    }
-	  }
-
-	};
-
-	module.exports = DOMPropertyOperations;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 108 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var escapeTextContentForBrowser = __webpack_require__(90);
-
-	/**
-	 * Escapes attribute value to prevent scripting attacks.
-	 *
-	 * @param {*} value Value to escape.
-	 * @return {string} An escaped string.
-	 */
-	function quoteAttributeValueForBrowser(value) {
-	  return '"' + escapeTextContentForBrowser(value) + '"';
-	}
-
-	module.exports = quoteAttributeValueForBrowser;
-
-/***/ },
-/* 109 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _assign = __webpack_require__(53);
-
-	var EventPluginRegistry = __webpack_require__(44);
-	var ReactEventEmitterMixin = __webpack_require__(110);
-	var ViewportMetrics = __webpack_require__(80);
-
-	var getVendorPrefixedEventName = __webpack_require__(111);
-	var isEventSupported = __webpack_require__(74);
-
-	/**
-	 * Summary of `ReactBrowserEventEmitter` event handling:
-	 *
-	 *  - Top-level delegation is used to trap most native browser events. This
-	 *    may only occur in the main thread and is the responsibility of
-	 *    ReactEventListener, which is injected and can therefore support pluggable
-	 *    event sources. This is the only work that occurs in the main thread.
-	 *
-	 *  - We normalize and de-duplicate events to account for browser quirks. This
-	 *    may be done in the worker thread.
-	 *
-	 *  - Forward these native events (with the associated top-level type used to
-	 *    trap it) to `EventPluginHub`, which in turn will ask plugins if they want
-	 *    to extract any synthetic events.
-	 *
-	 *  - The `EventPluginHub` will then process each event by annotating them with
-	 *    "dispatches", a sequence of listeners and IDs that care about that event.
-	 *
-	 *  - The `EventPluginHub` then dispatches the events.
-	 *
-	 * Overview of React and the event system:
-	 *
-	 * +------------+    .
-	 * |    DOM     |    .
-	 * +------------+    .
-	 *       |           .
-	 *       v           .
-	 * +------------+    .
-	 * | ReactEvent |    .
-	 * |  Listener  |    .
-	 * +------------+    .                         +-----------+
-	 *       |           .               +--------+|SimpleEvent|
-	 *       |           .               |         |Plugin     |
-	 * +-----|------+    .               v         +-----------+
-	 * |     |      |    .    +--------------+                    +------------+
-	 * |     +-----------.--->|EventPluginHub|                    |    Event   |
-	 * |            |    .    |              |     +-----------+  | Propagators|
-	 * | ReactEvent |    .    |              |     |TapEvent   |  |------------|
-	 * |  Emitter   |    .    |              |<---+|Plugin     |  |other plugin|
-	 * |            |    .    |              |     +-----------+  |  utilities |
-	 * |     +-----------.--->|              |                    +------------+
-	 * |     |      |    .    +--------------+
-	 * +-----|------+    .                ^        +-----------+
-	 *       |           .                |        |Enter/Leave|
-	 *       +           .                +-------+|Plugin     |
-	 * +-------------+   .                         +-----------+
-	 * | application |   .
-	 * |-------------|   .
-	 * |             |   .
-	 * |             |   .
-	 * +-------------+   .
-	 *                   .
-	 *    React Core     .  General Purpose Event Plugin System
-	 */
-
-	var hasEventPageXY;
-	var alreadyListeningTo = {};
-	var isMonitoringScrollValue = false;
-	var reactTopListenersCounter = 0;
-
-	// For events like 'submit' which don't consistently bubble (which we trap at a
-	// lower node than `document`), binding at `document` would cause duplicate
-	// events so we don't include them here
-	var topEventMapping = {
-	  topAbort: 'abort',
-	  topAnimationEnd: getVendorPrefixedEventName('animationend') || 'animationend',
-	  topAnimationIteration: getVendorPrefixedEventName('animationiteration') || 'animationiteration',
-	  topAnimationStart: getVendorPrefixedEventName('animationstart') || 'animationstart',
-	  topBlur: 'blur',
-	  topCanPlay: 'canplay',
-	  topCanPlayThrough: 'canplaythrough',
-	  topChange: 'change',
-	  topClick: 'click',
-	  topCompositionEnd: 'compositionend',
-	  topCompositionStart: 'compositionstart',
-	  topCompositionUpdate: 'compositionupdate',
-	  topContextMenu: 'contextmenu',
-	  topCopy: 'copy',
-	  topCut: 'cut',
-	  topDoubleClick: 'dblclick',
-	  topDrag: 'drag',
-	  topDragEnd: 'dragend',
-	  topDragEnter: 'dragenter',
-	  topDragExit: 'dragexit',
-	  topDragLeave: 'dragleave',
-	  topDragOver: 'dragover',
-	  topDragStart: 'dragstart',
-	  topDrop: 'drop',
-	  topDurationChange: 'durationchange',
-	  topEmptied: 'emptied',
-	  topEncrypted: 'encrypted',
-	  topEnded: 'ended',
-	  topError: 'error',
-	  topFocus: 'focus',
-	  topInput: 'input',
-	  topKeyDown: 'keydown',
-	  topKeyPress: 'keypress',
-	  topKeyUp: 'keyup',
-	  topLoadedData: 'loadeddata',
-	  topLoadedMetadata: 'loadedmetadata',
-	  topLoadStart: 'loadstart',
-	  topMouseDown: 'mousedown',
-	  topMouseMove: 'mousemove',
-	  topMouseOut: 'mouseout',
-	  topMouseOver: 'mouseover',
-	  topMouseUp: 'mouseup',
-	  topPaste: 'paste',
-	  topPause: 'pause',
-	  topPlay: 'play',
-	  topPlaying: 'playing',
-	  topProgress: 'progress',
-	  topRateChange: 'ratechange',
-	  topScroll: 'scroll',
-	  topSeeked: 'seeked',
-	  topSeeking: 'seeking',
-	  topSelectionChange: 'selectionchange',
-	  topStalled: 'stalled',
-	  topSuspend: 'suspend',
-	  topTextInput: 'textInput',
-	  topTimeUpdate: 'timeupdate',
-	  topTouchCancel: 'touchcancel',
-	  topTouchEnd: 'touchend',
-	  topTouchMove: 'touchmove',
-	  topTouchStart: 'touchstart',
-	  topTransitionEnd: getVendorPrefixedEventName('transitionend') || 'transitionend',
-	  topVolumeChange: 'volumechange',
-	  topWaiting: 'waiting',
-	  topWheel: 'wheel'
-	};
-
-	/**
-	 * To ensure no conflicts with other potential React instances on the page
-	 */
-	var topListenersIDKey = '_reactListenersID' + String(Math.random()).slice(2);
-
-	function getListeningForDocument(mountAt) {
-	  // In IE8, `mountAt` is a host object and doesn't have `hasOwnProperty`
-	  // directly.
-	  if (!Object.prototype.hasOwnProperty.call(mountAt, topListenersIDKey)) {
-	    mountAt[topListenersIDKey] = reactTopListenersCounter++;
-	    alreadyListeningTo[mountAt[topListenersIDKey]] = {};
-	  }
-	  return alreadyListeningTo[mountAt[topListenersIDKey]];
-	}
-
-	/**
-	 * `ReactBrowserEventEmitter` is used to attach top-level event listeners. For
-	 * example:
-	 *
-	 *   EventPluginHub.putListener('myID', 'onClick', myFunction);
-	 *
-	 * This would allocate a "registration" of `('onClick', myFunction)` on 'myID'.
-	 *
-	 * @internal
-	 */
-	var ReactBrowserEventEmitter = _assign({}, ReactEventEmitterMixin, {
-
-	  /**
-	   * Injectable event backend
-	   */
-	  ReactEventListener: null,
-
-	  injection: {
-	    /**
-	     * @param {object} ReactEventListener
-	     */
-	    injectReactEventListener: function (ReactEventListener) {
-	      ReactEventListener.setHandleTopLevel(ReactBrowserEventEmitter.handleTopLevel);
-	      ReactBrowserEventEmitter.ReactEventListener = ReactEventListener;
-	    }
-	  },
-
-	  /**
-	   * Sets whether or not any created callbacks should be enabled.
-	   *
-	   * @param {boolean} enabled True if callbacks should be enabled.
-	   */
-	  setEnabled: function (enabled) {
-	    if (ReactBrowserEventEmitter.ReactEventListener) {
-	      ReactBrowserEventEmitter.ReactEventListener.setEnabled(enabled);
-	    }
-	  },
-
-	  /**
-	   * @return {boolean} True if callbacks are enabled.
-	   */
-	  isEnabled: function () {
-	    return !!(ReactBrowserEventEmitter.ReactEventListener && ReactBrowserEventEmitter.ReactEventListener.isEnabled());
-	  },
-
-	  /**
-	   * 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.
-	   *
-	   * @param {string} registrationName Name of listener (e.g. `onClick`).
-	   * @param {object} contentDocumentHandle Document which owns the container
-	   */
-	  listenTo: function (registrationName, contentDocumentHandle) {
-	    var mountAt = contentDocumentHandle;
-	    var isListening = getListeningForDocument(mountAt);
-	    var dependencies = EventPluginRegistry.registrationNameDependencies[registrationName];
-
-	    for (var i = 0; i < dependencies.length; i++) {
-	      var dependency = dependencies[i];
-	      if (!(isListening.hasOwnProperty(dependency) && isListening[dependency])) {
-	        if (dependency === 'topWheel') {
-	          if (isEventSupported('wheel')) {
-	            ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topWheel', 'wheel', mountAt);
-	          } else if (isEventSupported('mousewheel')) {
-	            ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topWheel', 'mousewheel', mountAt);
-	          } else {
-	            // Firefox needs to capture a different mouse scroll event.
-	            // @see http://www.quirksmode.org/dom/events/tests/scroll.html
-	            ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topWheel', 'DOMMouseScroll', mountAt);
-	          }
-	        } else if (dependency === 'topScroll') {
-
-	          if (isEventSupported('scroll', true)) {
-	            ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent('topScroll', 'scroll', mountAt);
-	          } else {
-	            ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topScroll', 'scroll', ReactBrowserEventEmitter.ReactEventListener.WINDOW_HANDLE);
-	          }
-	        } else if (dependency === 'topFocus' || dependency === 'topBlur') {
-
-	          if (isEventSupported('focus', true)) {
-	            ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent('topFocus', 'focus', mountAt);
-	            ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent('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
-	            ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topFocus', 'focusin', mountAt);
-	            ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topBlur', 'focusout', mountAt);
-	          }
-
-	          // to make sure blur and focus event listeners are only attached once
-	          isListening.topBlur = true;
-	          isListening.topFocus = true;
-	        } else if (topEventMapping.hasOwnProperty(dependency)) {
-	          ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(dependency, topEventMapping[dependency], mountAt);
-	        }
-
-	        isListening[dependency] = true;
-	      }
-	    }
-	  },
-
-	  trapBubbledEvent: function (topLevelType, handlerBaseName, handle) {
-	    return ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelType, handlerBaseName, handle);
-	  },
-
-	  trapCapturedEvent: function (topLevelType, handlerBaseName, handle) {
-	    return ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(topLevelType, handlerBaseName, handle);
-	  },
-
-	  /**
-	   * Protect against document.createEvent() returning null
-	   * Some popup blocker extensions appear to do this:
-	   * https://github.com/facebook/react/issues/6887
-	   */
-	  supportsEventPageXY: function () {
-	    if (!document.createEvent) {
-	      return false;
-	    }
-	    var ev = document.createEvent('MouseEvent');
-	    return ev != null && 'pageX' in ev;
-	  },
-
-	  /**
-	   * Listens to window scroll and resize events. We cache scroll values so that
-	   * application code can access them without triggering reflows.
-	   *
-	   * ViewportMetrics is only used by SyntheticMouse/TouchEvent and only when
-	   * pageX/pageY isn't supported (legacy browsers).
-	   *
-	   * NOTE: Scroll events do not bubble.
-	   *
-	   * @see http://www.quirksmode.org/dom/events/scroll.html
-	   */
-	  ensureScrollValueMonitoring: function () {
-	    if (hasEventPageXY === undefined) {
-	      hasEventPageXY = ReactBrowserEventEmitter.supportsEventPageXY();
-	    }
-	    if (!hasEventPageXY && !isMonitoringScrollValue) {
-	      var refresh = ViewportMetrics.refreshScrollValues;
-	      ReactBrowserEventEmitter.ReactEventListener.monitorScrollValue(refresh);
-	      isMonitoringScrollValue = true;
-	    }
-	  }
-
-	});
-
-	module.exports = ReactBrowserEventEmitter;
-
-/***/ },
-/* 110 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var EventPluginHub = __webpack_require__(43);
-
-	function runEventQueueInBatch(events) {
-	  EventPluginHub.enqueueEvents(events);
-	  EventPluginHub.processEventQueue(false);
-	}
-
-	var ReactEventEmitterMixin = {
-
-	  /**
-	   * Streams a fired top-level event to `EventPluginHub` where plugins have the
-	   * opportunity to create `ReactEvent`s to be dispatched.
-	   */
-	  handleTopLevel: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-	    var events = EventPluginHub.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
-	    runEventQueueInBatch(events);
-	  }
-	};
-
-	module.exports = ReactEventEmitterMixin;
-
-/***/ },
-/* 111 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ExecutionEnvironment = __webpack_require__(51);
-
-	/**
-	 * Generate a mapping of standard vendor prefixes using the defined style property and event name.
-	 *
-	 * @param {string} styleProp
-	 * @param {string} eventName
-	 * @returns {object}
-	 */
-	function makePrefixMap(styleProp, eventName) {
-	  var prefixes = {};
-
-	  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
-	  prefixes['Webkit' + styleProp] = 'webkit' + eventName;
-	  prefixes['Moz' + styleProp] = 'moz' + eventName;
-	  prefixes['ms' + styleProp] = 'MS' + eventName;
-	  prefixes['O' + styleProp] = 'o' + eventName.toLowerCase();
-
-	  return prefixes;
-	}
-
-	/**
-	 * A list of event names to a configurable list of vendor prefixes.
-	 */
-	var vendorPrefixes = {
-	  animationend: makePrefixMap('Animation', 'AnimationEnd'),
-	  animationiteration: makePrefixMap('Animation', 'AnimationIteration'),
-	  animationstart: makePrefixMap('Animation', 'AnimationStart'),
-	  transitionend: makePrefixMap('Transition', 'TransitionEnd')
-	};
-
-	/**
-	 * Event names that have already been detected and prefixed (if applicable).
-	 */
-	var prefixedEventNames = {};
-
-	/**
-	 * Element to check for prefixes on.
-	 */
-	var style = {};
-
-	/**
-	 * Bootstrap if a DOM exists.
-	 */
-	if (ExecutionEnvironment.canUseDOM) {
-	  style = document.createElement('div').style;
-
-	  // On some platforms, in particular some releases of Android 4.x,
-	  // the un-prefixed "animation" and "transition" properties are defined on the
-	  // style object but the events that fire will still be prefixed, so we need
-	  // to check if the un-prefixed events are usable, and if not remove them from the map.
-	  if (!('AnimationEvent' in window)) {
-	    delete vendorPrefixes.animationend.animation;
-	    delete vendorPrefixes.animationiteration.animation;
-	    delete vendorPrefixes.animationstart.animation;
-	  }
-
-	  // Same as above
-	  if (!('TransitionEvent' in window)) {
-	    delete vendorPrefixes.transitionend.transition;
-	  }
-	}
-
-	/**
-	 * Attempts to determine the correct vendor prefixed event name.
-	 *
-	 * @param {string} eventName
-	 * @returns {string}
-	 */
-	function getVendorPrefixedEventName(eventName) {
-	  if (prefixedEventNames[eventName]) {
-	    return prefixedEventNames[eventName];
-	  } else if (!vendorPrefixes[eventName]) {
-	    return eventName;
-	  }
-
-	  var prefixMap = vendorPrefixes[eventName];
-
-	  for (var styleProp in prefixMap) {
-	    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
-	      return prefixedEventNames[eventName] = prefixMap[styleProp];
-	    }
-	  }
-
-	  return '';
-	}
-
-	module.exports = getVendorPrefixedEventName;
-
-/***/ },
-/* 112 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35),
-	    _assign = __webpack_require__(53);
-
-	var DOMPropertyOperations = __webpack_require__(107);
-	var LinkedValueUtils = __webpack_require__(113);
-	var ReactDOMComponentTree = __webpack_require__(34);
-	var ReactUpdates = __webpack_require__(60);
-
-	var invariant = __webpack_require__(37);
-	var warning = __webpack_require__(47);
-
-	var didWarnValueLink = false;
-	var didWarnCheckedLink = false;
-	var didWarnValueDefaultValue = false;
-	var didWarnCheckedDefaultChecked = false;
-	var didWarnControlledToUncontrolled = false;
-	var didWarnUncontrolledToControlled = false;
-
-	function forceUpdateIfMounted() {
-	  if (this._rootNodeID) {
-	    // DOM component is still mounted; update
-	    ReactDOMInput.updateWrapper(this);
-	  }
-	}
-
-	function isControlled(props) {
-	  var usesChecked = props.type === 'checkbox' || props.type === 'radio';
-	  return usesChecked ? props.checked != null : props.value != null;
-	}
-
-	/**
-	 * Implements an <input> host 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 = {
-	  getHostProps: function (inst, props) {
-	    var value = LinkedValueUtils.getValue(props);
-	    var checked = LinkedValueUtils.getChecked(props);
-
-	    var hostProps = _assign({
-	      // Make sure we set .type before any other properties (setting .value
-	      // before .type means .value is lost in IE11 and below)
-	      type: undefined,
-	      // Make sure we set .step before .value (setting .value before .step
-	      // means .value is rounded on mount, based upon step precision)
-	      step: undefined,
-	      // Make sure we set .min & .max before .value (to ensure proper order
-	      // in corner cases such as min or max deriving from value, e.g. Issue #7170)
-	      min: undefined,
-	      max: undefined
-	    }, props, {
-	      defaultChecked: undefined,
-	      defaultValue: undefined,
-	      value: value != null ? value : inst._wrapperState.initialValue,
-	      checked: checked != null ? checked : inst._wrapperState.initialChecked,
-	      onChange: inst._wrapperState.onChange
-	    });
-
-	    return hostProps;
-	  },
-
-	  mountWrapper: function (inst, props) {
-	    if (process.env.NODE_ENV !== 'production') {
-	      LinkedValueUtils.checkPropTypes('input', props, inst._currentElement._owner);
-
-	      var owner = inst._currentElement._owner;
-
-	      if (props.valueLink !== undefined && !didWarnValueLink) {
-	        process.env.NODE_ENV !== 'production' ? warning(false, '`valueLink` prop on `input` is deprecated; set `value` and `onChange` instead.') : void 0;
-	        didWarnValueLink = true;
-	      }
-	      if (props.checkedLink !== undefined && !didWarnCheckedLink) {
-	        process.env.NODE_ENV !== 'production' ? warning(false, '`checkedLink` prop on `input` is deprecated; set `value` and `onChange` instead.') : void 0;
-	        didWarnCheckedLink = true;
-	      }
-	      if (props.checked !== undefined && props.defaultChecked !== undefined && !didWarnCheckedDefaultChecked) {
-	        process.env.NODE_ENV !== 'production' ? warning(false, '%s contains an input of type %s with both checked and defaultChecked props. ' + 'Input elements must be either controlled or uncontrolled ' + '(specify either the checked prop, or the defaultChecked prop, but not ' + 'both). Decide between using a controlled or uncontrolled input ' + 'element and remove one of these props. More info: ' + 'https://fb.me/react-controlled-components', owner && owner.getName() || 'A component', props.type) : void 0;
-	        didWarnCheckedDefaultChecked = true;
-	      }
-	      if (props.value !== undefined && props.defaultValue !== undefined && !didWarnValueDefaultValue) {
-	        process.env.NODE_ENV !== 'production' ? warning(false, '%s contains an input of type %s with both value and defaultValue props. ' + 'Input elements must be either controlled or uncontrolled ' + '(specify either the value prop, or the defaultValue prop, but not ' + 'both). Decide between using a controlled or uncontrolled input ' + 'element and remove one of these props. More info: ' + 'https://fb.me/react-controlled-components', owner && owner.getName() || 'A component', props.type) : void 0;
-	        didWarnValueDefaultValue = true;
-	      }
-	    }
-
-	    var defaultValue = props.defaultValue;
-	    inst._wrapperState = {
-	      initialChecked: props.checked != null ? props.checked : props.defaultChecked,
-	      initialValue: props.value != null ? props.value : defaultValue,
-	      listeners: null,
-	      onChange: _handleChange.bind(inst)
-	    };
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      inst._wrapperState.controlled = isControlled(props);
-	    }
-	  },
-
-	  updateWrapper: function (inst) {
-	    var props = inst._currentElement.props;
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      var controlled = isControlled(props);
-	      var owner = inst._currentElement._owner;
-
-	      if (!inst._wrapperState.controlled && controlled && !didWarnUncontrolledToControlled) {
-	        process.env.NODE_ENV !== 'production' ? warning(false, '%s is changing an uncontrolled input of type %s to be controlled. ' + 'Input elements should not switch from uncontrolled to controlled (or vice versa). ' + 'Decide between using a controlled or uncontrolled input ' + 'element for the lifetime of the component. More info: https://fb.me/react-controlled-components', owner && owner.getName() || 'A component', props.type) : void 0;
-	        didWarnUncontrolledToControlled = true;
-	      }
-	      if (inst._wrapperState.controlled && !controlled && !didWarnControlledToUncontrolled) {
-	        process.env.NODE_ENV !== 'production' ? warning(false, '%s is changing a controlled input of type %s to be uncontrolled. ' + 'Input elements should not switch from controlled to uncontrolled (or vice versa). ' + 'Decide between using a controlled or uncontrolled input ' + 'element for the lifetime of the component. More info: https://fb.me/react-controlled-components', owner && owner.getName() || 'A component', props.type) : void 0;
-	        didWarnControlledToUncontrolled = true;
-	      }
-	    }
-
-	    // TODO: Shouldn't this be getChecked(props)?
-	    var checked = props.checked;
-	    if (checked != null) {
-	      DOMPropertyOperations.setValueForProperty(ReactDOMComponentTree.getNodeFromInstance(inst), 'checked', checked || false);
-	    }
-
-	    var node = ReactDOMComponentTree.getNodeFromInstance(inst);
-	    var value = LinkedValueUtils.getValue(props);
-	    if (value != null) {
-
-	      // Cast `value` to a string to ensure the value is set correctly. While
-	      // browsers typically do this as necessary, jsdom doesn't.
-	      var newValue = '' + value;
-
-	      // To avoid side effects (such as losing text selection), only set value if changed
-	      if (newValue !== node.value) {
-	        node.value = newValue;
-	      }
-	    } else {
-	      if (props.value == null && props.defaultValue != null) {
-	        node.defaultValue = '' + props.defaultValue;
-	      }
-	      if (props.checked == null && props.defaultChecked != null) {
-	        node.defaultChecked = !!props.defaultChecked;
-	      }
-	    }
-	  },
-
-	  postMountWrapper: function (inst) {
-	    var props = inst._currentElement.props;
-
-	    // This is in postMount because we need access to the DOM node, which is not
-	    // available until after the component has mounted.
-	    var node = ReactDOMComponentTree.getNodeFromInstance(inst);
-
-	    // Detach value from defaultValue. We won't do anything if we're working on
-	    // submit or reset inputs as those values & defaultValues are linked. They
-	    // are not resetable nodes so this operation doesn't matter and actually
-	    // removes browser-default values (eg "Submit Query") when no value is
-	    // provided.
-
-	    switch (props.type) {
-	      case 'submit':
-	      case 'reset':
-	        break;
-	      case 'color':
-	      case 'date':
-	      case 'datetime':
-	      case 'datetime-local':
-	      case 'month':
-	      case 'time':
-	      case 'week':
-	        // This fixes the no-show issue on iOS Safari and Android Chrome:
-	        // https://github.com/facebook/react/issues/7233
-	        node.value = '';
-	        node.value = node.defaultValue;
-	        break;
-	      default:
-	        node.value = node.value;
-	        break;
-	    }
-
-	    // Normally, we'd just do `node.checked = node.checked` upon initial mount, less this bug
-	    // this is needed to work around a chrome bug where setting defaultChecked
-	    // will sometimes influence the value of checked (even after detachment).
-	    // Reference: https://bugs.chromium.org/p/chromium/issues/detail?id=608416
-	    // We need to temporarily unset name to avoid disrupting radio button groups.
-	    var name = node.name;
-	    if (name !== '') {
-	      node.name = '';
-	    }
-	    node.defaultChecked = !node.defaultChecked;
-	    node.defaultChecked = !node.defaultChecked;
-	    if (name !== '') {
-	      node.name = name;
-	    }
-	  }
-	};
-
-	function _handleChange(event) {
-	  var props = this._currentElement.props;
-
-	  var returnValue = LinkedValueUtils.executeOnChange(props, event);
-
-	  // Here we use asap to wait until all updates have propagated, which
-	  // is important when using controlled components within layers:
-	  // https://github.com/facebook/react/issues/1698
-	  ReactUpdates.asap(forceUpdateIfMounted, this);
-
-	  var name = props.name;
-	  if (props.type === 'radio' && name != null) {
-	    var rootNode = ReactDOMComponentTree.getNodeFromInstance(this);
-	    var queryRoot = rootNode;
-
-	    while (queryRoot.parentNode) {
-	      queryRoot = queryRoot.parentNode;
-	    }
-
-	    // If `rootNode.form` was non-null, then we could try `form.elements`,
-	    // but that sometimes behaves strangely in IE8. We could also try using
-	    // `form.getElementsByName`, but that will only return direct children
-	    // and won't include inputs that use the HTML5 `form=` attribute. Since
-	    // the input might not even be in a form, let's just use the global
-	    // `querySelectorAll` to ensure we don't miss anything.
-	    var group = queryRoot.querySelectorAll('input[name=' + JSON.stringify('' + name) + '][type="radio"]');
-
-	    for (var i = 0; i < group.length; i++) {
-	      var otherNode = group[i];
-	      if (otherNode === rootNode || otherNode.form !== rootNode.form) {
-	        continue;
-	      }
-	      // This will throw if radio buttons rendered by different copies of React
-	      // and the same name are rendered into the same form (same as #1939).
-	      // That's probably okay; we don't support it just as we don't support
-	      // mixing React radio buttons with non-React ones.
-	      var otherInstance = ReactDOMComponentTree.getInstanceFromNode(otherNode);
-	      !otherInstance ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactDOMInput: Mixing React and non-React radio inputs with the same `name` is not supported.') : _prodInvariant('90') : void 0;
-	      // If this is a controlled radio button group, forcing the input that
-	      // was previously checked to update will cause it to be come re-checked
-	      // as appropriate.
-	      ReactUpdates.asap(forceUpdateIfMounted, otherInstance);
-	    }
-	  }
-
-	  return returnValue;
-	}
-
-	module.exports = ReactDOMInput;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 113 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var React = __webpack_require__(2);
-	var ReactPropTypesSecret = __webpack_require__(114);
-
-	var invariant = __webpack_require__(37);
-	var warning = __webpack_require__(47);
-
-	var hasReadOnlyValue = {
-	  'button': true,
-	  'checkbox': true,
-	  'image': true,
-	  'hidden': true,
-	  'radio': true,
-	  'reset': true,
-	  'submit': true
-	};
-
-	function _assertSingleLink(inputProps) {
-	  !(inputProps.checkedLink == null || inputProps.valueLink == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Cannot provide a checkedLink and a valueLink. If you want to use checkedLink, you probably don\'t want to use valueLink and vice versa.') : _prodInvariant('87') : void 0;
-	}
-	function _assertValueLink(inputProps) {
-	  _assertSingleLink(inputProps);
-	  !(inputProps.value == null && inputProps.onChange == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Cannot provide a valueLink and a value or onChange event. If you want to use value or onChange, you probably don\'t want to use valueLink.') : _prodInvariant('88') : void 0;
-	}
-
-	function _assertCheckedLink(inputProps) {
-	  _assertSingleLink(inputProps);
-	  !(inputProps.checked == null && inputProps.onChange == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Cannot provide a checkedLink and a checked property or onChange event. If you want to use checked or onChange, you probably don\'t want to use checkedLink') : _prodInvariant('89') : void 0;
-	}
-
-	var propTypes = {
-	  value: function (props, propName, componentName) {
-	    if (!props[propName] || hasReadOnlyValue[props.type] || props.onChange || props.readOnly || props.disabled) {
-	      return null;
-	    }
-	    return new Error('You provided a `value` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultValue`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
-	  },
-	  checked: function (props, propName, componentName) {
-	    if (!props[propName] || props.onChange || props.readOnly || props.disabled) {
-	      return null;
-	    }
-	    return new Error('You provided a `checked` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultChecked`. Otherwise, ' + 'set either `onChange` or `readOnly`.');
-	  },
-	  onChange: React.PropTypes.func
-	};
-
-	var loggedTypeFailures = {};
-	function getDeclarationErrorAddendum(owner) {
-	  if (owner) {
-	    var name = owner.getName();
-	    if (name) {
-	      return ' Check the render method of `' + name + '`.';
-	    }
-	  }
-	  return '';
-	}
-
-	/**
-	 * Provide a linked `value` attribute for controlled forms. You should not use
-	 * this outside of the ReactDOM controlled form components.
-	 */
-	var LinkedValueUtils = {
-	  checkPropTypes: function (tagName, props, owner) {
-	    for (var propName in propTypes) {
-	      if (propTypes.hasOwnProperty(propName)) {
-	        var error = propTypes[propName](props, propName, tagName, 'prop', null, ReactPropTypesSecret);
-	      }
-	      if (error instanceof Error && !(error.message in loggedTypeFailures)) {
-	        // Only monitor this failure once because there tends to be a lot of the
-	        // same error.
-	        loggedTypeFailures[error.message] = true;
-
-	        var addendum = getDeclarationErrorAddendum(owner);
-	        process.env.NODE_ENV !== 'production' ? warning(false, 'Failed form propType: %s%s', error.message, addendum) : void 0;
-	      }
-	    }
-	  },
-
-	  /**
-	   * @param {object} inputProps Props for form component
-	   * @return {*} current value of the input either from value prop or link.
-	   */
-	  getValue: function (inputProps) {
-	    if (inputProps.valueLink) {
-	      _assertValueLink(inputProps);
-	      return inputProps.valueLink.value;
-	    }
-	    return inputProps.value;
-	  },
-
-	  /**
-	   * @param {object} inputProps Props for form component
-	   * @return {*} current checked status of the input either from checked prop
-	   *             or link.
-	   */
-	  getChecked: function (inputProps) {
-	    if (inputProps.checkedLink) {
-	      _assertCheckedLink(inputProps);
-	      return inputProps.checkedLink.value;
-	    }
-	    return inputProps.checked;
-	  },
-
-	  /**
-	   * @param {object} inputProps Props for form component
-	   * @param {SyntheticEvent} event change event to handle
-	   */
-	  executeOnChange: function (inputProps, event) {
-	    if (inputProps.valueLink) {
-	      _assertValueLink(inputProps);
-	      return inputProps.valueLink.requestChange(event.target.value);
-	    } else if (inputProps.checkedLink) {
-	      _assertCheckedLink(inputProps);
-	      return inputProps.checkedLink.requestChange(event.target.checked);
-	    } else if (inputProps.onChange) {
-	      return inputProps.onChange.call(undefined, event);
-	    }
-	  }
-	};
-
-	module.exports = LinkedValueUtils;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 114 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
-
-	module.exports = ReactPropTypesSecret;
-
-/***/ },
-/* 115 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _assign = __webpack_require__(53);
-
-	var React = __webpack_require__(2);
-	var ReactDOMComponentTree = __webpack_require__(34);
-	var ReactDOMSelect = __webpack_require__(116);
-
-	var warning = __webpack_require__(47);
-	var didWarnInvalidOptionChildren = false;
-
-	function flattenChildren(children) {
-	  var content = '';
-
-	  // Flatten children and warn if they aren't strings or numbers;
-	  // invalid types are ignored.
-	  React.Children.forEach(children, function (child) {
-	    if (child == null) {
-	      return;
-	    }
-	    if (typeof child === 'string' || typeof child === 'number') {
-	      content += child;
-	    } else if (!didWarnInvalidOptionChildren) {
-	      didWarnInvalidOptionChildren = true;
-	      process.env.NODE_ENV !== 'production' ? warning(false, 'Only strings and numbers are supported as <option> children.') : void 0;
-	    }
-	  });
-
-	  return content;
-	}
-
-	/**
-	 * Implements an <option> host component that warns when `selected` is set.
-	 */
-	var ReactDOMOption = {
-	  mountWrapper: function (inst, props, hostParent) {
-	    // TODO (yungsters): Remove support for `selected` in <option>.
-	    if (process.env.NODE_ENV !== 'production') {
-	      process.env.NODE_ENV !== 'production' ? warning(props.selected == null, 'Use the `defaultValue` or `value` props on <select> instead of ' + 'setting `selected` on <option>.') : void 0;
-	    }
-
-	    // Look up whether this option is 'selected'
-	    var selectValue = null;
-	    if (hostParent != null) {
-	      var selectParent = hostParent;
-
-	      if (selectParent._tag === 'optgroup') {
-	        selectParent = selectParent._hostParent;
-	      }
-
-	      if (selectParent != null && selectParent._tag === 'select') {
-	        selectValue = ReactDOMSelect.getSelectValueContext(selectParent);
-	      }
-	    }
-
-	    // If the value is null (e.g., no specified value or after initial mount)
-	    // or missing (e.g., for <datalist>), we don't change props.selected
-	    var selected = null;
-	    if (selectValue != null) {
-	      var value;
-	      if (props.value != null) {
-	        value = props.value + '';
-	      } else {
-	        value = flattenChildren(props.children);
-	      }
-	      selected = false;
-	      if (Array.isArray(selectValue)) {
-	        // multiple
-	        for (var i = 0; i < selectValue.length; i++) {
-	          if ('' + selectValue[i] === value) {
-	            selected = true;
-	            break;
-	          }
-	        }
-	      } else {
-	        selected = '' + selectValue === value;
-	      }
-	    }
-
-	    inst._wrapperState = { selected: selected };
-	  },
-
-	  postMountWrapper: function (inst) {
-	    // value="" should make a value attribute (#6219)
-	    var props = inst._currentElement.props;
-	    if (props.value != null) {
-	      var node = ReactDOMComponentTree.getNodeFromInstance(inst);
-	      node.setAttribute('value', props.value);
-	    }
-	  },
-
-	  getHostProps: function (inst, props) {
-	    var hostProps = _assign({ selected: undefined, children: undefined }, props);
-
-	    // Read state only from initial mount because <select> updates value
-	    // manually; we need the initial state only for server rendering
-	    if (inst._wrapperState.selected != null) {
-	      hostProps.selected = inst._wrapperState.selected;
-	    }
-
-	    var content = flattenChildren(props.children);
-
-	    if (content) {
-	      hostProps.children = content;
-	    }
-
-	    return hostProps;
-	  }
-
-	};
-
-	module.exports = ReactDOMOption;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 116 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _assign = __webpack_require__(53);
-
-	var LinkedValueUtils = __webpack_require__(113);
-	var ReactDOMComponentTree = __webpack_require__(34);
-	var ReactUpdates = __webpack_require__(60);
-
-	var warning = __webpack_require__(47);
-
-	var didWarnValueLink = false;
-	var didWarnValueDefaultValue = false;
-
-	function updateOptionsIfPendingUpdateAndMounted() {
-	  if (this._rootNodeID && this._wrapperState.pendingUpdate) {
-	    this._wrapperState.pendingUpdate = false;
-
-	    var props = this._currentElement.props;
-	    var value = LinkedValueUtils.getValue(props);
-
-	    if (value != null) {
-	      updateOptions(this, Boolean(props.multiple), value);
-	    }
-	  }
-	}
-
-	function getDeclarationErrorAddendum(owner) {
-	  if (owner) {
-	    var name = owner.getName();
-	    if (name) {
-	      return ' Check the render method of `' + name + '`.';
-	    }
-	  }
-	  return '';
-	}
-
-	var valuePropNames = ['value', 'defaultValue'];
-
-	/**
-	 * Validation function for `value` and `defaultValue`.
-	 * @private
-	 */
-	function checkSelectPropTypes(inst, props) {
-	  var owner = inst._currentElement._owner;
-	  LinkedValueUtils.checkPropTypes('select', props, owner);
-
-	  if (props.valueLink !== undefined && !didWarnValueLink) {
-	    process.env.NODE_ENV !== 'production' ? warning(false, '`valueLink` prop on `select` is deprecated; set `value` and `onChange` instead.') : void 0;
-	    didWarnValueLink = true;
-	  }
-
-	  for (var i = 0; i < valuePropNames.length; i++) {
-	    var propName = valuePropNames[i];
-	    if (props[propName] == null) {
-	      continue;
-	    }
-	    var isArray = Array.isArray(props[propName]);
-	    if (props.multiple && !isArray) {
-	      process.env.NODE_ENV !== 'production' ? warning(false, 'The `%s` prop supplied to <select> must be an array if ' + '`multiple` is true.%s', propName, getDeclarationErrorAddendum(owner)) : void 0;
-	    } else if (!props.multiple && isArray) {
-	      process.env.NODE_ENV !== 'production' ? warning(false, 'The `%s` prop supplied to <select> must be a scalar ' + 'value if `multiple` is false.%s', propName, getDeclarationErrorAddendum(owner)) : void 0;
-	    }
-	  }
-	}
-
-	/**
-	 * @param {ReactDOMComponent} inst
-	 * @param {boolean} multiple
-	 * @param {*} propValue A stringable (with `multiple`, a list of stringables).
-	 * @private
-	 */
-	function updateOptions(inst, multiple, propValue) {
-	  var selectedValue, i;
-	  var options = ReactDOMComponentTree.getNodeFromInstance(inst).options;
-
-	  if (multiple) {
-	    selectedValue = {};
-	    for (i = 0; i < propValue.length; i++) {
-	      selectedValue['' + propValue[i]] = true;
-	    }
-	    for (i = 0; i < options.length; i++) {
-	      var selected = selectedValue.hasOwnProperty(options[i].value);
-	      if (options[i].selected !== selected) {
-	        options[i].selected = selected;
-	      }
-	    }
-	  } else {
-	    // Do not set `select.value` as exact behavior isn't consistent across all
-	    // browsers for all cases.
-	    selectedValue = '' + propValue;
-	    for (i = 0; i < options.length; i++) {
-	      if (options[i].value === selectedValue) {
-	        options[i].selected = true;
-	        return;
-	      }
-	    }
-	    if (options.length) {
-	      options[0].selected = true;
-	    }
-	  }
-	}
-
-	/**
-	 * Implements a <select> host component that allows optionally setting the
-	 * props `value` and `defaultValue`. If `multiple` is false, the prop must be a
-	 * stringable. If `multiple` is true, the prop must be an array of stringables.
-	 *
-	 * If `value` is not supplied (or null/undefined), user actions that change the
-	 * selected option will trigger updates to the rendered options.
-	 *
-	 * If it is supplied (and not null/undefined), the rendered options will not
-	 * update in response to user actions. Instead, the `value` prop must change in
-	 * order for the rendered options to update.
-	 *
-	 * If `defaultValue` is provided, any options with the supplied values will be
-	 * selected.
-	 */
-	var ReactDOMSelect = {
-	  getHostProps: function (inst, props) {
-	    return _assign({}, props, {
-	      onChange: inst._wrapperState.onChange,
-	      value: undefined
-	    });
-	  },
-
-	  mountWrapper: function (inst, props) {
-	    if (process.env.NODE_ENV !== 'production') {
-	      checkSelectPropTypes(inst, props);
-	    }
-
-	    var value = LinkedValueUtils.getValue(props);
-	    inst._wrapperState = {
-	      pendingUpdate: false,
-	      initialValue: value != null ? value : props.defaultValue,
-	      listeners: null,
-	      onChange: _handleChange.bind(inst),
-	      wasMultiple: Boolean(props.multiple)
-	    };
-
-	    if (props.value !== undefined && props.defaultValue !== undefined && !didWarnValueDefaultValue) {
-	      process.env.NODE_ENV !== 'production' ? warning(false, 'Select elements must be either controlled or uncontrolled ' + '(specify either the value prop, or the defaultValue prop, but not ' + 'both). Decide between using a controlled or uncontrolled select ' + 'element and remove one of these props. More info: ' + 'https://fb.me/react-controlled-components') : void 0;
-	      didWarnValueDefaultValue = true;
-	    }
-	  },
-
-	  getSelectValueContext: function (inst) {
-	    // ReactDOMOption looks at this initial value so the initial generated
-	    // markup has correct `selected` attributes
-	    return inst._wrapperState.initialValue;
-	  },
-
-	  postUpdateWrapper: function (inst) {
-	    var props = inst._currentElement.props;
-
-	    // After the initial mount, we control selected-ness manually so don't pass
-	    // this value down
-	    inst._wrapperState.initialValue = undefined;
-
-	    var wasMultiple = inst._wrapperState.wasMultiple;
-	    inst._wrapperState.wasMultiple = Boolean(props.multiple);
-
-	    var value = LinkedValueUtils.getValue(props);
-	    if (value != null) {
-	      inst._wrapperState.pendingUpdate = false;
-	      updateOptions(inst, Boolean(props.multiple), value);
-	    } else if (wasMultiple !== Boolean(props.multiple)) {
-	      // For simplicity, reapply `defaultValue` if `multiple` is toggled.
-	      if (props.defaultValue != null) {
-	        updateOptions(inst, Boolean(props.multiple), props.defaultValue);
-	      } else {
-	        // Revert the select back to its default unselected state.
-	        updateOptions(inst, Boolean(props.multiple), props.multiple ? [] : '');
-	      }
-	    }
-	  }
-	};
-
-	function _handleChange(event) {
-	  var props = this._currentElement.props;
-	  var returnValue = LinkedValueUtils.executeOnChange(props, event);
-
-	  if (this._rootNodeID) {
-	    this._wrapperState.pendingUpdate = true;
-	  }
-	  ReactUpdates.asap(updateOptionsIfPendingUpdateAndMounted, this);
-	  return returnValue;
-	}
-
-	module.exports = ReactDOMSelect;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 117 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35),
-	    _assign = __webpack_require__(53);
-
-	var LinkedValueUtils = __webpack_require__(113);
-	var ReactDOMComponentTree = __webpack_require__(34);
-	var ReactUpdates = __webpack_require__(60);
-
-	var invariant = __webpack_require__(37);
-	var warning = __webpack_require__(47);
-
-	var didWarnValueLink = false;
-	var didWarnValDefaultVal = false;
-
-	function forceUpdateIfMounted() {
-	  if (this._rootNodeID) {
-	    // DOM component is still mounted; update
-	    ReactDOMTextarea.updateWrapper(this);
-	  }
-	}
-
-	/**
-	 * Implements a <textarea> host 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 = {
-	  getHostProps: function (inst, props) {
-	    !(props.dangerouslySetInnerHTML == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, '`dangerouslySetInnerHTML` does not make sense on <textarea>.') : _prodInvariant('91') : void 0;
-
-	    // Always set children to the same thing. In IE9, the selection range will
-	    // get reset if `textContent` is mutated.  We could add a check in setTextContent
-	    // to only set the value if/when the value differs from the node value (which would
-	    // completely solve this IE9 bug), but Sebastian+Ben seemed to like this solution.
-	    // The value can be a boolean or object so that's why it's forced to be a string.
-	    var hostProps = _assign({}, props, {
-	      value: undefined,
-	      defaultValue: undefined,
-	      children: '' + inst._wrapperState.initialValue,
-	      onChange: inst._wrapperState.onChange
-	    });
-
-	    return hostProps;
-	  },
-
-	  mountWrapper: function (inst, props) {
-	    if (process.env.NODE_ENV !== 'production') {
-	      LinkedValueUtils.checkPropTypes('textarea', props, inst._currentElement._owner);
-	      if (props.valueLink !== undefined && !didWarnValueLink) {
-	        process.env.NODE_ENV !== 'production' ? warning(false, '`valueLink` prop on `textarea` is deprecated; set `value` and `onChange` instead.') : void 0;
-	        didWarnValueLink = true;
-	      }
-	      if (props.value !== undefined && props.defaultValue !== undefined && !didWarnValDefaultVal) {
-	        process.env.NODE_ENV !== 'production' ? warning(false, 'Textarea elements must be either controlled or uncontrolled ' + '(specify either the value prop, or the defaultValue prop, but not ' + 'both). Decide between using a controlled or uncontrolled textarea ' + 'and remove one of these props. More info: ' + 'https://fb.me/react-controlled-components') : void 0;
-	        didWarnValDefaultVal = true;
-	      }
-	    }
-
-	    var value = LinkedValueUtils.getValue(props);
-	    var initialValue = value;
-
-	    // Only bother fetching default value if we're going to use it
-	    if (value == null) {
-	      var defaultValue = props.defaultValue;
-	      // TODO (yungsters): Remove support for children content in <textarea>.
-	      var children = props.children;
-	      if (children != null) {
-	        if (process.env.NODE_ENV !== 'production') {
-	          process.env.NODE_ENV !== 'production' ? warning(false, 'Use the `defaultValue` or `value` props instead of setting ' + 'children on <textarea>.') : void 0;
-	        }
-	        !(defaultValue == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'If you supply `defaultValue` on a <textarea>, do not pass children.') : _prodInvariant('92') : void 0;
-	        if (Array.isArray(children)) {
-	          !(children.length <= 1) ? process.env.NODE_ENV !== 'production' ? invariant(false, '<textarea> can only have at most one child.') : _prodInvariant('93') : void 0;
-	          children = children[0];
-	        }
-
-	        defaultValue = '' + children;
-	      }
-	      if (defaultValue == null) {
-	        defaultValue = '';
-	      }
-	      initialValue = defaultValue;
-	    }
-
-	    inst._wrapperState = {
-	      initialValue: '' + initialValue,
-	      listeners: null,
-	      onChange: _handleChange.bind(inst)
-	    };
-	  },
-
-	  updateWrapper: function (inst) {
-	    var props = inst._currentElement.props;
-
-	    var node = ReactDOMComponentTree.getNodeFromInstance(inst);
-	    var value = LinkedValueUtils.getValue(props);
-	    if (value != null) {
-	      // Cast `value` to a string to ensure the value is set correctly. While
-	      // browsers typically do this as necessary, jsdom doesn't.
-	      var newValue = '' + value;
-
-	      // To avoid side effects (such as losing text selection), only set value if changed
-	      if (newValue !== node.value) {
-	        node.value = newValue;
-	      }
-	      if (props.defaultValue == null) {
-	        node.defaultValue = newValue;
-	      }
-	    }
-	    if (props.defaultValue != null) {
-	      node.defaultValue = props.defaultValue;
-	    }
-	  },
-
-	  postMountWrapper: function (inst) {
-	    // This is in postMount because we need access to the DOM node, which is not
-	    // available until after the component has mounted.
-	    var node = ReactDOMComponentTree.getNodeFromInstance(inst);
-
-	    // Warning: node.value may be the empty string at this point (IE11) if placeholder is set.
-	    node.value = node.textContent; // Detach value from defaultValue
-	  }
-	};
-
-	function _handleChange(event) {
-	  var props = this._currentElement.props;
-	  var returnValue = LinkedValueUtils.executeOnChange(props, event);
-	  ReactUpdates.asap(forceUpdateIfMounted, this);
-	  return returnValue;
-	}
-
-	module.exports = ReactDOMTextarea;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 118 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var ReactComponentEnvironment = __webpack_require__(119);
-	var ReactInstanceMap = __webpack_require__(120);
-	var ReactInstrumentation = __webpack_require__(66);
-
-	var ReactCurrentOwner = __webpack_require__(10);
-	var ReactReconciler = __webpack_require__(63);
-	var ReactChildReconciler = __webpack_require__(121);
-
-	var emptyFunction = __webpack_require__(48);
-	var flattenChildren = __webpack_require__(137);
-	var invariant = __webpack_require__(37);
-
-	/**
-	 * Make an update for markup to be rendered and inserted at a supplied index.
-	 *
-	 * @param {string} markup Markup that renders into an element.
-	 * @param {number} toIndex Destination index.
-	 * @private
-	 */
-	function makeInsertMarkup(markup, afterNode, toIndex) {
-	  // NOTE: Null values reduce hidden classes.
-	  return {
-	    type: 'INSERT_MARKUP',
-	    content: markup,
-	    fromIndex: null,
-	    fromNode: null,
-	    toIndex: toIndex,
-	    afterNode: afterNode
-	  };
-	}
-
-	/**
-	 * Make an update for moving an existing element to another index.
-	 *
-	 * @param {number} fromIndex Source index of the existing element.
-	 * @param {number} toIndex Destination index of the element.
-	 * @private
-	 */
-	function makeMove(child, afterNode, toIndex) {
-	  // NOTE: Null values reduce hidden classes.
-	  return {
-	    type: 'MOVE_EXISTING',
-	    content: null,
-	    fromIndex: child._mountIndex,
-	    fromNode: ReactReconciler.getHostNode(child),
-	    toIndex: toIndex,
-	    afterNode: afterNode
-	  };
-	}
-
-	/**
-	 * Make an update for removing an element at an index.
-	 *
-	 * @param {number} fromIndex Index of the element to remove.
-	 * @private
-	 */
-	function makeRemove(child, node) {
-	  // NOTE: Null values reduce hidden classes.
-	  return {
-	    type: 'REMOVE_NODE',
-	    content: null,
-	    fromIndex: child._mountIndex,
-	    fromNode: node,
-	    toIndex: null,
-	    afterNode: null
-	  };
-	}
-
-	/**
-	 * Make an update for setting the markup of a node.
-	 *
-	 * @param {string} markup Markup that renders into an element.
-	 * @private
-	 */
-	function makeSetMarkup(markup) {
-	  // NOTE: Null values reduce hidden classes.
-	  return {
-	    type: 'SET_MARKUP',
-	    content: markup,
-	    fromIndex: null,
-	    fromNode: null,
-	    toIndex: null,
-	    afterNode: null
-	  };
-	}
-
-	/**
-	 * Make an update for setting the text content.
-	 *
-	 * @param {string} textContent Text content to set.
-	 * @private
-	 */
-	function makeTextContent(textContent) {
-	  // NOTE: Null values reduce hidden classes.
-	  return {
-	    type: 'TEXT_CONTENT',
-	    content: textContent,
-	    fromIndex: null,
-	    fromNode: null,
-	    toIndex: null,
-	    afterNode: null
-	  };
-	}
-
-	/**
-	 * Push an update, if any, onto the queue. Creates a new queue if none is
-	 * passed and always returns the queue. Mutative.
-	 */
-	function enqueue(queue, update) {
-	  if (update) {
-	    queue = queue || [];
-	    queue.push(update);
-	  }
-	  return queue;
-	}
-
-	/**
-	 * Processes any enqueued updates.
-	 *
-	 * @private
-	 */
-	function processQueue(inst, updateQueue) {
-	  ReactComponentEnvironment.processChildrenUpdates(inst, updateQueue);
-	}
-
-	var setChildrenForInstrumentation = emptyFunction;
-	if (process.env.NODE_ENV !== 'production') {
-	  var getDebugID = function (inst) {
-	    if (!inst._debugID) {
-	      // Check for ART-like instances. TODO: This is silly/gross.
-	      var internal;
-	      if (internal = ReactInstanceMap.get(inst)) {
-	        inst = internal;
-	      }
-	    }
-	    return inst._debugID;
-	  };
-	  setChildrenForInstrumentation = function (children) {
-	    var debugID = getDebugID(this);
-	    // TODO: React Native empty components are also multichild.
-	    // This means they still get into this method but don't have _debugID.
-	    if (debugID !== 0) {
-	      ReactInstrumentation.debugTool.onSetChildren(debugID, children ? Object.keys(children).map(function (key) {
-	        return children[key]._debugID;
-	      }) : []);
-	    }
-	  };
-	}
-
-	/**
-	 * ReactMultiChild are capable of reconciling multiple children.
-	 *
-	 * @class ReactMultiChild
-	 * @internal
-	 */
-	var ReactMultiChild = {
-
-	  /**
-	   * Provides common functionality for components that must reconcile multiple
-	   * children. This is used by `ReactDOMComponent` to mount, update, and
-	   * unmount child components.
-	   *
-	   * @lends {ReactMultiChild.prototype}
-	   */
-	  Mixin: {
-
-	    _reconcilerInstantiateChildren: function (nestedChildren, transaction, context) {
-	      if (process.env.NODE_ENV !== 'production') {
-	        var selfDebugID = getDebugID(this);
-	        if (this._currentElement) {
-	          try {
-	            ReactCurrentOwner.current = this._currentElement._owner;
-	            return ReactChildReconciler.instantiateChildren(nestedChildren, transaction, context, selfDebugID);
-	          } finally {
-	            ReactCurrentOwner.current = null;
-	          }
-	        }
-	      }
-	      return ReactChildReconciler.instantiateChildren(nestedChildren, transaction, context);
-	    },
-
-	    _reconcilerUpdateChildren: function (prevChildren, nextNestedChildrenElements, mountImages, removedNodes, transaction, context) {
-	      var nextChildren;
-	      var selfDebugID = 0;
-	      if (process.env.NODE_ENV !== 'production') {
-	        selfDebugID = getDebugID(this);
-	        if (this._currentElement) {
-	          try {
-	            ReactCurrentOwner.current = this._currentElement._owner;
-	            nextChildren = flattenChildren(nextNestedChildrenElements, selfDebugID);
-	          } finally {
-	            ReactCurrentOwner.current = null;
-	          }
-	          ReactChildReconciler.updateChildren(prevChildren, nextChildren, mountImages, removedNodes, transaction, this, this._hostContainerInfo, context, selfDebugID);
-	          return nextChildren;
-	        }
-	      }
-	      nextChildren = flattenChildren(nextNestedChildrenElements, selfDebugID);
-	      ReactChildReconciler.updateChildren(prevChildren, nextChildren, mountImages, removedNodes, transaction, this, this._hostContainerInfo, context, selfDebugID);
-	      return nextChildren;
-	    },
-
-	    /**
-	     * Generates a "mount image" for each of the supplied children. In the case
-	     * of `ReactDOMComponent`, a mount image is a string of markup.
-	     *
-	     * @param {?object} nestedChildren Nested child maps.
-	     * @return {array} An array of mounted representations.
-	     * @internal
-	     */
-	    mountChildren: function (nestedChildren, transaction, context) {
-	      var children = this._reconcilerInstantiateChildren(nestedChildren, transaction, context);
-	      this._renderedChildren = children;
-
-	      var mountImages = [];
-	      var index = 0;
-	      for (var name in children) {
-	        if (children.hasOwnProperty(name)) {
-	          var child = children[name];
-	          var selfDebugID = 0;
-	          if (process.env.NODE_ENV !== 'production') {
-	            selfDebugID = getDebugID(this);
-	          }
-	          var mountImage = ReactReconciler.mountComponent(child, transaction, this, this._hostContainerInfo, context, selfDebugID);
-	          child._mountIndex = index++;
-	          mountImages.push(mountImage);
-	        }
-	      }
-
-	      if (process.env.NODE_ENV !== 'production') {
-	        setChildrenForInstrumentation.call(this, children);
-	      }
-
-	      return mountImages;
-	    },
-
-	    /**
-	     * Replaces any rendered children with a text content string.
-	     *
-	     * @param {string} nextContent String of content.
-	     * @internal
-	     */
-	    updateTextContent: function (nextContent) {
-	      var prevChildren = this._renderedChildren;
-	      // Remove any rendered children.
-	      ReactChildReconciler.unmountChildren(prevChildren, false);
-	      for (var name in prevChildren) {
-	        if (prevChildren.hasOwnProperty(name)) {
-	           true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'updateTextContent called on non-empty component.') : _prodInvariant('118') : void 0;
-	        }
-	      }
-	      // Set new text content.
-	      var updates = [makeTextContent(nextContent)];
-	      processQueue(this, updates);
-	    },
-
-	    /**
-	     * Replaces any rendered children with a markup string.
-	     *
-	     * @param {string} nextMarkup String of markup.
-	     * @internal
-	     */
-	    updateMarkup: function (nextMarkup) {
-	      var prevChildren = this._renderedChildren;
-	      // Remove any rendered children.
-	      ReactChildReconciler.unmountChildren(prevChildren, false);
-	      for (var name in prevChildren) {
-	        if (prevChildren.hasOwnProperty(name)) {
-	           true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'updateTextContent called on non-empty component.') : _prodInvariant('118') : void 0;
-	        }
-	      }
-	      var updates = [makeSetMarkup(nextMarkup)];
-	      processQueue(this, updates);
-	    },
-
-	    /**
-	     * Updates the rendered children with new children.
-	     *
-	     * @param {?object} nextNestedChildrenElements Nested child element maps.
-	     * @param {ReactReconcileTransaction} transaction
-	     * @internal
-	     */
-	    updateChildren: function (nextNestedChildrenElements, transaction, context) {
-	      // Hook used by React ART
-	      this._updateChildren(nextNestedChildrenElements, transaction, context);
-	    },
-
-	    /**
-	     * @param {?object} nextNestedChildrenElements Nested child element maps.
-	     * @param {ReactReconcileTransaction} transaction
-	     * @final
-	     * @protected
-	     */
-	    _updateChildren: function (nextNestedChildrenElements, transaction, context) {
-	      var prevChildren = this._renderedChildren;
-	      var removedNodes = {};
-	      var mountImages = [];
-	      var nextChildren = this._reconcilerUpdateChildren(prevChildren, nextNestedChildrenElements, mountImages, removedNodes, transaction, context);
-	      if (!nextChildren && !prevChildren) {
-	        return;
-	      }
-	      var updates = null;
-	      var name;
-	      // `nextIndex` will increment for each child in `nextChildren`, but
-	      // `lastIndex` will be the last index visited in `prevChildren`.
-	      var nextIndex = 0;
-	      var lastIndex = 0;
-	      // `nextMountIndex` will increment for each newly mounted child.
-	      var nextMountIndex = 0;
-	      var lastPlacedNode = null;
-	      for (name in nextChildren) {
-	        if (!nextChildren.hasOwnProperty(name)) {
-	          continue;
-	        }
-	        var prevChild = prevChildren && prevChildren[name];
-	        var nextChild = nextChildren[name];
-	        if (prevChild === nextChild) {
-	          updates = enqueue(updates, this.moveChild(prevChild, lastPlacedNode, nextIndex, lastIndex));
-	          lastIndex = Math.max(prevChild._mountIndex, lastIndex);
-	          prevChild._mountIndex = nextIndex;
-	        } else {
-	          if (prevChild) {
-	            // Update `lastIndex` before `_mountIndex` gets unset by unmounting.
-	            lastIndex = Math.max(prevChild._mountIndex, lastIndex);
-	            // The `removedNodes` loop below will actually remove the child.
-	          }
-	          // The child must be instantiated before it's mounted.
-	          updates = enqueue(updates, this._mountChildAtIndex(nextChild, mountImages[nextMountIndex], lastPlacedNode, nextIndex, transaction, context));
-	          nextMountIndex++;
-	        }
-	        nextIndex++;
-	        lastPlacedNode = ReactReconciler.getHostNode(nextChild);
-	      }
-	      // Remove children that are no longer present.
-	      for (name in removedNodes) {
-	        if (removedNodes.hasOwnProperty(name)) {
-	          updates = enqueue(updates, this._unmountChild(prevChildren[name], removedNodes[name]));
-	        }
-	      }
-	      if (updates) {
-	        processQueue(this, updates);
-	      }
-	      this._renderedChildren = nextChildren;
-
-	      if (process.env.NODE_ENV !== 'production') {
-	        setChildrenForInstrumentation.call(this, nextChildren);
-	      }
-	    },
-
-	    /**
-	     * Unmounts all rendered children. This should be used to clean up children
-	     * when this component is unmounted. It does not actually perform any
-	     * backend operations.
-	     *
-	     * @internal
-	     */
-	    unmountChildren: function (safely) {
-	      var renderedChildren = this._renderedChildren;
-	      ReactChildReconciler.unmountChildren(renderedChildren, safely);
-	      this._renderedChildren = null;
-	    },
-
-	    /**
-	     * Moves a child component to the supplied index.
-	     *
-	     * @param {ReactComponent} child Component to move.
-	     * @param {number} toIndex Destination index of the element.
-	     * @param {number} lastIndex Last index visited of the siblings of `child`.
-	     * @protected
-	     */
-	    moveChild: function (child, afterNode, toIndex, lastIndex) {
-	      // If the index of `child` is less than `lastIndex`, then it needs to
-	      // be moved. Otherwise, we do not need to move it because a child will be
-	      // inserted or moved before `child`.
-	      if (child._mountIndex < lastIndex) {
-	        return makeMove(child, afterNode, toIndex);
-	      }
-	    },
-
-	    /**
-	     * Creates a child component.
-	     *
-	     * @param {ReactComponent} child Component to create.
-	     * @param {string} mountImage Markup to insert.
-	     * @protected
-	     */
-	    createChild: function (child, afterNode, mountImage) {
-	      return makeInsertMarkup(mountImage, afterNode, child._mountIndex);
-	    },
-
-	    /**
-	     * Removes a child component.
-	     *
-	     * @param {ReactComponent} child Child to remove.
-	     * @protected
-	     */
-	    removeChild: function (child, node) {
-	      return makeRemove(child, node);
-	    },
-
-	    /**
-	     * Mounts a child with the supplied name.
-	     *
-	     * NOTE: This is part of `updateChildren` and is here for readability.
-	     *
-	     * @param {ReactComponent} child Component to mount.
-	     * @param {string} name Name of the child.
-	     * @param {number} index Index at which to insert the child.
-	     * @param {ReactReconcileTransaction} transaction
-	     * @private
-	     */
-	    _mountChildAtIndex: function (child, mountImage, afterNode, index, transaction, context) {
-	      child._mountIndex = index;
-	      return this.createChild(child, afterNode, mountImage);
-	    },
-
-	    /**
-	     * Unmounts a rendered child.
-	     *
-	     * NOTE: This is part of `updateChildren` and is here for readability.
-	     *
-	     * @param {ReactComponent} child Component to unmount.
-	     * @private
-	     */
-	    _unmountChild: function (child, node) {
-	      var update = this.removeChild(child, node);
-	      child._mountIndex = null;
-	      return update;
-	    }
-
-	  }
-
-	};
-
-	module.exports = ReactMultiChild;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 119 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2014-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var invariant = __webpack_require__(37);
-
-	var injected = false;
-
-	var ReactComponentEnvironment = {
-
-	  /**
-	   * Optionally injectable hook for swapping out mount images in the middle of
-	   * the tree.
-	   */
-	  replaceNodeWithMarkup: null,
-
-	  /**
-	   * Optionally injectable hook for processing a queue of child updates. Will
-	   * later move into MultiChildComponents.
-	   */
-	  processChildrenUpdates: null,
-
-	  injection: {
-	    injectEnvironment: function (environment) {
-	      !!injected ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactCompositeComponent: injectEnvironment() can only be called once.') : _prodInvariant('104') : void 0;
-	      ReactComponentEnvironment.replaceNodeWithMarkup = environment.replaceNodeWithMarkup;
-	      ReactComponentEnvironment.processChildrenUpdates = environment.processChildrenUpdates;
-	      injected = true;
-	    }
-	  }
-
-	};
-
-	module.exports = ReactComponentEnvironment;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 120 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	/**
-	 * `ReactInstanceMap` maintains a mapping from a public facing stateful
-	 * instance (key) and the internal representation (value). This allows public
-	 * methods to accept the user facing instance as an argument and map them back
-	 * to internal methods.
-	 */
-
-	// TODO: Replace this with ES6: var ReactInstanceMap = new Map();
-
-	var ReactInstanceMap = {
-
-	  /**
-	   * This API should be called `delete` but we'd have to make sure to always
-	   * transform these to strings for IE support. When this transform is fully
-	   * supported we can rename it.
-	   */
-	  remove: function (key) {
-	    key._reactInternalInstance = undefined;
-	  },
-
-	  get: function (key) {
-	    return key._reactInternalInstance;
-	  },
-
-	  has: function (key) {
-	    return key._reactInternalInstance !== undefined;
-	  },
-
-	  set: function (key, value) {
-	    key._reactInternalInstance = value;
-	  }
-
-	};
-
-	module.exports = ReactInstanceMap;
-
-/***/ },
-/* 121 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2014-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ReactReconciler = __webpack_require__(63);
-
-	var instantiateReactComponent = __webpack_require__(122);
-	var KeyEscapeUtils = __webpack_require__(133);
-	var shouldUpdateReactComponent = __webpack_require__(129);
-	var traverseAllChildren = __webpack_require__(134);
-	var warning = __webpack_require__(47);
-
-	var ReactComponentTreeHook;
-
-	if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV === 'test') {
-	  // Temporary hack.
-	  // Inline requires don't work well with Jest:
-	  // https://github.com/facebook/react/issues/7240
-	  // Remove the inline requires when we don't need them anymore:
-	  // https://github.com/facebook/react/pull/7178
-	  ReactComponentTreeHook = __webpack_require__(26);
-	}
-
-	function instantiateChild(childInstances, child, name, selfDebugID) {
-	  // We found a component instance.
-	  var keyUnique = childInstances[name] === undefined;
-	  if (process.env.NODE_ENV !== 'production') {
-	    if (!ReactComponentTreeHook) {
-	      ReactComponentTreeHook = __webpack_require__(26);
-	    }
-	    if (!keyUnique) {
-	      process.env.NODE_ENV !== 'production' ? warning(false, 'flattenChildren(...): Encountered two children with the same key, ' + '`%s`. Child keys must be unique; when two children share a key, only ' + 'the first child will be used.%s', KeyEscapeUtils.unescape(name), ReactComponentTreeHook.getStackAddendumByID(selfDebugID)) : void 0;
-	    }
-	  }
-	  if (child != null && keyUnique) {
-	    childInstances[name] = instantiateReactComponent(child, true);
-	  }
-	}
-
-	/**
-	 * ReactChildReconciler provides helpers for initializing or updating a set of
-	 * children. Its output is suitable for passing it onto ReactMultiChild which
-	 * does diffed reordering and insertion.
-	 */
-	var ReactChildReconciler = {
-	  /**
-	   * Generates a "mount image" for each of the supplied children. In the case
-	   * of `ReactDOMComponent`, a mount image is a string of markup.
-	   *
-	   * @param {?object} nestedChildNodes Nested child maps.
-	   * @return {?object} A set of child instances.
-	   * @internal
-	   */
-	  instantiateChildren: function (nestedChildNodes, transaction, context, selfDebugID // 0 in production and for roots
-	  ) {
-	    if (nestedChildNodes == null) {
-	      return null;
-	    }
-	    var childInstances = {};
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      traverseAllChildren(nestedChildNodes, function (childInsts, child, name) {
-	        return instantiateChild(childInsts, child, name, selfDebugID);
-	      }, childInstances);
-	    } else {
-	      traverseAllChildren(nestedChildNodes, instantiateChild, childInstances);
-	    }
-	    return childInstances;
-	  },
-
-	  /**
-	   * Updates the rendered children and returns a new set of children.
-	   *
-	   * @param {?object} prevChildren Previously initialized set of children.
-	   * @param {?object} nextChildren Flat child element maps.
-	   * @param {ReactReconcileTransaction} transaction
-	   * @param {object} context
-	   * @return {?object} A new set of child instances.
-	   * @internal
-	   */
-	  updateChildren: function (prevChildren, nextChildren, mountImages, removedNodes, transaction, hostParent, hostContainerInfo, context, selfDebugID // 0 in production and for roots
-	  ) {
-	    // We currently don't have a way to track moves here but if we use iterators
-	    // instead of for..in we can zip the iterators and check if an item has
-	    // moved.
-	    // TODO: If nothing has changed, return the prevChildren object so that we
-	    // can quickly bailout if nothing has changed.
-	    if (!nextChildren && !prevChildren) {
-	      return;
-	    }
-	    var name;
-	    var prevChild;
-	    for (name in nextChildren) {
-	      if (!nextChildren.hasOwnProperty(name)) {
-	        continue;
-	      }
-	      prevChild = prevChildren && prevChildren[name];
-	      var prevElement = prevChild && prevChild._currentElement;
-	      var nextElement = nextChildren[name];
-	      if (prevChild != null && shouldUpdateReactComponent(prevElement, nextElement)) {
-	        ReactReconciler.receiveComponent(prevChild, nextElement, transaction, context);
-	        nextChildren[name] = prevChild;
-	      } else {
-	        if (prevChild) {
-	          removedNodes[name] = ReactReconciler.getHostNode(prevChild);
-	          ReactReconciler.unmountComponent(prevChild, false);
-	        }
-	        // The child must be instantiated before it's mounted.
-	        var nextChildInstance = instantiateReactComponent(nextElement, true);
-	        nextChildren[name] = nextChildInstance;
-	        // Creating mount image now ensures refs are resolved in right order
-	        // (see https://github.com/facebook/react/pull/7101 for explanation).
-	        var nextChildMountImage = ReactReconciler.mountComponent(nextChildInstance, transaction, hostParent, hostContainerInfo, context, selfDebugID);
-	        mountImages.push(nextChildMountImage);
-	      }
-	    }
-	    // Unmount children that are no longer present.
-	    for (name in prevChildren) {
-	      if (prevChildren.hasOwnProperty(name) && !(nextChildren && nextChildren.hasOwnProperty(name))) {
-	        prevChild = prevChildren[name];
-	        removedNodes[name] = ReactReconciler.getHostNode(prevChild);
-	        ReactReconciler.unmountComponent(prevChild, false);
-	      }
-	    }
-	  },
-
-	  /**
-	   * Unmounts all rendered children. This should be used to clean up children
-	   * when this component is unmounted.
-	   *
-	   * @param {?object} renderedChildren Previously initialized set of children.
-	   * @internal
-	   */
-	  unmountChildren: function (renderedChildren, safely) {
-	    for (var name in renderedChildren) {
-	      if (renderedChildren.hasOwnProperty(name)) {
-	        var renderedChild = renderedChildren[name];
-	        ReactReconciler.unmountComponent(renderedChild, safely);
-	      }
-	    }
-	  }
-
-	};
-
-	module.exports = ReactChildReconciler;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 122 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35),
-	    _assign = __webpack_require__(53);
-
-	var ReactCompositeComponent = __webpack_require__(123);
-	var ReactEmptyComponent = __webpack_require__(130);
-	var ReactHostComponent = __webpack_require__(131);
-
-	var getNextDebugID = __webpack_require__(132);
-	var invariant = __webpack_require__(37);
-	var warning = __webpack_require__(47);
-
-	// To avoid a cyclic dependency, we create the final class in this module
-	var ReactCompositeComponentWrapper = function (element) {
-	  this.construct(element);
-	};
-	_assign(ReactCompositeComponentWrapper.prototype, ReactCompositeComponent, {
-	  _instantiateReactComponent: instantiateReactComponent
-	});
-
-	function getDeclarationErrorAddendum(owner) {
-	  if (owner) {
-	    var name = owner.getName();
-	    if (name) {
-	      return ' Check the render method of `' + name + '`.';
-	    }
-	  }
-	  return '';
-	}
-
-	/**
-	 * Check if the type reference is a known internal type. I.e. not a user
-	 * provided composite type.
-	 *
-	 * @param {function} type
-	 * @return {boolean} Returns true if this is a valid internal type.
-	 */
-	function isInternalComponentType(type) {
-	  return typeof type === 'function' && typeof type.prototype !== 'undefined' && typeof type.prototype.mountComponent === 'function' && typeof type.prototype.receiveComponent === 'function';
-	}
-
-	/**
-	 * Given a ReactNode, create an instance that will actually be mounted.
-	 *
-	 * @param {ReactNode} node
-	 * @param {boolean} shouldHaveDebugID
-	 * @return {object} A new instance of the element's constructor.
-	 * @protected
-	 */
-	function instantiateReactComponent(node, shouldHaveDebugID) {
-	  var instance;
-
-	  if (node === null || node === false) {
-	    instance = ReactEmptyComponent.create(instantiateReactComponent);
-	  } else if (typeof node === 'object') {
-	    var element = node;
-	    !(element && (typeof element.type === 'function' || typeof element.type === 'string')) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s', element.type == null ? element.type : typeof element.type, getDeclarationErrorAddendum(element._owner)) : _prodInvariant('130', element.type == null ? element.type : typeof element.type, getDeclarationErrorAddendum(element._owner)) : void 0;
-
-	    // Special case string values
-	    if (typeof element.type === 'string') {
-	      instance = ReactHostComponent.createInternalComponent(element);
-	    } else if (isInternalComponentType(element.type)) {
-	      // This is temporarily available for custom components that are not string
-	      // representations. I.e. ART. Once those are updated to use the string
-	      // representation, we can drop this code path.
-	      instance = new element.type(element);
-
-	      // We renamed this. Allow the old name for compat. :(
-	      if (!instance.getHostNode) {
-	        instance.getHostNode = instance.getNativeNode;
-	      }
-	    } else {
-	      instance = new ReactCompositeComponentWrapper(element);
-	    }
-	  } else if (typeof node === 'string' || typeof node === 'number') {
-	    instance = ReactHostComponent.createInstanceForText(node);
-	  } else {
-	     true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Encountered invalid React node of type %s', typeof node) : _prodInvariant('131', typeof node) : void 0;
-	  }
-
-	  if (process.env.NODE_ENV !== 'production') {
-	    process.env.NODE_ENV !== 'production' ? warning(typeof instance.mountComponent === 'function' && typeof instance.receiveComponent === 'function' && typeof instance.getHostNode === 'function' && typeof instance.unmountComponent === 'function', 'Only React Components can be mounted.') : void 0;
-	  }
-
-	  // These two fields are used by the DOM and ART diffing algorithms
-	  // respectively. Instead of using expandos on components, we should be
-	  // storing the state needed by the diffing algorithms elsewhere.
-	  instance._mountIndex = 0;
-	  instance._mountImage = null;
-
-	  if (process.env.NODE_ENV !== 'production') {
-	    instance._debugID = shouldHaveDebugID ? getNextDebugID() : 0;
-	  }
-
-	  // Internal instances should fully constructed at this point, so they should
-	  // not get any new fields added to them at this point.
-	  if (process.env.NODE_ENV !== 'production') {
-	    if (Object.preventExtensions) {
-	      Object.preventExtensions(instance);
-	    }
-	  }
-
-	  return instance;
-	}
-
-	module.exports = instantiateReactComponent;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 123 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35),
-	    _assign = __webpack_require__(53);
-
-	var React = __webpack_require__(2);
-	var ReactComponentEnvironment = __webpack_require__(119);
-	var ReactCurrentOwner = __webpack_require__(10);
-	var ReactErrorUtils = __webpack_require__(46);
-	var ReactInstanceMap = __webpack_require__(120);
-	var ReactInstrumentation = __webpack_require__(66);
-	var ReactNodeTypes = __webpack_require__(124);
-	var ReactReconciler = __webpack_require__(63);
-
-	if (process.env.NODE_ENV !== 'production') {
-	  var checkReactTypeSpec = __webpack_require__(125);
-	}
-
-	var emptyObject = __webpack_require__(127);
-	var invariant = __webpack_require__(37);
-	var shallowEqual = __webpack_require__(128);
-	var shouldUpdateReactComponent = __webpack_require__(129);
-	var warning = __webpack_require__(47);
-
-	var CompositeTypes = {
-	  ImpureClass: 0,
-	  PureClass: 1,
-	  StatelessFunctional: 2
-	};
-
-	function StatelessComponent(Component) {}
-	StatelessComponent.prototype.render = function () {
-	  var Component = ReactInstanceMap.get(this)._currentElement.type;
-	  var element = Component(this.props, this.context, this.updater);
-	  warnIfInvalidElement(Component, element);
-	  return element;
-	};
-
-	function warnIfInvalidElement(Component, element) {
-	  if (process.env.NODE_ENV !== 'production') {
-	    process.env.NODE_ENV !== 'production' ? warning(element === null || element === false || React.isValidElement(element), '%s(...): A valid React element (or null) must be returned. You may have ' + 'returned undefined, an array or some other invalid object.', Component.displayName || Component.name || 'Component') : void 0;
-	    process.env.NODE_ENV !== 'production' ? warning(!Component.childContextTypes, '%s(...): childContextTypes cannot be defined on a functional component.', Component.displayName || Component.name || 'Component') : void 0;
-	  }
-	}
-
-	function shouldConstruct(Component) {
-	  return !!(Component.prototype && Component.prototype.isReactComponent);
-	}
-
-	function isPureComponent(Component) {
-	  return !!(Component.prototype && Component.prototype.isPureReactComponent);
-	}
-
-	// Separated into a function to contain deoptimizations caused by try/finally.
-	function measureLifeCyclePerf(fn, debugID, timerType) {
-	  if (debugID === 0) {
-	    // Top-level wrappers (see ReactMount) and empty components (see
-	    // ReactDOMEmptyComponent) are invisible to hooks and devtools.
-	    // Both are implementation details that should go away in the future.
-	    return fn();
-	  }
-
-	  ReactInstrumentation.debugTool.onBeginLifeCycleTimer(debugID, timerType);
-	  try {
-	    return fn();
-	  } finally {
-	    ReactInstrumentation.debugTool.onEndLifeCycleTimer(debugID, timerType);
-	  }
-	}
-
-	/**
-	 * ------------------ The Life-Cycle of a Composite Component ------------------
-	 *
-	 * - constructor: Initialization of state. The instance is now retained.
-	 *   - componentWillMount
-	 *   - render
-	 *   - [children's constructors]
-	 *     - [children's componentWillMount and render]
-	 *     - [children's componentDidMount]
-	 *     - componentDidMount
-	 *
-	 *       Update Phases:
-	 *       - componentWillReceiveProps (only called if parent updated)
-	 *       - shouldComponentUpdate
-	 *         - componentWillUpdate
-	 *           - render
-	 *           - [children's constructors or receive props phases]
-	 *         - componentDidUpdate
-	 *
-	 *     - componentWillUnmount
-	 *     - [children's componentWillUnmount]
-	 *   - [children destroyed]
-	 * - (destroyed): The instance is now blank, released by React and ready for GC.
-	 *
-	 * -----------------------------------------------------------------------------
-	 */
-
-	/**
-	 * An incrementing ID assigned to each component when it is mounted. This is
-	 * used to enforce the order in which `ReactUpdates` updates dirty components.
-	 *
-	 * @private
-	 */
-	var nextMountID = 1;
-
-	/**
-	 * @lends {ReactCompositeComponent.prototype}
-	 */
-	var ReactCompositeComponent = {
-
-	  /**
-	   * Base constructor for all composite component.
-	   *
-	   * @param {ReactElement} element
-	   * @final
-	   * @internal
-	   */
-	  construct: function (element) {
-	    this._currentElement = element;
-	    this._rootNodeID = 0;
-	    this._compositeType = null;
-	    this._instance = null;
-	    this._hostParent = null;
-	    this._hostContainerInfo = null;
-
-	    // See ReactUpdateQueue
-	    this._updateBatchNumber = null;
-	    this._pendingElement = null;
-	    this._pendingStateQueue = null;
-	    this._pendingReplaceState = false;
-	    this._pendingForceUpdate = false;
-
-	    this._renderedNodeType = null;
-	    this._renderedComponent = null;
-	    this._context = null;
-	    this._mountOrder = 0;
-	    this._topLevelWrapper = null;
-
-	    // See ReactUpdates and ReactUpdateQueue.
-	    this._pendingCallbacks = null;
-
-	    // ComponentWillUnmount shall only be called once
-	    this._calledComponentWillUnmount = false;
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      this._warnedAboutRefsInRender = false;
-	    }
-	  },
-
-	  /**
-	   * Initializes the component, renders markup, and registers event listeners.
-	   *
-	   * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
-	   * @param {?object} hostParent
-	   * @param {?object} hostContainerInfo
-	   * @param {?object} context
-	   * @return {?string} Rendered markup to be inserted into the DOM.
-	   * @final
-	   * @internal
-	   */
-	  mountComponent: function (transaction, hostParent, hostContainerInfo, context) {
-	    var _this = this;
-
-	    this._context = context;
-	    this._mountOrder = nextMountID++;
-	    this._hostParent = hostParent;
-	    this._hostContainerInfo = hostContainerInfo;
-
-	    var publicProps = this._currentElement.props;
-	    var publicContext = this._processContext(context);
-
-	    var Component = this._currentElement.type;
-
-	    var updateQueue = transaction.getUpdateQueue();
-
-	    // Initialize the public class
-	    var doConstruct = shouldConstruct(Component);
-	    var inst = this._constructComponent(doConstruct, publicProps, publicContext, updateQueue);
-	    var renderedElement;
-
-	    // Support functional components
-	    if (!doConstruct && (inst == null || inst.render == null)) {
-	      renderedElement = inst;
-	      warnIfInvalidElement(Component, renderedElement);
-	      !(inst === null || inst === false || React.isValidElement(inst)) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s(...): A valid React element (or null) must be returned. You may have returned undefined, an array or some other invalid object.', Component.displayName || Component.name || 'Component') : _prodInvariant('105', Component.displayName || Component.name || 'Component') : void 0;
-	      inst = new StatelessComponent(Component);
-	      this._compositeType = CompositeTypes.StatelessFunctional;
-	    } else {
-	      if (isPureComponent(Component)) {
-	        this._compositeType = CompositeTypes.PureClass;
-	      } else {
-	        this._compositeType = CompositeTypes.ImpureClass;
-	      }
-	    }
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      // This will throw later in _renderValidatedComponent, but add an early
-	      // warning now to help debugging
-	      if (inst.render == null) {
-	        process.env.NODE_ENV !== 'production' ? warning(false, '%s(...): No `render` method found on the returned component ' + 'instance: you may have forgotten to define `render`.', Component.displayName || Component.name || 'Component') : void 0;
-	      }
-
-	      var propsMutated = inst.props !== publicProps;
-	      var componentName = Component.displayName || Component.name || 'Component';
-
-	      process.env.NODE_ENV !== 'production' ? warning(inst.props === undefined || !propsMutated, '%s(...): When calling super() in `%s`, make sure to pass ' + 'up the same props that your component\'s constructor was passed.', componentName, componentName) : void 0;
-	    }
-
-	    // These should be set up in the constructor, but as a convenience for
-	    // simpler class abstractions, we set them up after the fact.
-	    inst.props = publicProps;
-	    inst.context = publicContext;
-	    inst.refs = emptyObject;
-	    inst.updater = updateQueue;
-
-	    this._instance = inst;
-
-	    // Store a reference from the instance back to the internal representation
-	    ReactInstanceMap.set(inst, this);
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      // Since plain JS classes are defined without any special initialization
-	      // logic, we can not catch common errors early. Therefore, we have to
-	      // catch them here, at initialization time, instead.
-	      process.env.NODE_ENV !== 'production' ? warning(!inst.getInitialState || inst.getInitialState.isReactClassApproved, 'getInitialState was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Did you mean to define a state property instead?', this.getName() || 'a component') : void 0;
-	      process.env.NODE_ENV !== 'production' ? warning(!inst.getDefaultProps || inst.getDefaultProps.isReactClassApproved, 'getDefaultProps was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Use a static property to define defaultProps instead.', this.getName() || 'a component') : void 0;
-	      process.env.NODE_ENV !== 'production' ? warning(!inst.propTypes, 'propTypes was defined as an instance property on %s. Use a static ' + 'property to define propTypes instead.', this.getName() || 'a component') : void 0;
-	      process.env.NODE_ENV !== 'production' ? warning(!inst.contextTypes, 'contextTypes was defined as an instance property on %s. Use a ' + 'static property to define contextTypes instead.', this.getName() || 'a component') : void 0;
-	      process.env.NODE_ENV !== 'production' ? warning(typeof inst.componentShouldUpdate !== 'function', '%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', this.getName() || 'A component') : void 0;
-	      process.env.NODE_ENV !== 'production' ? warning(typeof inst.componentDidUnmount !== 'function', '%s has a method called ' + 'componentDidUnmount(). But there is no such lifecycle method. ' + 'Did you mean componentWillUnmount()?', this.getName() || 'A component') : void 0;
-	      process.env.NODE_ENV !== 'production' ? warning(typeof inst.componentWillRecieveProps !== 'function', '%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', this.getName() || 'A component') : void 0;
-	    }
-
-	    var initialState = inst.state;
-	    if (initialState === undefined) {
-	      inst.state = initialState = null;
-	    }
-	    !(typeof initialState === 'object' && !Array.isArray(initialState)) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.state: must be set to an object or null', this.getName() || 'ReactCompositeComponent') : _prodInvariant('106', this.getName() || 'ReactCompositeComponent') : void 0;
-
-	    this._pendingStateQueue = null;
-	    this._pendingReplaceState = false;
-	    this._pendingForceUpdate = false;
-
-	    var markup;
-	    if (inst.unstable_handleError) {
-	      markup = this.performInitialMountWithErrorHandling(renderedElement, hostParent, hostContainerInfo, transaction, context);
-	    } else {
-	      markup = this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context);
-	    }
-
-	    if (inst.componentDidMount) {
-	      if (process.env.NODE_ENV !== 'production') {
-	        transaction.getReactMountReady().enqueue(function () {
-	          measureLifeCyclePerf(function () {
-	            return inst.componentDidMount();
-	          }, _this._debugID, 'componentDidMount');
-	        });
-	      } else {
-	        transaction.getReactMountReady().enqueue(inst.componentDidMount, inst);
-	      }
-	    }
-
-	    return markup;
-	  },
-
-	  _constructComponent: function (doConstruct, publicProps, publicContext, updateQueue) {
-	    if (process.env.NODE_ENV !== 'production') {
-	      ReactCurrentOwner.current = this;
-	      try {
-	        return this._constructComponentWithoutOwner(doConstruct, publicProps, publicContext, updateQueue);
-	      } finally {
-	        ReactCurrentOwner.current = null;
-	      }
-	    } else {
-	      return this._constructComponentWithoutOwner(doConstruct, publicProps, publicContext, updateQueue);
-	    }
-	  },
-
-	  _constructComponentWithoutOwner: function (doConstruct, publicProps, publicContext, updateQueue) {
-	    var Component = this._currentElement.type;
-
-	    if (doConstruct) {
-	      if (process.env.NODE_ENV !== 'production') {
-	        return measureLifeCyclePerf(function () {
-	          return new Component(publicProps, publicContext, updateQueue);
-	        }, this._debugID, 'ctor');
-	      } else {
-	        return new Component(publicProps, publicContext, updateQueue);
-	      }
-	    }
-
-	    // This can still be an instance in case of factory components
-	    // but we'll count this as time spent rendering as the more common case.
-	    if (process.env.NODE_ENV !== 'production') {
-	      return measureLifeCyclePerf(function () {
-	        return Component(publicProps, publicContext, updateQueue);
-	      }, this._debugID, 'render');
-	    } else {
-	      return Component(publicProps, publicContext, updateQueue);
-	    }
-	  },
-
-	  performInitialMountWithErrorHandling: function (renderedElement, hostParent, hostContainerInfo, transaction, context) {
-	    var markup;
-	    var checkpoint = transaction.checkpoint();
-	    try {
-	      markup = this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context);
-	    } catch (e) {
-	      // Roll back to checkpoint, handle error (which may add items to the transaction), and take a new checkpoint
-	      transaction.rollback(checkpoint);
-	      this._instance.unstable_handleError(e);
-	      if (this._pendingStateQueue) {
-	        this._instance.state = this._processPendingState(this._instance.props, this._instance.context);
-	      }
-	      checkpoint = transaction.checkpoint();
-
-	      this._renderedComponent.unmountComponent(true);
-	      transaction.rollback(checkpoint);
-
-	      // Try again - we've informed the component about the error, so they can render an error message this time.
-	      // If this throws again, the error will bubble up (and can be caught by a higher error boundary).
-	      markup = this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context);
-	    }
-	    return markup;
-	  },
-
-	  performInitialMount: function (renderedElement, hostParent, hostContainerInfo, transaction, context) {
-	    var inst = this._instance;
-
-	    var debugID = 0;
-	    if (process.env.NODE_ENV !== 'production') {
-	      debugID = this._debugID;
-	    }
-
-	    if (inst.componentWillMount) {
-	      if (process.env.NODE_ENV !== 'production') {
-	        measureLifeCyclePerf(function () {
-	          return inst.componentWillMount();
-	        }, debugID, 'componentWillMount');
-	      } else {
-	        inst.componentWillMount();
-	      }
-	      // When mounting, calls to `setState` by `componentWillMount` will set
-	      // `this._pendingStateQueue` without triggering a re-render.
-	      if (this._pendingStateQueue) {
-	        inst.state = this._processPendingState(inst.props, inst.context);
-	      }
-	    }
-
-	    // If not a stateless component, we now render
-	    if (renderedElement === undefined) {
-	      renderedElement = this._renderValidatedComponent();
-	    }
-
-	    var nodeType = ReactNodeTypes.getType(renderedElement);
-	    this._renderedNodeType = nodeType;
-	    var child = this._instantiateReactComponent(renderedElement, nodeType !== ReactNodeTypes.EMPTY /* shouldHaveDebugID */
-	    );
-	    this._renderedComponent = child;
-
-	    var markup = ReactReconciler.mountComponent(child, transaction, hostParent, hostContainerInfo, this._processChildContext(context), debugID);
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      if (debugID !== 0) {
-	        var childDebugIDs = child._debugID !== 0 ? [child._debugID] : [];
-	        ReactInstrumentation.debugTool.onSetChildren(debugID, childDebugIDs);
-	      }
-	    }
-
-	    return markup;
-	  },
-
-	  getHostNode: function () {
-	    return ReactReconciler.getHostNode(this._renderedComponent);
-	  },
-
-	  /**
-	   * Releases any resources allocated by `mountComponent`.
-	   *
-	   * @final
-	   * @internal
-	   */
-	  unmountComponent: function (safely) {
-	    if (!this._renderedComponent) {
-	      return;
-	    }
-
-	    var inst = this._instance;
-
-	    if (inst.componentWillUnmount && !inst._calledComponentWillUnmount) {
-	      inst._calledComponentWillUnmount = true;
-
-	      if (safely) {
-	        var name = this.getName() + '.componentWillUnmount()';
-	        ReactErrorUtils.invokeGuardedCallback(name, inst.componentWillUnmount.bind(inst));
-	      } else {
-	        if (process.env.NODE_ENV !== 'production') {
-	          measureLifeCyclePerf(function () {
-	            return inst.componentWillUnmount();
-	          }, this._debugID, 'componentWillUnmount');
-	        } else {
-	          inst.componentWillUnmount();
-	        }
-	      }
-	    }
-
-	    if (this._renderedComponent) {
-	      ReactReconciler.unmountComponent(this._renderedComponent, safely);
-	      this._renderedNodeType = null;
-	      this._renderedComponent = null;
-	      this._instance = null;
-	    }
-
-	    // Reset pending fields
-	    // Even if this component is scheduled for another update in ReactUpdates,
-	    // it would still be ignored because these fields are reset.
-	    this._pendingStateQueue = null;
-	    this._pendingReplaceState = false;
-	    this._pendingForceUpdate = false;
-	    this._pendingCallbacks = null;
-	    this._pendingElement = null;
-
-	    // These fields do not really need to be reset since this object is no
-	    // longer accessible.
-	    this._context = null;
-	    this._rootNodeID = 0;
-	    this._topLevelWrapper = null;
-
-	    // Delete the reference from the instance to this internal representation
-	    // which allow the internals to be properly cleaned up even if the user
-	    // leaks a reference to the public instance.
-	    ReactInstanceMap.remove(inst);
-
-	    // Some existing components rely on inst.props even after they've been
-	    // destroyed (in event handlers).
-	    // TODO: inst.props = null;
-	    // TODO: inst.state = null;
-	    // TODO: inst.context = null;
-	  },
-
-	  /**
-	   * Filters the context object to only contain keys specified in
-	   * `contextTypes`
-	   *
-	   * @param {object} context
-	   * @return {?object}
-	   * @private
-	   */
-	  _maskContext: function (context) {
-	    var Component = this._currentElement.type;
-	    var contextTypes = Component.contextTypes;
-	    if (!contextTypes) {
-	      return emptyObject;
-	    }
-	    var maskedContext = {};
-	    for (var contextName in contextTypes) {
-	      maskedContext[contextName] = context[contextName];
-	    }
-	    return maskedContext;
-	  },
-
-	  /**
-	   * Filters the context object to only contain keys specified in
-	   * `contextTypes`, and asserts that they are valid.
-	   *
-	   * @param {object} context
-	   * @return {?object}
-	   * @private
-	   */
-	  _processContext: function (context) {
-	    var maskedContext = this._maskContext(context);
-	    if (process.env.NODE_ENV !== 'production') {
-	      var Component = this._currentElement.type;
-	      if (Component.contextTypes) {
-	        this._checkContextTypes(Component.contextTypes, maskedContext, 'context');
-	      }
-	    }
-	    return maskedContext;
-	  },
-
-	  /**
-	   * @param {object} currentContext
-	   * @return {object}
-	   * @private
-	   */
-	  _processChildContext: function (currentContext) {
-	    var Component = this._currentElement.type;
-	    var inst = this._instance;
-	    var childContext;
-
-	    if (inst.getChildContext) {
-	      if (process.env.NODE_ENV !== 'production') {
-	        ReactInstrumentation.debugTool.onBeginProcessingChildContext();
-	        try {
-	          childContext = inst.getChildContext();
-	        } finally {
-	          ReactInstrumentation.debugTool.onEndProcessingChildContext();
-	        }
-	      } else {
-	        childContext = inst.getChildContext();
-	      }
-	    }
-
-	    if (childContext) {
-	      !(typeof Component.childContextTypes === 'object') ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.getChildContext(): childContextTypes must be defined in order to use getChildContext().', this.getName() || 'ReactCompositeComponent') : _prodInvariant('107', this.getName() || 'ReactCompositeComponent') : void 0;
-	      if (process.env.NODE_ENV !== 'production') {
-	        this._checkContextTypes(Component.childContextTypes, childContext, 'childContext');
-	      }
-	      for (var name in childContext) {
-	        !(name in Component.childContextTypes) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', this.getName() || 'ReactCompositeComponent', name) : _prodInvariant('108', this.getName() || 'ReactCompositeComponent', name) : void 0;
-	      }
-	      return _assign({}, currentContext, childContext);
-	    }
-	    return currentContext;
-	  },
-
-	  /**
-	   * Assert that the context types are valid
-	   *
-	   * @param {object} typeSpecs Map of context field to a ReactPropType
-	   * @param {object} values Runtime values that need to be type-checked
-	   * @param {string} location e.g. "prop", "context", "child context"
-	   * @private
-	   */
-	  _checkContextTypes: function (typeSpecs, values, location) {
-	    if (process.env.NODE_ENV !== 'production') {
-	      checkReactTypeSpec(typeSpecs, values, location, this.getName(), null, this._debugID);
-	    }
-	  },
-
-	  receiveComponent: function (nextElement, transaction, nextContext) {
-	    var prevElement = this._currentElement;
-	    var prevContext = this._context;
-
-	    this._pendingElement = null;
-
-	    this.updateComponent(transaction, prevElement, nextElement, prevContext, nextContext);
-	  },
-
-	  /**
-	   * If any of `_pendingElement`, `_pendingStateQueue`, or `_pendingForceUpdate`
-	   * is set, update the component.
-	   *
-	   * @param {ReactReconcileTransaction} transaction
-	   * @internal
-	   */
-	  performUpdateIfNecessary: function (transaction) {
-	    if (this._pendingElement != null) {
-	      ReactReconciler.receiveComponent(this, this._pendingElement, transaction, this._context);
-	    } else if (this._pendingStateQueue !== null || this._pendingForceUpdate) {
-	      this.updateComponent(transaction, this._currentElement, this._currentElement, this._context, this._context);
-	    } else {
-	      this._updateBatchNumber = null;
-	    }
-	  },
-
-	  /**
-	   * Perform an update to a mounted component. The componentWillReceiveProps and
-	   * shouldComponentUpdate methods are called, then (assuming the update isn't
-	   * skipped) the remaining update lifecycle methods are called and the DOM
-	   * representation is updated.
-	   *
-	   * By default, this implements React's rendering and reconciliation algorithm.
-	   * Sophisticated clients may wish to override this.
-	   *
-	   * @param {ReactReconcileTransaction} transaction
-	   * @param {ReactElement} prevParentElement
-	   * @param {ReactElement} nextParentElement
-	   * @internal
-	   * @overridable
-	   */
-	  updateComponent: function (transaction, prevParentElement, nextParentElement, prevUnmaskedContext, nextUnmaskedContext) {
-	    var inst = this._instance;
-	    !(inst != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Attempted to update component `%s` that has already been unmounted (or failed to mount).', this.getName() || 'ReactCompositeComponent') : _prodInvariant('136', this.getName() || 'ReactCompositeComponent') : void 0;
-
-	    var willReceive = false;
-	    var nextContext;
-
-	    // Determine if the context has changed or not
-	    if (this._context === nextUnmaskedContext) {
-	      nextContext = inst.context;
-	    } else {
-	      nextContext = this._processContext(nextUnmaskedContext);
-	      willReceive = true;
-	    }
-
-	    var prevProps = prevParentElement.props;
-	    var nextProps = nextParentElement.props;
-
-	    // Not a simple state update but a props update
-	    if (prevParentElement !== nextParentElement) {
-	      willReceive = true;
-	    }
-
-	    // An update here will schedule an update but immediately set
-	    // _pendingStateQueue which will ensure that any state updates gets
-	    // immediately reconciled instead of waiting for the next batch.
-	    if (willReceive && inst.componentWillReceiveProps) {
-	      if (process.env.NODE_ENV !== 'production') {
-	        measureLifeCyclePerf(function () {
-	          return inst.componentWillReceiveProps(nextProps, nextContext);
-	        }, this._debugID, 'componentWillReceiveProps');
-	      } else {
-	        inst.componentWillReceiveProps(nextProps, nextContext);
-	      }
-	    }
-
-	    var nextState = this._processPendingState(nextProps, nextContext);
-	    var shouldUpdate = true;
-
-	    if (!this._pendingForceUpdate) {
-	      if (inst.shouldComponentUpdate) {
-	        if (process.env.NODE_ENV !== 'production') {
-	          shouldUpdate = measureLifeCyclePerf(function () {
-	            return inst.shouldComponentUpdate(nextProps, nextState, nextContext);
-	          }, this._debugID, 'shouldComponentUpdate');
-	        } else {
-	          shouldUpdate = inst.shouldComponentUpdate(nextProps, nextState, nextContext);
-	        }
-	      } else {
-	        if (this._compositeType === CompositeTypes.PureClass) {
-	          shouldUpdate = !shallowEqual(prevProps, nextProps) || !shallowEqual(inst.state, nextState);
-	        }
-	      }
-	    }
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      process.env.NODE_ENV !== 'production' ? warning(shouldUpdate !== undefined, '%s.shouldComponentUpdate(): Returned undefined instead of a ' + 'boolean value. Make sure to return true or false.', this.getName() || 'ReactCompositeComponent') : void 0;
-	    }
-
-	    this._updateBatchNumber = null;
-	    if (shouldUpdate) {
-	      this._pendingForceUpdate = false;
-	      // Will set `this.props`, `this.state` and `this.context`.
-	      this._performComponentUpdate(nextParentElement, nextProps, nextState, nextContext, transaction, nextUnmaskedContext);
-	    } else {
-	      // If it's determined that a component should not update, we still want
-	      // to set props and state but we shortcut the rest of the update.
-	      this._currentElement = nextParentElement;
-	      this._context = nextUnmaskedContext;
-	      inst.props = nextProps;
-	      inst.state = nextState;
-	      inst.context = nextContext;
-	    }
-	  },
-
-	  _processPendingState: function (props, context) {
-	    var inst = this._instance;
-	    var queue = this._pendingStateQueue;
-	    var replace = this._pendingReplaceState;
-	    this._pendingReplaceState = false;
-	    this._pendingStateQueue = null;
-
-	    if (!queue) {
-	      return inst.state;
-	    }
-
-	    if (replace && queue.length === 1) {
-	      return queue[0];
-	    }
-
-	    var nextState = _assign({}, replace ? queue[0] : inst.state);
-	    for (var i = replace ? 1 : 0; i < queue.length; i++) {
-	      var partial = queue[i];
-	      _assign(nextState, typeof partial === 'function' ? partial.call(inst, nextState, props, context) : partial);
-	    }
-
-	    return nextState;
-	  },
-
-	  /**
-	   * Merges new props and state, notifies delegate methods of update and
-	   * performs update.
-	   *
-	   * @param {ReactElement} nextElement Next element
-	   * @param {object} nextProps Next public object to set as properties.
-	   * @param {?object} nextState Next object to set as state.
-	   * @param {?object} nextContext Next public object to set as context.
-	   * @param {ReactReconcileTransaction} transaction
-	   * @param {?object} unmaskedContext
-	   * @private
-	   */
-	  _performComponentUpdate: function (nextElement, nextProps, nextState, nextContext, transaction, unmaskedContext) {
-	    var _this2 = this;
-
-	    var inst = this._instance;
-
-	    var hasComponentDidUpdate = Boolean(inst.componentDidUpdate);
-	    var prevProps;
-	    var prevState;
-	    var prevContext;
-	    if (hasComponentDidUpdate) {
-	      prevProps = inst.props;
-	      prevState = inst.state;
-	      prevContext = inst.context;
-	    }
-
-	    if (inst.componentWillUpdate) {
-	      if (process.env.NODE_ENV !== 'production') {
-	        measureLifeCyclePerf(function () {
-	          return inst.componentWillUpdate(nextProps, nextState, nextContext);
-	        }, this._debugID, 'componentWillUpdate');
-	      } else {
-	        inst.componentWillUpdate(nextProps, nextState, nextContext);
-	      }
-	    }
-
-	    this._currentElement = nextElement;
-	    this._context = unmaskedContext;
-	    inst.props = nextProps;
-	    inst.state = nextState;
-	    inst.context = nextContext;
-
-	    this._updateRenderedComponent(transaction, unmaskedContext);
-
-	    if (hasComponentDidUpdate) {
-	      if (process.env.NODE_ENV !== 'production') {
-	        transaction.getReactMountReady().enqueue(function () {
-	          measureLifeCyclePerf(inst.componentDidUpdate.bind(inst, prevProps, prevState, prevContext), _this2._debugID, 'componentDidUpdate');
-	        });
-	      } else {
-	        transaction.getReactMountReady().enqueue(inst.componentDidUpdate.bind(inst, prevProps, prevState, prevContext), inst);
-	      }
-	    }
-	  },
-
-	  /**
-	   * Call the component's `render` method and update the DOM accordingly.
-	   *
-	   * @param {ReactReconcileTransaction} transaction
-	   * @internal
-	   */
-	  _updateRenderedComponent: function (transaction, context) {
-	    var prevComponentInstance = this._renderedComponent;
-	    var prevRenderedElement = prevComponentInstance._currentElement;
-	    var nextRenderedElement = this._renderValidatedComponent();
-
-	    var debugID = 0;
-	    if (process.env.NODE_ENV !== 'production') {
-	      debugID = this._debugID;
-	    }
-
-	    if (shouldUpdateReactComponent(prevRenderedElement, nextRenderedElement)) {
-	      ReactReconciler.receiveComponent(prevComponentInstance, nextRenderedElement, transaction, this._processChildContext(context));
-	    } else {
-	      var oldHostNode = ReactReconciler.getHostNode(prevComponentInstance);
-	      ReactReconciler.unmountComponent(prevComponentInstance, false);
-
-	      var nodeType = ReactNodeTypes.getType(nextRenderedElement);
-	      this._renderedNodeType = nodeType;
-	      var child = this._instantiateReactComponent(nextRenderedElement, nodeType !== ReactNodeTypes.EMPTY /* shouldHaveDebugID */
-	      );
-	      this._renderedComponent = child;
-
-	      var nextMarkup = ReactReconciler.mountComponent(child, transaction, this._hostParent, this._hostContainerInfo, this._processChildContext(context), debugID);
-
-	      if (process.env.NODE_ENV !== 'production') {
-	        if (debugID !== 0) {
-	          var childDebugIDs = child._debugID !== 0 ? [child._debugID] : [];
-	          ReactInstrumentation.debugTool.onSetChildren(debugID, childDebugIDs);
-	        }
-	      }
-
-	      this._replaceNodeWithMarkup(oldHostNode, nextMarkup, prevComponentInstance);
-	    }
-	  },
-
-	  /**
-	   * Overridden in shallow rendering.
-	   *
-	   * @protected
-	   */
-	  _replaceNodeWithMarkup: function (oldHostNode, nextMarkup, prevInstance) {
-	    ReactComponentEnvironment.replaceNodeWithMarkup(oldHostNode, nextMarkup, prevInstance);
-	  },
-
-	  /**
-	   * @protected
-	   */
-	  _renderValidatedComponentWithoutOwnerOrContext: function () {
-	    var inst = this._instance;
-	    var renderedElement;
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      renderedElement = measureLifeCyclePerf(function () {
-	        return inst.render();
-	      }, this._debugID, 'render');
-	    } else {
-	      renderedElement = inst.render();
-	    }
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      // We allow auto-mocks to proceed as if they're returning null.
-	      if (renderedElement === undefined && inst.render._isMockFunction) {
-	        // This is probably bad practice. Consider warning here and
-	        // deprecating this convenience.
-	        renderedElement = null;
-	      }
-	    }
-
-	    return renderedElement;
-	  },
-
-	  /**
-	   * @private
-	   */
-	  _renderValidatedComponent: function () {
-	    var renderedElement;
-	    if (process.env.NODE_ENV !== 'production' || this._compositeType !== CompositeTypes.StatelessFunctional) {
-	      ReactCurrentOwner.current = this;
-	      try {
-	        renderedElement = this._renderValidatedComponentWithoutOwnerOrContext();
-	      } finally {
-	        ReactCurrentOwner.current = null;
-	      }
-	    } else {
-	      renderedElement = this._renderValidatedComponentWithoutOwnerOrContext();
-	    }
-	    !(
-	    // TODO: An `isValidNode` function would probably be more appropriate
-	    renderedElement === null || renderedElement === false || React.isValidElement(renderedElement)) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.render(): A valid React element (or null) must be returned. You may have returned undefined, an array or some other invalid object.', this.getName() || 'ReactCompositeComponent') : _prodInvariant('109', this.getName() || 'ReactCompositeComponent') : void 0;
-
-	    return renderedElement;
-	  },
-
-	  /**
-	   * 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) {
-	    var inst = this.getPublicInstance();
-	    !(inst != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Stateless function components cannot have refs.') : _prodInvariant('110') : void 0;
-	    var publicComponentInstance = component.getPublicInstance();
-	    if (process.env.NODE_ENV !== 'production') {
-	      var componentName = component && component.getName ? component.getName() : 'a component';
-	      process.env.NODE_ENV !== 'production' ? warning(publicComponentInstance != null || component._compositeType !== CompositeTypes.StatelessFunctional, 'Stateless function components cannot be given refs ' + '(See ref "%s" in %s created by %s). ' + 'Attempts to access this ref will fail.', ref, componentName, this.getName()) : void 0;
-	    }
-	    var refs = inst.refs === emptyObject ? inst.refs = {} : inst.refs;
-	    refs[ref] = publicComponentInstance;
-	  },
-
-	  /**
-	   * Detaches a reference name.
-	   *
-	   * @param {string} ref Name to dereference.
-	   * @final
-	   * @private
-	   */
-	  detachRef: function (ref) {
-	    var refs = this.getPublicInstance().refs;
-	    delete refs[ref];
-	  },
-
-	  /**
-	   * Get a text description of the component that can be used to identify it
-	   * in error messages.
-	   * @return {string} The name or null.
-	   * @internal
-	   */
-	  getName: function () {
-	    var type = this._currentElement.type;
-	    var constructor = this._instance && this._instance.constructor;
-	    return type.displayName || constructor && constructor.displayName || type.name || constructor && constructor.name || null;
-	  },
-
-	  /**
-	   * Get the publicly accessible representation of this component - i.e. what
-	   * is exposed by refs and returned by render. Can be null for stateless
-	   * components.
-	   *
-	   * @return {ReactComponent} the public component instance.
-	   * @internal
-	   */
-	  getPublicInstance: function () {
-	    var inst = this._instance;
-	    if (this._compositeType === CompositeTypes.StatelessFunctional) {
-	      return null;
-	    }
-	    return inst;
-	  },
-
-	  // Stub
-	  _instantiateReactComponent: null
-
-	};
-
-	module.exports = ReactCompositeComponent;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 124 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var React = __webpack_require__(2);
-
-	var invariant = __webpack_require__(37);
-
-	var ReactNodeTypes = {
-	  HOST: 0,
-	  COMPOSITE: 1,
-	  EMPTY: 2,
-
-	  getType: function (node) {
-	    if (node === null || node === false) {
-	      return ReactNodeTypes.EMPTY;
-	    } else if (React.isValidElement(node)) {
-	      if (typeof node.type === 'function') {
-	        return ReactNodeTypes.COMPOSITE;
-	      } else {
-	        return ReactNodeTypes.HOST;
-	      }
-	    }
-	     true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Unexpected node: %s', node) : _prodInvariant('26', node) : void 0;
-	  }
-	};
-
-	module.exports = ReactNodeTypes;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 125 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var ReactPropTypeLocationNames = __webpack_require__(126);
-	var ReactPropTypesSecret = __webpack_require__(114);
-
-	var invariant = __webpack_require__(37);
-	var warning = __webpack_require__(47);
-
-	var ReactComponentTreeHook;
-
-	if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV === 'test') {
-	  // Temporary hack.
-	  // Inline requires don't work well with Jest:
-	  // https://github.com/facebook/react/issues/7240
-	  // Remove the inline requires when we don't need them anymore:
-	  // https://github.com/facebook/react/pull/7178
-	  ReactComponentTreeHook = __webpack_require__(26);
-	}
-
-	var loggedTypeFailures = {};
-
-	/**
-	 * Assert that the values match with the type specs.
-	 * Error messages are memorized and will only be shown once.
-	 *
-	 * @param {object} typeSpecs Map of name to a ReactPropType
-	 * @param {object} values Runtime values that need to be type-checked
-	 * @param {string} location e.g. "prop", "context", "child context"
-	 * @param {string} componentName Name of the component for error messages.
-	 * @param {?object} element The React element that is being type-checked
-	 * @param {?number} debugID The React component instance that is being type-checked
-	 * @private
-	 */
-	function checkReactTypeSpec(typeSpecs, values, location, componentName, element, debugID) {
-	  for (var typeSpecName in typeSpecs) {
-	    if (typeSpecs.hasOwnProperty(typeSpecName)) {
-	      var error;
-	      // Prop type validation may throw. In case they do, we don't want to
-	      // fail the render phase where it didn't fail before. So we log it.
-	      // After these have been cleaned up, we'll let them throw.
-	      try {
-	        // This is intentionally an invariant that gets caught. It's the same
-	        // behavior as without this statement except with a better message.
-	        !(typeof typeSpecs[typeSpecName] === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s: %s type `%s` is invalid; it must be a function, usually from React.PropTypes.', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName) : _prodInvariant('84', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName) : void 0;
-	        error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
-	      } catch (ex) {
-	        error = ex;
-	      }
-	      process.env.NODE_ENV !== 'production' ? warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName, typeof error) : void 0;
-	      if (error instanceof Error && !(error.message in loggedTypeFailures)) {
-	        // Only monitor this failure once because there tends to be a lot of the
-	        // same error.
-	        loggedTypeFailures[error.message] = true;
-
-	        var componentStackInfo = '';
-
-	        if (process.env.NODE_ENV !== 'production') {
-	          if (!ReactComponentTreeHook) {
-	            ReactComponentTreeHook = __webpack_require__(26);
-	          }
-	          if (debugID !== null) {
-	            componentStackInfo = ReactComponentTreeHook.getStackAddendumByID(debugID);
-	          } else if (element !== null) {
-	            componentStackInfo = ReactComponentTreeHook.getCurrentStackAddendum(element);
-	          }
-	        }
-
-	        process.env.NODE_ENV !== 'production' ? warning(false, 'Failed %s type: %s%s', location, error.message, componentStackInfo) : void 0;
-	      }
-	    }
-	  }
-	}
-
-	module.exports = checkReactTypeSpec;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 126 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var ReactPropTypeLocationNames = {};
-
-	if (process.env.NODE_ENV !== 'production') {
-	  ReactPropTypeLocationNames = {
-	    prop: 'prop',
-	    context: 'context',
-	    childContext: 'child context'
-	  };
-	}
-
-	module.exports = ReactPropTypeLocationNames;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 127 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var emptyObject = {};
-
-	if (process.env.NODE_ENV !== 'production') {
-	  Object.freeze(emptyObject);
-	}
-
-	module.exports = emptyObject;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 128 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * @typechecks
-	 * 
-	 */
-
-	/*eslint-disable no-self-compare */
-
-	'use strict';
-
-	var hasOwnProperty = Object.prototype.hasOwnProperty;
-
-	/**
-	 * inlined Object.is polyfill to avoid requiring consumers ship their own
-	 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
-	 */
-	function is(x, y) {
-	  // SameValue algorithm
-	  if (x === y) {
-	    // Steps 1-5, 7-10
-	    // Steps 6.b-6.e: +0 != -0
-	    // Added the nonzero y check to make Flow happy, but it is redundant
-	    return x !== 0 || y !== 0 || 1 / x === 1 / y;
-	  } else {
-	    // Step 6.a: NaN == NaN
-	    return x !== x && y !== y;
-	  }
-	}
-
-	/**
-	 * Performs equality by iterating through keys on an object and returning false
-	 * when any key has values which are not strictly equal between the arguments.
-	 * Returns true when the values of all keys are strictly equal.
-	 */
-	function shallowEqual(objA, objB) {
-	  if (is(objA, objB)) {
-	    return true;
-	  }
-
-	  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
-	    return false;
-	  }
-
-	  var keysA = Object.keys(objA);
-	  var keysB = Object.keys(objB);
-
-	  if (keysA.length !== keysB.length) {
-	    return false;
-	  }
-
-	  // Test for A's keys different from B.
-	  for (var i = 0; i < keysA.length; i++) {
-	    if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
-	      return false;
-	    }
-	  }
-
-	  return true;
-	}
-
-	module.exports = shallowEqual;
-
-/***/ },
-/* 129 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	/**
-	 * Given a `prevElement` and `nextElement`, determines if the existing
-	 * instance should be updated as opposed to being destroyed or replaced by a new
-	 * instance. Both arguments are elements. This ensures that this logic can
-	 * operate on stateless trees without any backing instance.
-	 *
-	 * @param {?object} prevElement
-	 * @param {?object} nextElement
-	 * @return {boolean} True if the existing instance should be updated.
-	 * @protected
-	 */
-
-	function shouldUpdateReactComponent(prevElement, nextElement) {
-	  var prevEmpty = prevElement === null || prevElement === false;
-	  var nextEmpty = nextElement === null || nextElement === false;
-	  if (prevEmpty || nextEmpty) {
-	    return prevEmpty === nextEmpty;
-	  }
-
-	  var prevType = typeof prevElement;
-	  var nextType = typeof nextElement;
-	  if (prevType === 'string' || prevType === 'number') {
-	    return nextType === 'string' || nextType === 'number';
-	  } else {
-	    return nextType === 'object' && prevElement.type === nextElement.type && prevElement.key === nextElement.key;
-	  }
-	}
-
-	module.exports = shouldUpdateReactComponent;
-
-/***/ },
-/* 130 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2014-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var emptyComponentFactory;
-
-	var ReactEmptyComponentInjection = {
-	  injectEmptyComponentFactory: function (factory) {
-	    emptyComponentFactory = factory;
-	  }
-	};
-
-	var ReactEmptyComponent = {
-	  create: function (instantiate) {
-	    return emptyComponentFactory(instantiate);
-	  }
-	};
-
-	ReactEmptyComponent.injection = ReactEmptyComponentInjection;
-
-	module.exports = ReactEmptyComponent;
-
-/***/ },
-/* 131 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2014-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35),
-	    _assign = __webpack_require__(53);
-
-	var invariant = __webpack_require__(37);
-
-	var genericComponentClass = null;
-	// This registry keeps track of wrapper classes around host tags.
-	var tagToComponentClass = {};
-	var textComponentClass = null;
-
-	var ReactHostComponentInjection = {
-	  // This accepts a class that receives the tag string. This is a catch all
-	  // that can render any kind of tag.
-	  injectGenericComponentClass: function (componentClass) {
-	    genericComponentClass = componentClass;
-	  },
-	  // This accepts a text component class that takes the text string to be
-	  // rendered as props.
-	  injectTextComponentClass: function (componentClass) {
-	    textComponentClass = componentClass;
-	  },
-	  // This accepts a keyed object with classes as values. Each key represents a
-	  // tag. That particular tag will use this class instead of the generic one.
-	  injectComponentClasses: function (componentClasses) {
-	    _assign(tagToComponentClass, componentClasses);
-	  }
-	};
-
-	/**
-	 * Get a host internal component class for a specific tag.
-	 *
-	 * @param {ReactElement} element The element to create.
-	 * @return {function} The internal class constructor function.
-	 */
-	function createInternalComponent(element) {
-	  !genericComponentClass ? process.env.NODE_ENV !== 'production' ? invariant(false, 'There is no registered component for the tag %s', element.type) : _prodInvariant('111', element.type) : void 0;
-	  return new genericComponentClass(element);
-	}
-
-	/**
-	 * @param {ReactText} text
-	 * @return {ReactComponent}
-	 */
-	function createInstanceForText(text) {
-	  return new textComponentClass(text);
-	}
-
-	/**
-	 * @param {ReactComponent} component
-	 * @return {boolean}
-	 */
-	function isTextComponent(component) {
-	  return component instanceof textComponentClass;
-	}
-
-	var ReactHostComponent = {
-	  createInternalComponent: createInternalComponent,
-	  createInstanceForText: createInstanceForText,
-	  isTextComponent: isTextComponent,
-	  injection: ReactHostComponentInjection
-	};
-
-	module.exports = ReactHostComponent;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 132 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var nextDebugID = 1;
-
-	function getNextDebugID() {
-	  return nextDebugID++;
-	}
-
-	module.exports = getNextDebugID;
-
-/***/ },
-/* 133 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	/**
-	 * Escape and wrap key so it is safe to use as a reactid
-	 *
-	 * @param {string} key to be escaped.
-	 * @return {string} the escaped key.
-	 */
-
-	function escape(key) {
-	  var escapeRegex = /[=:]/g;
-	  var escaperLookup = {
-	    '=': '=0',
-	    ':': '=2'
-	  };
-	  var escapedString = ('' + key).replace(escapeRegex, function (match) {
-	    return escaperLookup[match];
-	  });
-
-	  return '$' + escapedString;
-	}
-
-	/**
-	 * Unescape and unwrap key for human-readable display
-	 *
-	 * @param {string} key to unescape.
-	 * @return {string} the unescaped key.
-	 */
-	function unescape(key) {
-	  var unescapeRegex = /(=0|=2)/g;
-	  var unescaperLookup = {
-	    '=0': '=',
-	    '=2': ':'
-	  };
-	  var keySubstring = key[0] === '.' && key[1] === '$' ? key.substring(2) : key.substring(1);
-
-	  return ('' + keySubstring).replace(unescapeRegex, function (match) {
-	    return unescaperLookup[match];
-	  });
-	}
-
-	var KeyEscapeUtils = {
-	  escape: escape,
-	  unescape: unescape
-	};
-
-	module.exports = KeyEscapeUtils;
-
-/***/ },
-/* 134 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var ReactCurrentOwner = __webpack_require__(10);
-	var REACT_ELEMENT_TYPE = __webpack_require__(135);
-
-	var getIteratorFn = __webpack_require__(136);
-	var invariant = __webpack_require__(37);
-	var KeyEscapeUtils = __webpack_require__(133);
-	var warning = __webpack_require__(47);
-
-	var SEPARATOR = '.';
-	var SUBSEPARATOR = ':';
-
-	/**
-	 * This is inlined from ReactElement since this file is shared between
-	 * isomorphic and renderers. We could extract this to a
-	 *
-	 */
-
-	/**
-	 * TODO: Test that a single child and an array with one item have the same key
-	 * pattern.
-	 */
-
-	var didWarnAboutMaps = false;
-
-	/**
-	 * 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}
-	 */
-	function getComponentKey(component, index) {
-	  // Do some typechecking here since we call this blindly. We want to ensure
-	  // that we don't block potential future ES APIs.
-	  if (component && typeof component === 'object' && component.key != null) {
-	    // Explicit key
-	    return KeyEscapeUtils.escape(component.key);
-	  }
-	  // Implicit key determined by the index in the set
-	  return index.toString(36);
-	}
-
-	/**
-	 * @param {?*} children Children tree container.
-	 * @param {!string} nameSoFar Name of the key path so far.
-	 * @param {!function} callback Callback to invoke with each child found.
-	 * @param {?*} traverseContext Used to pass information throughout the traversal
-	 * process.
-	 * @return {!number} The number of children in this subtree.
-	 */
-	function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {
-	  var type = typeof children;
-
-	  if (type === 'undefined' || type === 'boolean') {
-	    // All of the above are perceived as null.
-	    children = null;
-	  }
-
-	  if (children === null || type === 'string' || type === 'number' ||
-	  // The following is inlined from ReactElement. This means we can optimize
-	  // some checks. React Fiber also inlines this logic for similar purposes.
-	  type === 'object' && children.$$typeof === REACT_ELEMENT_TYPE) {
-	    callback(traverseContext, children,
-	    // 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.
-	    nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);
-	    return 1;
-	  }
-
-	  var child;
-	  var nextName;
-	  var subtreeCount = 0; // Count of children found in the current subtree.
-	  var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;
-
-	  if (Array.isArray(children)) {
-	    for (var i = 0; i < children.length; i++) {
-	      child = children[i];
-	      nextName = nextNamePrefix + getComponentKey(child, i);
-	      subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
-	    }
-	  } else {
-	    var iteratorFn = getIteratorFn(children);
-	    if (iteratorFn) {
-	      var iterator = iteratorFn.call(children);
-	      var step;
-	      if (iteratorFn !== children.entries) {
-	        var ii = 0;
-	        while (!(step = iterator.next()).done) {
-	          child = step.value;
-	          nextName = nextNamePrefix + getComponentKey(child, ii++);
-	          subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
-	        }
-	      } else {
-	        if (process.env.NODE_ENV !== 'production') {
-	          var mapsAsChildrenAddendum = '';
-	          if (ReactCurrentOwner.current) {
-	            var mapsAsChildrenOwnerName = ReactCurrentOwner.current.getName();
-	            if (mapsAsChildrenOwnerName) {
-	              mapsAsChildrenAddendum = ' Check the render method of `' + mapsAsChildrenOwnerName + '`.';
-	            }
-	          }
-	          process.env.NODE_ENV !== 'production' ? warning(didWarnAboutMaps, 'Using Maps as children is not yet fully supported. It is an ' + 'experimental feature that might be removed. Convert it to a ' + 'sequence / iterable of keyed ReactElements instead.%s', mapsAsChildrenAddendum) : void 0;
-	          didWarnAboutMaps = true;
-	        }
-	        // Iterator will provide entry [k,v] tuples rather than values.
-	        while (!(step = iterator.next()).done) {
-	          var entry = step.value;
-	          if (entry) {
-	            child = entry[1];
-	            nextName = nextNamePrefix + KeyEscapeUtils.escape(entry[0]) + SUBSEPARATOR + getComponentKey(child, 0);
-	            subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
-	          }
-	        }
-	      }
-	    } else if (type === 'object') {
-	      var addendum = '';
-	      if (process.env.NODE_ENV !== 'production') {
-	        addendum = ' If you meant to render a collection of children, use an array ' + 'instead or wrap the object using createFragment(object) from the ' + 'React add-ons.';
-	        if (children._isReactElement) {
-	          addendum = ' It looks like you\'re using an element created by a different ' + 'version of React. Make sure to use only one copy of React.';
-	        }
-	        if (ReactCurrentOwner.current) {
-	          var name = ReactCurrentOwner.current.getName();
-	          if (name) {
-	            addendum += ' Check the render method of `' + name + '`.';
-	          }
-	        }
-	      }
-	      var childrenString = String(children);
-	       true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum) : _prodInvariant('31', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum) : void 0;
-	    }
-	  }
-
-	  return subtreeCount;
-	}
-
-	/**
-	 * Traverses children that are typically specified as `props.children`, but
-	 * might also be specified through attributes:
-	 *
-	 * - `traverseAllChildren(this.props.children, ...)`
-	 * - `traverseAllChildren(this.props.leftPanelChildren, ...)`
-	 *
-	 * The `traverseContext` is an optional argument that is passed through the
-	 * entire traversal. It can be used to store accumulations or anything else that
-	 * the callback might find relevant.
-	 *
-	 * @param {?*} children Children tree object.
-	 * @param {!function} callback To invoke upon traversing each child.
-	 * @param {?*} traverseContext Context for traversal.
-	 * @return {!number} The number of children in this subtree.
-	 */
-	function traverseAllChildren(children, callback, traverseContext) {
-	  if (children == null) {
-	    return 0;
-	  }
-
-	  return traverseAllChildrenImpl(children, '', callback, traverseContext);
-	}
-
-	module.exports = traverseAllChildren;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 135 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2014-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	// The Symbol used to tag the ReactElement type. If there is no native Symbol
-	// nor polyfill, then a plain number is used for performance.
-
-	var REACT_ELEMENT_TYPE = typeof Symbol === 'function' && Symbol['for'] && Symbol['for']('react.element') || 0xeac7;
-
-	module.exports = REACT_ELEMENT_TYPE;
-
-/***/ },
-/* 136 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	/* global Symbol */
-
-	var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
-	var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
-
-	/**
-	 * Returns the iterator method function contained on the iterable object.
-	 *
-	 * Be sure to invoke the function with the iterable as context:
-	 *
-	 *     var iteratorFn = getIteratorFn(myIterable);
-	 *     if (iteratorFn) {
-	 *       var iterator = iteratorFn.call(myIterable);
-	 *       ...
-	 *     }
-	 *
-	 * @param {?object} maybeIterable
-	 * @return {?function}
-	 */
-	function getIteratorFn(maybeIterable) {
-	  var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
-	  if (typeof iteratorFn === 'function') {
-	    return iteratorFn;
-	  }
-	}
-
-	module.exports = getIteratorFn;
-
-/***/ },
-/* 137 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var KeyEscapeUtils = __webpack_require__(133);
-	var traverseAllChildren = __webpack_require__(134);
-	var warning = __webpack_require__(47);
-
-	var ReactComponentTreeHook;
-
-	if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV === 'test') {
-	  // Temporary hack.
-	  // Inline requires don't work well with Jest:
-	  // https://github.com/facebook/react/issues/7240
-	  // Remove the inline requires when we don't need them anymore:
-	  // https://github.com/facebook/react/pull/7178
-	  ReactComponentTreeHook = __webpack_require__(26);
-	}
-
-	/**
-	 * @param {function} traverseContext Context passed through traversal.
-	 * @param {?ReactComponent} child React child component.
-	 * @param {!string} name String name of key path to child.
-	 * @param {number=} selfDebugID Optional debugID of the current internal instance.
-	 */
-	function flattenSingleChildIntoContext(traverseContext, child, name, selfDebugID) {
-	  // We found a component instance.
-	  if (traverseContext && typeof traverseContext === 'object') {
-	    var result = traverseContext;
-	    var keyUnique = result[name] === undefined;
-	    if (process.env.NODE_ENV !== 'production') {
-	      if (!ReactComponentTreeHook) {
-	        ReactComponentTreeHook = __webpack_require__(26);
-	      }
-	      if (!keyUnique) {
-	        process.env.NODE_ENV !== 'production' ? warning(false, 'flattenChildren(...): Encountered two children with the same key, ' + '`%s`. Child keys must be unique; when two children share a key, only ' + 'the first child will be used.%s', KeyEscapeUtils.unescape(name), ReactComponentTreeHook.getStackAddendumByID(selfDebugID)) : void 0;
-	      }
-	    }
-	    if (keyUnique && child != null) {
-	      result[name] = child;
-	    }
-	  }
-	}
-
-	/**
-	 * Flattens children that are typically specified as `props.children`. Any null
-	 * children will not be included in the resulting object.
-	 * @return {!object} flattened children keyed by name.
-	 */
-	function flattenChildren(children, selfDebugID) {
-	  if (children == null) {
-	    return children;
-	  }
-	  var result = {};
-
-	  if (process.env.NODE_ENV !== 'production') {
-	    traverseAllChildren(children, function (traverseContext, child, name) {
-	      return flattenSingleChildIntoContext(traverseContext, child, name, selfDebugID);
-	    }, result);
-	  } else {
-	    traverseAllChildren(children, flattenSingleChildIntoContext, result);
-	  }
-	  return result;
-	}
-
-	module.exports = flattenChildren;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 138 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2014-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _assign = __webpack_require__(53);
-
-	var PooledClass = __webpack_require__(54);
-	var Transaction = __webpack_require__(72);
-	var ReactInstrumentation = __webpack_require__(66);
-	var ReactServerUpdateQueue = __webpack_require__(139);
-
-	/**
-	 * 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 = [];
-
-	if (process.env.NODE_ENV !== 'production') {
-	  TRANSACTION_WRAPPERS.push({
-	    initialize: ReactInstrumentation.debugTool.onBeginFlush,
-	    close: ReactInstrumentation.debugTool.onEndFlush
-	  });
-	}
-
-	var noopCallbackQueue = {
-	  enqueue: function () {}
-	};
-
-	/**
-	 * @class ReactServerRenderingTransaction
-	 * @param {boolean} renderToStaticMarkup
-	 */
-	function ReactServerRenderingTransaction(renderToStaticMarkup) {
-	  this.reinitializeTransaction();
-	  this.renderToStaticMarkup = renderToStaticMarkup;
-	  this.useCreateElement = false;
-	  this.updateQueue = new ReactServerUpdateQueue(this);
-	}
-
-	var Mixin = {
-	  /**
-	   * @see Transaction
-	   * @abstract
-	   * @final
-	   * @return {array} Empty list of operation wrap procedures.
-	   */
-	  getTransactionWrappers: function () {
-	    return TRANSACTION_WRAPPERS;
-	  },
-
-	  /**
-	   * @return {object} The queue to collect `onDOMReady` callbacks with.
-	   */
-	  getReactMountReady: function () {
-	    return noopCallbackQueue;
-	  },
-
-	  /**
-	   * @return {object} The queue to collect React async events.
-	   */
-	  getUpdateQueue: function () {
-	    return this.updateQueue;
-	  },
-
-	  /**
-	   * `PooledClass` looks for this, and will invoke this before allowing this
-	   * instance to be reused.
-	   */
-	  destructor: function () {},
-
-	  checkpoint: function () {},
-
-	  rollback: function () {}
-	};
-
-	_assign(ReactServerRenderingTransaction.prototype, Transaction, Mixin);
-
-	PooledClass.addPoolingTo(ReactServerRenderingTransaction);
-
-	module.exports = ReactServerRenderingTransaction;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 139 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2015-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-	var ReactUpdateQueue = __webpack_require__(140);
-
-	var warning = __webpack_require__(47);
-
-	function warnNoop(publicInstance, callerName) {
-	  if (process.env.NODE_ENV !== 'production') {
-	    var constructor = publicInstance.constructor;
-	    process.env.NODE_ENV !== 'production' ? warning(false, '%s(...): Can only update a mounting component. ' + 'This usually means you called %s() outside componentWillMount() on the server. ' + 'This is a no-op. Please check the code for the %s component.', callerName, callerName, constructor && (constructor.displayName || constructor.name) || 'ReactClass') : void 0;
-	  }
-	}
-
-	/**
-	 * This is the update queue used for server rendering.
-	 * It delegates to ReactUpdateQueue while server rendering is in progress and
-	 * switches to ReactNoopUpdateQueue after the transaction has completed.
-	 * @class ReactServerUpdateQueue
-	 * @param {Transaction} transaction
-	 */
-
-	var ReactServerUpdateQueue = function () {
-	  function ReactServerUpdateQueue(transaction) {
-	    _classCallCheck(this, ReactServerUpdateQueue);
-
-	    this.transaction = transaction;
-	  }
-
-	  /**
-	   * Checks whether or not this composite component is mounted.
-	   * @param {ReactClass} publicInstance The instance we want to test.
-	   * @return {boolean} True if mounted, false otherwise.
-	   * @protected
-	   * @final
-	   */
-
-
-	  ReactServerUpdateQueue.prototype.isMounted = function isMounted(publicInstance) {
-	    return false;
-	  };
-
-	  /**
-	   * Enqueue a callback that will be executed after all the pending updates
-	   * have processed.
-	   *
-	   * @param {ReactClass} publicInstance The instance to use as `this` context.
-	   * @param {?function} callback Called after state is updated.
-	   * @internal
-	   */
-
-
-	  ReactServerUpdateQueue.prototype.enqueueCallback = function enqueueCallback(publicInstance, callback, callerName) {
-	    if (this.transaction.isInTransaction()) {
-	      ReactUpdateQueue.enqueueCallback(publicInstance, callback, callerName);
-	    }
-	  };
-
-	  /**
-	   * 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 `shouldComponentUpdate`, but it will invoke
-	   * `componentWillUpdate` and `componentDidUpdate`.
-	   *
-	   * @param {ReactClass} publicInstance The instance that should rerender.
-	   * @internal
-	   */
-
-
-	  ReactServerUpdateQueue.prototype.enqueueForceUpdate = function enqueueForceUpdate(publicInstance) {
-	    if (this.transaction.isInTransaction()) {
-	      ReactUpdateQueue.enqueueForceUpdate(publicInstance);
-	    } else {
-	      warnNoop(publicInstance, 'forceUpdate');
-	    }
-	  };
-
-	  /**
-	   * 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 {ReactClass} publicInstance The instance that should rerender.
-	   * @param {object|function} completeState Next state.
-	   * @internal
-	   */
-
-
-	  ReactServerUpdateQueue.prototype.enqueueReplaceState = function enqueueReplaceState(publicInstance, completeState) {
-	    if (this.transaction.isInTransaction()) {
-	      ReactUpdateQueue.enqueueReplaceState(publicInstance, completeState);
-	    } else {
-	      warnNoop(publicInstance, 'replaceState');
-	    }
-	  };
-
-	  /**
-	   * Sets a subset of the state. This only exists because _pendingState is
-	   * internal. This provides a merging strategy that is not available to deep
-	   * properties which is confusing. TODO: Expose pendingState or don't use it
-	   * during the merge.
-	   *
-	   * @param {ReactClass} publicInstance The instance that should rerender.
-	   * @param {object|function} partialState Next partial state to be merged with state.
-	   * @internal
-	   */
-
-
-	  ReactServerUpdateQueue.prototype.enqueueSetState = function enqueueSetState(publicInstance, partialState) {
-	    if (this.transaction.isInTransaction()) {
-	      ReactUpdateQueue.enqueueSetState(publicInstance, partialState);
-	    } else {
-	      warnNoop(publicInstance, 'setState');
-	    }
-	  };
-
-	  return ReactServerUpdateQueue;
-	}();
-
-	module.exports = ReactServerUpdateQueue;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 140 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2015-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var ReactCurrentOwner = __webpack_require__(10);
-	var ReactInstanceMap = __webpack_require__(120);
-	var ReactInstrumentation = __webpack_require__(66);
-	var ReactUpdates = __webpack_require__(60);
-
-	var invariant = __webpack_require__(37);
-	var warning = __webpack_require__(47);
-
-	function enqueueUpdate(internalInstance) {
-	  ReactUpdates.enqueueUpdate(internalInstance);
-	}
-
-	function formatUnexpectedArgument(arg) {
-	  var type = typeof arg;
-	  if (type !== 'object') {
-	    return type;
-	  }
-	  var displayName = arg.constructor && arg.constructor.name || type;
-	  var keys = Object.keys(arg);
-	  if (keys.length > 0 && keys.length < 20) {
-	    return displayName + ' (keys: ' + keys.join(', ') + ')';
-	  }
-	  return displayName;
-	}
-
-	function getInternalInstanceReadyForUpdate(publicInstance, callerName) {
-	  var internalInstance = ReactInstanceMap.get(publicInstance);
-	  if (!internalInstance) {
-	    if (process.env.NODE_ENV !== 'production') {
-	      var ctor = publicInstance.constructor;
-	      // Only warn when we have a callerName. Otherwise we should be silent.
-	      // We're probably calling from enqueueCallback. We don't want to warn
-	      // there because we already warned for the corresponding lifecycle method.
-	      process.env.NODE_ENV !== 'production' ? warning(!callerName, '%s(...): Can only update a mounted or mounting component. ' + 'This usually means you called %s() on an unmounted component. ' + 'This is a no-op. Please check the code for the %s component.', callerName, callerName, ctor && (ctor.displayName || ctor.name) || 'ReactClass') : void 0;
-	    }
-	    return null;
-	  }
-
-	  if (process.env.NODE_ENV !== 'production') {
-	    process.env.NODE_ENV !== 'production' ? warning(ReactCurrentOwner.current == null, '%s(...): Cannot update during an existing state transition (such as ' + 'within `render` or another component\'s constructor). Render methods ' + 'should be a pure function of props and state; constructor ' + 'side-effects are an anti-pattern, but can be moved to ' + '`componentWillMount`.', callerName) : void 0;
-	  }
-
-	  return internalInstance;
-	}
-
-	/**
-	 * ReactUpdateQueue allows for state updates to be scheduled into a later
-	 * reconciliation step.
-	 */
-	var ReactUpdateQueue = {
-
-	  /**
-	   * Checks whether or not this composite component is mounted.
-	   * @param {ReactClass} publicInstance The instance we want to test.
-	   * @return {boolean} True if mounted, false otherwise.
-	   * @protected
-	   * @final
-	   */
-	  isMounted: function (publicInstance) {
-	    if (process.env.NODE_ENV !== 'production') {
-	      var owner = ReactCurrentOwner.current;
-	      if (owner !== null) {
-	        process.env.NODE_ENV !== 'production' ? warning(owner._warnedAboutRefsInRender, '%s is accessing isMounted inside its render() function. ' + 'render() should be a pure function of props and state. It should ' + 'never access something that requires stale data from the previous ' + 'render, such as refs. Move this logic to componentDidMount and ' + 'componentDidUpdate instead.', owner.getName() || 'A component') : void 0;
-	        owner._warnedAboutRefsInRender = true;
-	      }
-	    }
-	    var internalInstance = ReactInstanceMap.get(publicInstance);
-	    if (internalInstance) {
-	      // During componentWillMount and render this will still be null but after
-	      // that will always render to something. At least for now. So we can use
-	      // this hack.
-	      return !!internalInstance._renderedComponent;
-	    } else {
-	      return false;
-	    }
-	  },
-
-	  /**
-	   * Enqueue a callback that will be executed after all the pending updates
-	   * have processed.
-	   *
-	   * @param {ReactClass} publicInstance The instance to use as `this` context.
-	   * @param {?function} callback Called after state is updated.
-	   * @param {string} callerName Name of the calling function in the public API.
-	   * @internal
-	   */
-	  enqueueCallback: function (publicInstance, callback, callerName) {
-	    ReactUpdateQueue.validateCallback(callback, callerName);
-	    var internalInstance = getInternalInstanceReadyForUpdate(publicInstance);
-
-	    // Previously we would throw an error if we didn't have an internal
-	    // instance. Since we want to make it a no-op instead, we mirror the same
-	    // behavior we have in other enqueue* methods.
-	    // We also need to ignore callbacks in componentWillMount. See
-	    // enqueueUpdates.
-	    if (!internalInstance) {
-	      return null;
-	    }
-
-	    if (internalInstance._pendingCallbacks) {
-	      internalInstance._pendingCallbacks.push(callback);
-	    } else {
-	      internalInstance._pendingCallbacks = [callback];
-	    }
-	    // TODO: The callback here is ignored when setState is called from
-	    // componentWillMount. Either fix it or disallow doing so completely in
-	    // favor of getInitialState. Alternatively, we can disallow
-	    // componentWillMount during server-side rendering.
-	    enqueueUpdate(internalInstance);
-	  },
-
-	  enqueueCallbackInternal: function (internalInstance, callback) {
-	    if (internalInstance._pendingCallbacks) {
-	      internalInstance._pendingCallbacks.push(callback);
-	    } else {
-	      internalInstance._pendingCallbacks = [callback];
-	    }
-	    enqueueUpdate(internalInstance);
-	  },
-
-	  /**
-	   * 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 `shouldComponentUpdate`, but it will invoke
-	   * `componentWillUpdate` and `componentDidUpdate`.
-	   *
-	   * @param {ReactClass} publicInstance The instance that should rerender.
-	   * @internal
-	   */
-	  enqueueForceUpdate: function (publicInstance) {
-	    var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'forceUpdate');
-
-	    if (!internalInstance) {
-	      return;
-	    }
-
-	    internalInstance._pendingForceUpdate = true;
-
-	    enqueueUpdate(internalInstance);
-	  },
-
-	  /**
-	   * 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 {ReactClass} publicInstance The instance that should rerender.
-	   * @param {object} completeState Next state.
-	   * @internal
-	   */
-	  enqueueReplaceState: function (publicInstance, completeState) {
-	    var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'replaceState');
-
-	    if (!internalInstance) {
-	      return;
-	    }
-
-	    internalInstance._pendingStateQueue = [completeState];
-	    internalInstance._pendingReplaceState = true;
-
-	    enqueueUpdate(internalInstance);
-	  },
-
-	  /**
-	   * Sets a subset of the state. This only exists because _pendingState is
-	   * internal. This provides a merging strategy that is not available to deep
-	   * properties which is confusing. TODO: Expose pendingState or don't use it
-	   * during the merge.
-	   *
-	   * @param {ReactClass} publicInstance The instance that should rerender.
-	   * @param {object} partialState Next partial state to be merged with state.
-	   * @internal
-	   */
-	  enqueueSetState: function (publicInstance, partialState) {
-	    if (process.env.NODE_ENV !== 'production') {
-	      ReactInstrumentation.debugTool.onSetState();
-	      process.env.NODE_ENV !== 'production' ? warning(partialState != null, 'setState(...): You passed an undefined or null state object; ' + 'instead, use forceUpdate().') : void 0;
-	    }
-
-	    var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'setState');
-
-	    if (!internalInstance) {
-	      return;
-	    }
-
-	    var queue = internalInstance._pendingStateQueue || (internalInstance._pendingStateQueue = []);
-	    queue.push(partialState);
-
-	    enqueueUpdate(internalInstance);
-	  },
-
-	  enqueueElementInternal: function (internalInstance, nextElement, nextContext) {
-	    internalInstance._pendingElement = nextElement;
-	    // TODO: introduce _pendingContext instead of setting it directly.
-	    internalInstance._context = nextContext;
-	    enqueueUpdate(internalInstance);
-	  },
-
-	  validateCallback: function (callback, callerName) {
-	    !(!callback || typeof callback === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s(...): Expected the last optional `callback` argument to be a function. Instead received: %s.', callerName, formatUnexpectedArgument(callback)) : _prodInvariant('122', callerName, formatUnexpectedArgument(callback)) : void 0;
-	  }
-
-	};
-
-	module.exports = ReactUpdateQueue;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 141 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2015-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _assign = __webpack_require__(53);
-
-	var emptyFunction = __webpack_require__(48);
-	var warning = __webpack_require__(47);
-
-	var validateDOMNesting = emptyFunction;
-
-	if (process.env.NODE_ENV !== 'production') {
-	  // This validation code was written based on the HTML5 parsing spec:
-	  // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope
-	  //
-	  // Note: this does not catch all invalid nesting, nor does it try to (as it's
-	  // not clear what practical benefit doing so provides); instead, we warn only
-	  // for cases where the parser will give a parse tree differing from what React
-	  // intended. For example, <b><div></div></b> is invalid but we don't warn
-	  // because it still parses correctly; we do warn for other cases like nested
-	  // <p> tags where the beginning of the second element implicitly closes the
-	  // first, causing a confusing mess.
-
-	  // https://html.spec.whatwg.org/multipage/syntax.html#special
-	  var specialTags = ['address', 'applet', 'area', 'article', 'aside', 'base', 'basefont', 'bgsound', 'blockquote', 'body', 'br', 'button', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dir', 'div', 'dl', 'dt', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'iframe', 'img', 'input', 'isindex', 'li', 'link', 'listing', 'main', 'marquee', 'menu', 'menuitem', 'meta', 'nav', 'noembed', 'noframes', 'noscript', 'object', 'ol', 'p', 'param', 'plaintext', 'pre', 'script', 'section', 'select', 'source', 'style', 'summary', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul', 'wbr', 'xmp'];
-
-	  // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope
-	  var inScopeTags = ['applet', 'caption', 'html', 'table', 'td', 'th', 'marquee', 'object', 'template',
-
-	  // https://html.spec.whatwg.org/multipage/syntax.html#html-integration-point
-	  // TODO: Distinguish by namespace here -- for <title>, including it here
-	  // errs on the side of fewer warnings
-	  'foreignObject', 'desc', 'title'];
-
-	  // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-button-scope
-	  var buttonScopeTags = inScopeTags.concat(['button']);
-
-	  // https://html.spec.whatwg.org/multipage/syntax.html#generate-implied-end-tags
-	  var impliedEndTags = ['dd', 'dt', 'li', 'option', 'optgroup', 'p', 'rp', 'rt'];
-
-	  var emptyAncestorInfo = {
-	    current: null,
-
-	    formTag: null,
-	    aTagInScope: null,
-	    buttonTagInScope: null,
-	    nobrTagInScope: null,
-	    pTagInButtonScope: null,
-
-	    listItemTagAutoclosing: null,
-	    dlItemTagAutoclosing: null
-	  };
-
-	  var updatedAncestorInfo = function (oldInfo, tag, instance) {
-	    var ancestorInfo = _assign({}, oldInfo || emptyAncestorInfo);
-	    var info = { tag: tag, instance: instance };
-
-	    if (inScopeTags.indexOf(tag) !== -1) {
-	      ancestorInfo.aTagInScope = null;
-	      ancestorInfo.buttonTagInScope = null;
-	      ancestorInfo.nobrTagInScope = null;
-	    }
-	    if (buttonScopeTags.indexOf(tag) !== -1) {
-	      ancestorInfo.pTagInButtonScope = null;
-	    }
-
-	    // See rules for 'li', 'dd', 'dt' start tags in
-	    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody
-	    if (specialTags.indexOf(tag) !== -1 && tag !== 'address' && tag !== 'div' && tag !== 'p') {
-	      ancestorInfo.listItemTagAutoclosing = null;
-	      ancestorInfo.dlItemTagAutoclosing = null;
-	    }
-
-	    ancestorInfo.current = info;
-
-	    if (tag === 'form') {
-	      ancestorInfo.formTag = info;
-	    }
-	    if (tag === 'a') {
-	      ancestorInfo.aTagInScope = info;
-	    }
-	    if (tag === 'button') {
-	      ancestorInfo.buttonTagInScope = info;
-	    }
-	    if (tag === 'nobr') {
-	      ancestorInfo.nobrTagInScope = info;
-	    }
-	    if (tag === 'p') {
-	      ancestorInfo.pTagInButtonScope = info;
-	    }
-	    if (tag === 'li') {
-	      ancestorInfo.listItemTagAutoclosing = info;
-	    }
-	    if (tag === 'dd' || tag === 'dt') {
-	      ancestorInfo.dlItemTagAutoclosing = info;
-	    }
-
-	    return ancestorInfo;
-	  };
-
-	  /**
-	   * Returns whether
-	   */
-	  var isTagValidWithParent = function (tag, parentTag) {
-	    // First, let's check if we're in an unusual parsing mode...
-	    switch (parentTag) {
-	      // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inselect
-	      case 'select':
-	        return tag === 'option' || tag === 'optgroup' || tag === '#text';
-	      case 'optgroup':
-	        return tag === 'option' || tag === '#text';
-	      // Strictly speaking, seeing an <option> doesn't mean we're in a <select>
-	      // but
-	      case 'option':
-	        return tag === '#text';
-
-	      // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intd
-	      // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incaption
-	      // No special behavior since these rules fall back to "in body" mode for
-	      // all except special table nodes which cause bad parsing behavior anyway.
-
-	      // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intr
-	      case 'tr':
-	        return tag === 'th' || tag === 'td' || tag === 'style' || tag === 'script' || tag === 'template';
-
-	      // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intbody
-	      case 'tbody':
-	      case 'thead':
-	      case 'tfoot':
-	        return tag === 'tr' || tag === 'style' || tag === 'script' || tag === 'template';
-
-	      // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incolgroup
-	      case 'colgroup':
-	        return tag === 'col' || tag === 'template';
-
-	      // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intable
-	      case 'table':
-	        return tag === 'caption' || tag === 'colgroup' || tag === 'tbody' || tag === 'tfoot' || tag === 'thead' || tag === 'style' || tag === 'script' || tag === 'template';
-
-	      // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inhead
-	      case 'head':
-	        return tag === 'base' || tag === 'basefont' || tag === 'bgsound' || tag === 'link' || tag === 'meta' || tag === 'title' || tag === 'noscript' || tag === 'noframes' || tag === 'style' || tag === 'script' || tag === 'template';
-
-	      // https://html.spec.whatwg.org/multipage/semantics.html#the-html-element
-	      case 'html':
-	        return tag === 'head' || tag === 'body';
-	      case '#document':
-	        return tag === 'html';
-	    }
-
-	    // Probably in the "in body" parsing mode, so we outlaw only tag combos
-	    // where the parsing rules cause implicit opens or closes to be added.
-	    // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody
-	    switch (tag) {
-	      case 'h1':
-	      case 'h2':
-	      case 'h3':
-	      case 'h4':
-	      case 'h5':
-	      case 'h6':
-	        return parentTag !== 'h1' && parentTag !== 'h2' && parentTag !== 'h3' && parentTag !== 'h4' && parentTag !== 'h5' && parentTag !== 'h6';
-
-	      case 'rp':
-	      case 'rt':
-	        return impliedEndTags.indexOf(parentTag) === -1;
-
-	      case 'body':
-	      case 'caption':
-	      case 'col':
-	      case 'colgroup':
-	      case 'frame':
-	      case 'head':
-	      case 'html':
-	      case 'tbody':
-	      case 'td':
-	      case 'tfoot':
-	      case 'th':
-	      case 'thead':
-	      case 'tr':
-	        // These tags are only valid with a few parents that have special child
-	        // parsing rules -- if we're down here, then none of those matched and
-	        // so we allow it only if we don't know what the parent is, as all other
-	        // cases are invalid.
-	        return parentTag == null;
-	    }
-
-	    return true;
-	  };
-
-	  /**
-	   * Returns whether
-	   */
-	  var findInvalidAncestorForTag = function (tag, ancestorInfo) {
-	    switch (tag) {
-	      case 'address':
-	      case 'article':
-	      case 'aside':
-	      case 'blockquote':
-	      case 'center':
-	      case 'details':
-	      case 'dialog':
-	      case 'dir':
-	      case 'div':
-	      case 'dl':
-	      case 'fieldset':
-	      case 'figcaption':
-	      case 'figure':
-	      case 'footer':
-	      case 'header':
-	      case 'hgroup':
-	      case 'main':
-	      case 'menu':
-	      case 'nav':
-	      case 'ol':
-	      case 'p':
-	      case 'section':
-	      case 'summary':
-	      case 'ul':
-
-	      case 'pre':
-	      case 'listing':
-
-	      case 'table':
-
-	      case 'hr':
-
-	      case 'xmp':
-
-	      case 'h1':
-	      case 'h2':
-	      case 'h3':
-	      case 'h4':
-	      case 'h5':
-	      case 'h6':
-	        return ancestorInfo.pTagInButtonScope;
-
-	      case 'form':
-	        return ancestorInfo.formTag || ancestorInfo.pTagInButtonScope;
-
-	      case 'li':
-	        return ancestorInfo.listItemTagAutoclosing;
-
-	      case 'dd':
-	      case 'dt':
-	        return ancestorInfo.dlItemTagAutoclosing;
-
-	      case 'button':
-	        return ancestorInfo.buttonTagInScope;
-
-	      case 'a':
-	        // Spec says something about storing a list of markers, but it sounds
-	        // equivalent to this check.
-	        return ancestorInfo.aTagInScope;
-
-	      case 'nobr':
-	        return ancestorInfo.nobrTagInScope;
-	    }
-
-	    return null;
-	  };
-
-	  /**
-	   * Given a ReactCompositeComponent instance, return a list of its recursive
-	   * owners, starting at the root and ending with the instance itself.
-	   */
-	  var findOwnerStack = function (instance) {
-	    if (!instance) {
-	      return [];
-	    }
-
-	    var stack = [];
-	    do {
-	      stack.push(instance);
-	    } while (instance = instance._currentElement._owner);
-	    stack.reverse();
-	    return stack;
-	  };
-
-	  var didWarn = {};
-
-	  validateDOMNesting = function (childTag, childText, childInstance, ancestorInfo) {
-	    ancestorInfo = ancestorInfo || emptyAncestorInfo;
-	    var parentInfo = ancestorInfo.current;
-	    var parentTag = parentInfo && parentInfo.tag;
-
-	    if (childText != null) {
-	      process.env.NODE_ENV !== 'production' ? warning(childTag == null, 'validateDOMNesting: when childText is passed, childTag should be null') : void 0;
-	      childTag = '#text';
-	    }
-
-	    var invalidParent = isTagValidWithParent(childTag, parentTag) ? null : parentInfo;
-	    var invalidAncestor = invalidParent ? null : findInvalidAncestorForTag(childTag, ancestorInfo);
-	    var problematic = invalidParent || invalidAncestor;
-
-	    if (problematic) {
-	      var ancestorTag = problematic.tag;
-	      var ancestorInstance = problematic.instance;
-
-	      var childOwner = childInstance && childInstance._currentElement._owner;
-	      var ancestorOwner = ancestorInstance && ancestorInstance._currentElement._owner;
-
-	      var childOwners = findOwnerStack(childOwner);
-	      var ancestorOwners = findOwnerStack(ancestorOwner);
-
-	      var minStackLen = Math.min(childOwners.length, ancestorOwners.length);
-	      var i;
-
-	      var deepestCommon = -1;
-	      for (i = 0; i < minStackLen; i++) {
-	        if (childOwners[i] === ancestorOwners[i]) {
-	          deepestCommon = i;
-	        } else {
-	          break;
-	        }
-	      }
-
-	      var UNKNOWN = '(unknown)';
-	      var childOwnerNames = childOwners.slice(deepestCommon + 1).map(function (inst) {
-	        return inst.getName() || UNKNOWN;
-	      });
-	      var ancestorOwnerNames = ancestorOwners.slice(deepestCommon + 1).map(function (inst) {
-	        return inst.getName() || UNKNOWN;
-	      });
-	      var ownerInfo = [].concat(
-	      // If the parent and child instances have a common owner ancestor, start
-	      // with that -- otherwise we just start with the parent's owners.
-	      deepestCommon !== -1 ? childOwners[deepestCommon].getName() || UNKNOWN : [], ancestorOwnerNames, ancestorTag,
-	      // If we're warning about an invalid (non-parent) ancestry, add '...'
-	      invalidAncestor ? ['...'] : [], childOwnerNames, childTag).join(' > ');
-
-	      var warnKey = !!invalidParent + '|' + childTag + '|' + ancestorTag + '|' + ownerInfo;
-	      if (didWarn[warnKey]) {
-	        return;
-	      }
-	      didWarn[warnKey] = true;
-
-	      var tagDisplayName = childTag;
-	      var whitespaceInfo = '';
-	      if (childTag === '#text') {
-	        if (/\S/.test(childText)) {
-	          tagDisplayName = 'Text nodes';
-	        } else {
-	          tagDisplayName = 'Whitespace text nodes';
-	          whitespaceInfo = ' Make sure you don\'t have any extra whitespace between tags on ' + 'each line of your source code.';
-	        }
-	      } else {
-	        tagDisplayName = '<' + childTag + '>';
-	      }
-
-	      if (invalidParent) {
-	        var info = '';
-	        if (ancestorTag === 'table' && childTag === 'tr') {
-	          info += ' Add a <tbody> to your code to match the DOM tree generated by ' + 'the browser.';
-	        }
-	        process.env.NODE_ENV !== 'production' ? warning(false, 'validateDOMNesting(...): %s cannot appear as a child of <%s>.%s ' + 'See %s.%s', tagDisplayName, ancestorTag, whitespaceInfo, ownerInfo, info) : void 0;
-	      } else {
-	        process.env.NODE_ENV !== 'production' ? warning(false, 'validateDOMNesting(...): %s cannot appear as a descendant of ' + '<%s>. See %s.', tagDisplayName, ancestorTag, ownerInfo) : void 0;
-	      }
-	    }
-	  };
-
-	  validateDOMNesting.updatedAncestorInfo = updatedAncestorInfo;
-
-	  // For testing
-	  validateDOMNesting.isTagValidInContext = function (tag, ancestorInfo) {
-	    ancestorInfo = ancestorInfo || emptyAncestorInfo;
-	    var parentInfo = ancestorInfo.current;
-	    var parentTag = parentInfo && parentInfo.tag;
-	    return isTagValidWithParent(tag, parentTag) && !findInvalidAncestorForTag(tag, ancestorInfo);
-	  };
-	}
-
-	module.exports = validateDOMNesting;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 142 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2014-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _assign = __webpack_require__(53);
-
-	var DOMLazyTree = __webpack_require__(85);
-	var ReactDOMComponentTree = __webpack_require__(34);
-
-	var ReactDOMEmptyComponent = function (instantiate) {
-	  // ReactCompositeComponent uses this:
-	  this._currentElement = null;
-	  // ReactDOMComponentTree uses these:
-	  this._hostNode = null;
-	  this._hostParent = null;
-	  this._hostContainerInfo = null;
-	  this._domID = 0;
-	};
-	_assign(ReactDOMEmptyComponent.prototype, {
-	  mountComponent: function (transaction, hostParent, hostContainerInfo, context) {
-	    var domID = hostContainerInfo._idCounter++;
-	    this._domID = domID;
-	    this._hostParent = hostParent;
-	    this._hostContainerInfo = hostContainerInfo;
-
-	    var nodeValue = ' react-empty: ' + this._domID + ' ';
-	    if (transaction.useCreateElement) {
-	      var ownerDocument = hostContainerInfo._ownerDocument;
-	      var node = ownerDocument.createComment(nodeValue);
-	      ReactDOMComponentTree.precacheNode(this, node);
-	      return DOMLazyTree(node);
-	    } else {
-	      if (transaction.renderToStaticMarkup) {
-	        // Normally we'd insert a comment node, but since this is a situation
-	        // where React won't take over (static pages), we can simply return
-	        // nothing.
-	        return '';
-	      }
-	      return '<!--' + nodeValue + '-->';
-	    }
-	  },
-	  receiveComponent: function () {},
-	  getHostNode: function () {
-	    return ReactDOMComponentTree.getNodeFromInstance(this);
-	  },
-	  unmountComponent: function () {
-	    ReactDOMComponentTree.uncacheNode(this);
-	  }
-	});
-
-	module.exports = ReactDOMEmptyComponent;
-
-/***/ },
-/* 143 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2015-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var invariant = __webpack_require__(37);
-
-	/**
-	 * Return the lowest common ancestor of A and B, or null if they are in
-	 * different trees.
-	 */
-	function getLowestCommonAncestor(instA, instB) {
-	  !('_hostNode' in instA) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getNodeFromInstance: Invalid argument.') : _prodInvariant('33') : void 0;
-	  !('_hostNode' in instB) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getNodeFromInstance: Invalid argument.') : _prodInvariant('33') : void 0;
-
-	  var depthA = 0;
-	  for (var tempA = instA; tempA; tempA = tempA._hostParent) {
-	    depthA++;
-	  }
-	  var depthB = 0;
-	  for (var tempB = instB; tempB; tempB = tempB._hostParent) {
-	    depthB++;
-	  }
-
-	  // If A is deeper, crawl up.
-	  while (depthA - depthB > 0) {
-	    instA = instA._hostParent;
-	    depthA--;
-	  }
-
-	  // If B is deeper, crawl up.
-	  while (depthB - depthA > 0) {
-	    instB = instB._hostParent;
-	    depthB--;
-	  }
-
-	  // Walk in lockstep until we find a match.
-	  var depth = depthA;
-	  while (depth--) {
-	    if (instA === instB) {
-	      return instA;
-	    }
-	    instA = instA._hostParent;
-	    instB = instB._hostParent;
-	  }
-	  return null;
-	}
-
-	/**
-	 * Return if A is an ancestor of B.
-	 */
-	function isAncestor(instA, instB) {
-	  !('_hostNode' in instA) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'isAncestor: Invalid argument.') : _prodInvariant('35') : void 0;
-	  !('_hostNode' in instB) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'isAncestor: Invalid argument.') : _prodInvariant('35') : void 0;
-
-	  while (instB) {
-	    if (instB === instA) {
-	      return true;
-	    }
-	    instB = instB._hostParent;
-	  }
-	  return false;
-	}
-
-	/**
-	 * Return the parent instance of the passed-in instance.
-	 */
-	function getParentInstance(inst) {
-	  !('_hostNode' in inst) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getParentInstance: Invalid argument.') : _prodInvariant('36') : void 0;
-
-	  return inst._hostParent;
-	}
-
-	/**
-	 * Simulates the traversal of a two-phase, capture/bubble event dispatch.
-	 */
-	function traverseTwoPhase(inst, fn, arg) {
-	  var path = [];
-	  while (inst) {
-	    path.push(inst);
-	    inst = inst._hostParent;
-	  }
-	  var i;
-	  for (i = path.length; i-- > 0;) {
-	    fn(path[i], 'captured', arg);
-	  }
-	  for (i = 0; i < path.length; i++) {
-	    fn(path[i], 'bubbled', arg);
-	  }
-	}
-
-	/**
-	 * Traverses the ID hierarchy and invokes the supplied `cb` on any IDs that
-	 * should would receive a `mouseEnter` or `mouseLeave` event.
-	 *
-	 * Does not invoke the callback on the nearest common ancestor because nothing
-	 * "entered" or "left" that element.
-	 */
-	function traverseEnterLeave(from, to, fn, argFrom, argTo) {
-	  var common = from && to ? getLowestCommonAncestor(from, to) : null;
-	  var pathFrom = [];
-	  while (from && from !== common) {
-	    pathFrom.push(from);
-	    from = from._hostParent;
-	  }
-	  var pathTo = [];
-	  while (to && to !== common) {
-	    pathTo.push(to);
-	    to = to._hostParent;
-	  }
-	  var i;
-	  for (i = 0; i < pathFrom.length; i++) {
-	    fn(pathFrom[i], 'bubbled', argFrom);
-	  }
-	  for (i = pathTo.length; i-- > 0;) {
-	    fn(pathTo[i], 'captured', argTo);
-	  }
-	}
-
-	module.exports = {
-	  isAncestor: isAncestor,
-	  getLowestCommonAncestor: getLowestCommonAncestor,
-	  getParentInstance: getParentInstance,
-	  traverseTwoPhase: traverseTwoPhase,
-	  traverseEnterLeave: traverseEnterLeave
-	};
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 144 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35),
-	    _assign = __webpack_require__(53);
-
-	var DOMChildrenOperations = __webpack_require__(84);
-	var DOMLazyTree = __webpack_require__(85);
-	var ReactDOMComponentTree = __webpack_require__(34);
-
-	var escapeTextContentForBrowser = __webpack_require__(90);
-	var invariant = __webpack_require__(37);
-	var validateDOMNesting = __webpack_require__(141);
-
-	/**
-	 * 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 between comment nodes 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 ReactDOMTextComponent
-	 * @extends ReactComponent
-	 * @internal
-	 */
-	var ReactDOMTextComponent = function (text) {
-	  // TODO: This is really a ReactText (ReactNode), not a ReactElement
-	  this._currentElement = text;
-	  this._stringText = '' + text;
-	  // ReactDOMComponentTree uses these:
-	  this._hostNode = null;
-	  this._hostParent = null;
-
-	  // Properties
-	  this._domID = 0;
-	  this._mountIndex = 0;
-	  this._closingComment = null;
-	  this._commentNodes = null;
-	};
-
-	_assign(ReactDOMTextComponent.prototype, {
-
-	  /**
-	   * Creates the markup for this text node. This node is not intended to have
-	   * any features besides containing text content.
-	   *
-	   * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
-	   * @return {string} Markup for this text node.
-	   * @internal
-	   */
-	  mountComponent: function (transaction, hostParent, hostContainerInfo, context) {
-	    if (process.env.NODE_ENV !== 'production') {
-	      var parentInfo;
-	      if (hostParent != null) {
-	        parentInfo = hostParent._ancestorInfo;
-	      } else if (hostContainerInfo != null) {
-	        parentInfo = hostContainerInfo._ancestorInfo;
-	      }
-	      if (parentInfo) {
-	        // parentInfo should always be present except for the top-level
-	        // component when server rendering
-	        validateDOMNesting(null, this._stringText, this, parentInfo);
-	      }
-	    }
-
-	    var domID = hostContainerInfo._idCounter++;
-	    var openingValue = ' react-text: ' + domID + ' ';
-	    var closingValue = ' /react-text ';
-	    this._domID = domID;
-	    this._hostParent = hostParent;
-	    if (transaction.useCreateElement) {
-	      var ownerDocument = hostContainerInfo._ownerDocument;
-	      var openingComment = ownerDocument.createComment(openingValue);
-	      var closingComment = ownerDocument.createComment(closingValue);
-	      var lazyTree = DOMLazyTree(ownerDocument.createDocumentFragment());
-	      DOMLazyTree.queueChild(lazyTree, DOMLazyTree(openingComment));
-	      if (this._stringText) {
-	        DOMLazyTree.queueChild(lazyTree, DOMLazyTree(ownerDocument.createTextNode(this._stringText)));
-	      }
-	      DOMLazyTree.queueChild(lazyTree, DOMLazyTree(closingComment));
-	      ReactDOMComponentTree.precacheNode(this, openingComment);
-	      this._closingComment = closingComment;
-	      return lazyTree;
-	    } else {
-	      var escapedText = escapeTextContentForBrowser(this._stringText);
-
-	      if (transaction.renderToStaticMarkup) {
-	        // Normally we'd wrap this between comment nodes for the reasons stated
-	        // above, but since this is a situation where React won't take over
-	        // (static pages), we can simply return the text as it is.
-	        return escapedText;
-	      }
-
-	      return '<!--' + openingValue + '-->' + escapedText + '<!--' + closingValue + '-->';
-	    }
-	  },
-
-	  /**
-	   * Updates this component by updating the text content.
-	   *
-	   * @param {ReactText} nextText The next text content
-	   * @param {ReactReconcileTransaction} transaction
-	   * @internal
-	   */
-	  receiveComponent: function (nextText, transaction) {
-	    if (nextText !== this._currentElement) {
-	      this._currentElement = nextText;
-	      var nextStringText = '' + nextText;
-	      if (nextStringText !== this._stringText) {
-	        // TODO: Save this as pending props and use performUpdateIfNecessary
-	        // and/or updateComponent to do the actual update for consistency with
-	        // other component types?
-	        this._stringText = nextStringText;
-	        var commentNodes = this.getHostNode();
-	        DOMChildrenOperations.replaceDelimitedText(commentNodes[0], commentNodes[1], nextStringText);
-	      }
-	    }
-	  },
-
-	  getHostNode: function () {
-	    var hostNode = this._commentNodes;
-	    if (hostNode) {
-	      return hostNode;
-	    }
-	    if (!this._closingComment) {
-	      var openingComment = ReactDOMComponentTree.getNodeFromInstance(this);
-	      var node = openingComment.nextSibling;
-	      while (true) {
-	        !(node != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Missing closing comment for text component %s', this._domID) : _prodInvariant('67', this._domID) : void 0;
-	        if (node.nodeType === 8 && node.nodeValue === ' /react-text ') {
-	          this._closingComment = node;
-	          break;
-	        }
-	        node = node.nextSibling;
-	      }
-	    }
-	    hostNode = [this._hostNode, this._closingComment];
-	    this._commentNodes = hostNode;
-	    return hostNode;
-	  },
-
-	  unmountComponent: function () {
-	    this._closingComment = null;
-	    this._commentNodes = null;
-	    ReactDOMComponentTree.uncacheNode(this);
-	  }
-
-	});
-
-	module.exports = ReactDOMTextComponent;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 145 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _assign = __webpack_require__(53);
-
-	var ReactUpdates = __webpack_require__(60);
-	var Transaction = __webpack_require__(72);
-
-	var emptyFunction = __webpack_require__(48);
-
-	var RESET_BATCHED_UPDATES = {
-	  initialize: emptyFunction,
-	  close: function () {
-	    ReactDefaultBatchingStrategy.isBatchingUpdates = false;
-	  }
-	};
-
-	var FLUSH_BATCHED_UPDATES = {
-	  initialize: emptyFunction,
-	  close: ReactUpdates.flushBatchedUpdates.bind(ReactUpdates)
-	};
-
-	var TRANSACTION_WRAPPERS = [FLUSH_BATCHED_UPDATES, RESET_BATCHED_UPDATES];
-
-	function ReactDefaultBatchingStrategyTransaction() {
-	  this.reinitializeTransaction();
-	}
-
-	_assign(ReactDefaultBatchingStrategyTransaction.prototype, Transaction, {
-	  getTransactionWrappers: function () {
-	    return TRANSACTION_WRAPPERS;
-	  }
-	});
-
-	var transaction = new ReactDefaultBatchingStrategyTransaction();
-
-	var ReactDefaultBatchingStrategy = {
-	  isBatchingUpdates: false,
-
-	  /**
-	   * Call the provided function in a context within which calls to `setState`
-	   * and friends are batched such that components aren't updated unnecessarily.
-	   */
-	  batchedUpdates: function (callback, a, b, c, d, e) {
-	    var alreadyBatchingUpdates = ReactDefaultBatchingStrategy.isBatchingUpdates;
-
-	    ReactDefaultBatchingStrategy.isBatchingUpdates = true;
-
-	    // The code is written this way to avoid extra allocations
-	    if (alreadyBatchingUpdates) {
-	      return callback(a, b, c, d, e);
-	    } else {
-	      return transaction.perform(callback, null, a, b, c, d, e);
-	    }
-	  }
-	};
-
-	module.exports = ReactDefaultBatchingStrategy;
-
-/***/ },
-/* 146 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _assign = __webpack_require__(53);
-
-	var EventListener = __webpack_require__(147);
-	var ExecutionEnvironment = __webpack_require__(51);
-	var PooledClass = __webpack_require__(54);
-	var ReactDOMComponentTree = __webpack_require__(34);
-	var ReactUpdates = __webpack_require__(60);
-
-	var getEventTarget = __webpack_require__(73);
-	var getUnboundedScrollPosition = __webpack_require__(148);
-
-	/**
-	 * Find the deepest React component completely containing the root of the
-	 * passed-in instance (for use when entire React trees are nested within each
-	 * other). If React trees are not nested, returns null.
-	 */
-	function findParent(inst) {
-	  // TODO: It may be a good idea to cache this to prevent unnecessary DOM
-	  // traversal, but caching is difficult to do correctly without using a
-	  // mutation observer to listen for all DOM changes.
-	  while (inst._hostParent) {
-	    inst = inst._hostParent;
-	  }
-	  var rootNode = ReactDOMComponentTree.getNodeFromInstance(inst);
-	  var container = rootNode.parentNode;
-	  return ReactDOMComponentTree.getClosestInstanceFromNode(container);
-	}
-
-	// Used to store ancestor hierarchy in top level callback
-	function TopLevelCallbackBookKeeping(topLevelType, nativeEvent) {
-	  this.topLevelType = topLevelType;
-	  this.nativeEvent = nativeEvent;
-	  this.ancestors = [];
-	}
-	_assign(TopLevelCallbackBookKeeping.prototype, {
-	  destructor: function () {
-	    this.topLevelType = null;
-	    this.nativeEvent = null;
-	    this.ancestors.length = 0;
-	  }
-	});
-	PooledClass.addPoolingTo(TopLevelCallbackBookKeeping, PooledClass.twoArgumentPooler);
-
-	function handleTopLevelImpl(bookKeeping) {
-	  var nativeEventTarget = getEventTarget(bookKeeping.nativeEvent);
-	  var targetInst = ReactDOMComponentTree.getClosestInstanceFromNode(nativeEventTarget);
-
-	  // Loop through the hierarchy, in case there's any nested components.
-	  // It's important that we build the array of ancestors before calling any
-	  // event handlers, because event handlers can modify the DOM, leading to
-	  // inconsistencies with ReactMount's node cache. See #1105.
-	  var ancestor = targetInst;
-	  do {
-	    bookKeeping.ancestors.push(ancestor);
-	    ancestor = ancestor && findParent(ancestor);
-	  } while (ancestor);
-
-	  for (var i = 0; i < bookKeeping.ancestors.length; i++) {
-	    targetInst = bookKeeping.ancestors[i];
-	    ReactEventListener._handleTopLevel(bookKeeping.topLevelType, targetInst, bookKeeping.nativeEvent, getEventTarget(bookKeeping.nativeEvent));
-	  }
-	}
-
-	function scrollValueMonitor(cb) {
-	  var scrollPosition = getUnboundedScrollPosition(window);
-	  cb(scrollPosition);
-	}
-
-	var ReactEventListener = {
-	  _enabled: true,
-	  _handleTopLevel: null,
-
-	  WINDOW_HANDLE: ExecutionEnvironment.canUseDOM ? window : null,
-
-	  setHandleTopLevel: function (handleTopLevel) {
-	    ReactEventListener._handleTopLevel = handleTopLevel;
-	  },
-
-	  setEnabled: function (enabled) {
-	    ReactEventListener._enabled = !!enabled;
-	  },
-
-	  isEnabled: function () {
-	    return ReactEventListener._enabled;
-	  },
-
-	  /**
-	   * Traps top-level events by using event bubbling.
-	   *
-	   * @param {string} topLevelType Record from `EventConstants`.
-	   * @param {string} handlerBaseName Event name (e.g. "click").
-	   * @param {object} element Element on which to attach listener.
-	   * @return {?object} An object with a remove function which will forcefully
-	   *                  remove the listener.
-	   * @internal
-	   */
-	  trapBubbledEvent: function (topLevelType, handlerBaseName, element) {
-	    if (!element) {
-	      return null;
-	    }
-	    return EventListener.listen(element, handlerBaseName, ReactEventListener.dispatchEvent.bind(null, topLevelType));
-	  },
-
-	  /**
-	   * Traps a top-level event by using event capturing.
-	   *
-	   * @param {string} topLevelType Record from `EventConstants`.
-	   * @param {string} handlerBaseName Event name (e.g. "click").
-	   * @param {object} element Element on which to attach listener.
-	   * @return {?object} An object with a remove function which will forcefully
-	   *                  remove the listener.
-	   * @internal
-	   */
-	  trapCapturedEvent: function (topLevelType, handlerBaseName, element) {
-	    if (!element) {
-	      return null;
-	    }
-	    return EventListener.capture(element, handlerBaseName, ReactEventListener.dispatchEvent.bind(null, topLevelType));
-	  },
-
-	  monitorScrollValue: function (refresh) {
-	    var callback = scrollValueMonitor.bind(null, refresh);
-	    EventListener.listen(window, 'scroll', callback);
-	  },
-
-	  dispatchEvent: function (topLevelType, nativeEvent) {
-	    if (!ReactEventListener._enabled) {
-	      return;
-	    }
-
-	    var bookKeeping = TopLevelCallbackBookKeeping.getPooled(topLevelType, nativeEvent);
-	    try {
-	      // Event queue being processed in the same cycle allows
-	      // `preventDefault`.
-	      ReactUpdates.batchedUpdates(handleTopLevelImpl, bookKeeping);
-	    } finally {
-	      TopLevelCallbackBookKeeping.release(bookKeeping);
-	    }
-	  }
-	};
-
-	module.exports = ReactEventListener;
-
-/***/ },
-/* 147 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
-
-	/**
-	 * Copyright (c) 2013-present, 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.
-	 *
-	 * @typechecks
-	 */
-
-	var emptyFunction = __webpack_require__(48);
-
-	/**
-	 * Upstream version of event listener. Does not take into account specific
-	 * nature of platform.
-	 */
-	var EventListener = {
-	  /**
-	   * Listen to DOM events during the bubble phase.
-	   *
-	   * @param {DOMEventTarget} target DOM element to register listener on.
-	   * @param {string} eventType Event type, e.g. 'click' or 'mouseover'.
-	   * @param {function} callback Callback function.
-	   * @return {object} Object with a `remove` method.
-	   */
-	  listen: function listen(target, eventType, callback) {
-	    if (target.addEventListener) {
-	      target.addEventListener(eventType, callback, false);
-	      return {
-	        remove: function remove() {
-	          target.removeEventListener(eventType, callback, false);
-	        }
-	      };
-	    } else if (target.attachEvent) {
-	      target.attachEvent('on' + eventType, callback);
-	      return {
-	        remove: function remove() {
-	          target.detachEvent('on' + eventType, callback);
-	        }
-	      };
-	    }
-	  },
-
-	  /**
-	   * Listen to DOM events during the capture phase.
-	   *
-	   * @param {DOMEventTarget} target DOM element to register listener on.
-	   * @param {string} eventType Event type, e.g. 'click' or 'mouseover'.
-	   * @param {function} callback Callback function.
-	   * @return {object} Object with a `remove` method.
-	   */
-	  capture: function capture(target, eventType, callback) {
-	    if (target.addEventListener) {
-	      target.addEventListener(eventType, callback, true);
-	      return {
-	        remove: function remove() {
-	          target.removeEventListener(eventType, callback, true);
-	        }
-	      };
-	    } else {
-	      if (process.env.NODE_ENV !== 'production') {
-	        console.error('Attempted to listen to events during the capture phase on a ' + 'browser that does not support the capture phase. Your application ' + 'will not receive some events.');
-	      }
-	      return {
-	        remove: emptyFunction
-	      };
-	    }
-	  },
-
-	  registerDefault: function registerDefault() {}
-	};
-
-	module.exports = EventListener;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 148 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * @typechecks
-	 */
-
-	'use strict';
-
-	/**
-	 * Gets the scroll position of the supplied element or window.
-	 *
-	 * The return values are unbounded, unlike `getScrollPosition`. This means they
-	 * may be negative or exceed the element boundaries (which is possible using
-	 * inertial scrolling).
-	 *
-	 * @param {DOMWindow|DOMElement} scrollable
-	 * @return {object} Map with `x` and `y` keys.
-	 */
-
-	function getUnboundedScrollPosition(scrollable) {
-	  if (scrollable === window) {
-	    return {
-	      x: window.pageXOffset || document.documentElement.scrollLeft,
-	      y: window.pageYOffset || document.documentElement.scrollTop
-	    };
-	  }
-	  return {
-	    x: scrollable.scrollLeft,
-	    y: scrollable.scrollTop
-	  };
-	}
-
-	module.exports = getUnboundedScrollPosition;
-
-/***/ },
-/* 149 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var DOMProperty = __webpack_require__(36);
-	var EventPluginHub = __webpack_require__(43);
-	var EventPluginUtils = __webpack_require__(45);
-	var ReactComponentEnvironment = __webpack_require__(119);
-	var ReactEmptyComponent = __webpack_require__(130);
-	var ReactBrowserEventEmitter = __webpack_require__(109);
-	var ReactHostComponent = __webpack_require__(131);
-	var ReactUpdates = __webpack_require__(60);
-
-	var ReactInjection = {
-	  Component: ReactComponentEnvironment.injection,
-	  DOMProperty: DOMProperty.injection,
-	  EmptyComponent: ReactEmptyComponent.injection,
-	  EventPluginHub: EventPluginHub.injection,
-	  EventPluginUtils: EventPluginUtils.injection,
-	  EventEmitter: ReactBrowserEventEmitter.injection,
-	  HostComponent: ReactHostComponent.injection,
-	  Updates: ReactUpdates.injection
-	};
-
-	module.exports = ReactInjection;
-
-/***/ },
-/* 150 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _assign = __webpack_require__(53);
-
-	var CallbackQueue = __webpack_require__(61);
-	var PooledClass = __webpack_require__(54);
-	var ReactBrowserEventEmitter = __webpack_require__(109);
-	var ReactInputSelection = __webpack_require__(151);
-	var ReactInstrumentation = __webpack_require__(66);
-	var Transaction = __webpack_require__(72);
-	var ReactUpdateQueue = __webpack_require__(140);
-
-	/**
-	 * 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 `ReactBrowserEventEmitter` before
-	   * the reconciliation.
-	   */
-	  initialize: function () {
-	    var currentlyEnabled = ReactBrowserEventEmitter.isEnabled();
-	    ReactBrowserEventEmitter.setEnabled(false);
-	    return currentlyEnabled;
-	  },
-
-	  /**
-	   * @param {boolean} previouslyEnabled Enabled status of
-	   *   `ReactBrowserEventEmitter` before the reconciliation occurred. `close`
-	   *   restores the previous value.
-	   */
-	  close: function (previouslyEnabled) {
-	    ReactBrowserEventEmitter.setEnabled(previouslyEnabled);
-	  }
-	};
-
-	/**
-	 * Provides a queue for collecting `componentDidMount` and
-	 * `componentDidUpdate` callbacks during the transaction.
-	 */
-	var ON_DOM_READY_QUEUEING = {
-	  /**
-	   * Initializes the internal `onDOMReady` queue.
-	   */
-	  initialize: function () {
-	    this.reactMountReady.reset();
-	  },
-
-	  /**
-	   * After DOM is flushed, invoke all registered `onDOMReady` callbacks.
-	   */
-	  close: function () {
-	    this.reactMountReady.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];
-
-	if (process.env.NODE_ENV !== 'production') {
-	  TRANSACTION_WRAPPERS.push({
-	    initialize: ReactInstrumentation.debugTool.onBeginFlush,
-	    close: ReactInstrumentation.debugTool.onEndFlush
-	  });
-	}
-
-	/**
-	 * 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(useCreateElement) {
-	  this.reinitializeTransaction();
-	  // Only server-side rendering really needs this option (see
-	  // `ReactServerRendering`), but server-side uses
-	  // `ReactServerRenderingTransaction` instead. This option is here so that it's
-	  // accessible and defaults to false when `ReactDOMComponent` and
-	  // `ReactDOMTextComponent` checks it in `mountComponent`.`
-	  this.renderToStaticMarkup = false;
-	  this.reactMountReady = CallbackQueue.getPooled(null);
-	  this.useCreateElement = useCreateElement;
-	}
-
-	var Mixin = {
-	  /**
-	   * @see Transaction
-	   * @abstract
-	   * @final
-	   * @return {array<object>} List of operation wrap procedures.
-	   *   TODO: convert to array<TransactionWrapper>
-	   */
-	  getTransactionWrappers: function () {
-	    return TRANSACTION_WRAPPERS;
-	  },
-
-	  /**
-	   * @return {object} The queue to collect `onDOMReady` callbacks with.
-	   */
-	  getReactMountReady: function () {
-	    return this.reactMountReady;
-	  },
-
-	  /**
-	   * @return {object} The queue to collect React async events.
-	   */
-	  getUpdateQueue: function () {
-	    return ReactUpdateQueue;
-	  },
-
-	  /**
-	   * Save current transaction state -- if the return value from this method is
-	   * passed to `rollback`, the transaction will be reset to that state.
-	   */
-	  checkpoint: function () {
-	    // reactMountReady is the our only stateful wrapper
-	    return this.reactMountReady.checkpoint();
-	  },
-
-	  rollback: function (checkpoint) {
-	    this.reactMountReady.rollback(checkpoint);
-	  },
-
-	  /**
-	   * `PooledClass` looks for this, and will invoke this before allowing this
-	   * instance to be reused.
-	   */
-	  destructor: function () {
-	    CallbackQueue.release(this.reactMountReady);
-	    this.reactMountReady = null;
-	  }
-	};
-
-	_assign(ReactReconcileTransaction.prototype, Transaction, Mixin);
-
-	PooledClass.addPoolingTo(ReactReconcileTransaction);
-
-	module.exports = ReactReconcileTransaction;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 151 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ReactDOMSelection = __webpack_require__(152);
-
-	var containsNode = __webpack_require__(154);
-	var focusNode = __webpack_require__(98);
-	var getActiveElement = __webpack_require__(157);
-
-	function isInDocument(node) {
-	  return containsNode(document.documentElement, 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
-	 * assume buttons have range selections allowed).
-	 * Input selection module for React.
-	 */
-	var ReactInputSelection = {
-
-	  hasSelectionCapabilities: function (elem) {
-	    var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
-	    return nodeName && (nodeName === 'input' && elem.type === 'text' || 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 && isInDocument(priorFocusedElem)) {
-	      if (ReactInputSelection.hasSelectionCapabilities(priorFocusedElem)) {
-	        ReactInputSelection.setSelection(priorFocusedElem, priorSelectionRange);
-	      }
-	      focusNode(priorFocusedElem);
-	    }
-	  },
-
-	  /**
-	   * @getSelection: Gets the selection bounds of a focused textarea, input or
-	   * contentEditable node.
-	   * -@input: Look up selection bounds of this input
-	   * -@return {start: selectionStart, end: selectionEnd}
-	   */
-	  getSelection: function (input) {
-	    var selection;
-
-	    if ('selectionStart' in input) {
-	      // Modern browser with input or textarea.
-	      selection = {
-	        start: input.selectionStart,
-	        end: input.selectionEnd
-	      };
-	    } else if (document.selection && input.nodeName && input.nodeName.toLowerCase() === 'input') {
-	      // IE8 input.
-	      var range = document.selection.createRange();
-	      // There can only be one selection per document in IE, so it must
-	      // be in our element.
-	      if (range.parentElement() === input) {
-	        selection = {
-	          start: -range.moveStart('character', -input.value.length),
-	          end: -range.moveEnd('character', -input.value.length)
-	        };
-	      }
-	    } else {
-	      // Content editable or old IE textarea.
-	      selection = ReactDOMSelection.getOffsets(input);
-	    }
-
-	    return selection || { start: 0, end: 0 };
-	  },
-
-	  /**
-	   * @setSelection: Sets the selection bounds of a textarea or input and focuses
-	   * the input.
-	   * -@input     Set selection bounds of this input or textarea
-	   * -@offsets   Object of same form that is returned from get*
-	   */
-	  setSelection: function (input, offsets) {
-	    var start = offsets.start;
-	    var end = offsets.end;
-	    if (end === undefined) {
-	      end = start;
-	    }
-
-	    if ('selectionStart' in input) {
-	      input.selectionStart = start;
-	      input.selectionEnd = Math.min(end, input.value.length);
-	    } else if (document.selection && input.nodeName && input.nodeName.toLowerCase() === 'input') {
-	      var range = input.createTextRange();
-	      range.collapse(true);
-	      range.moveStart('character', start);
-	      range.moveEnd('character', end - start);
-	      range.select();
-	    } else {
-	      ReactDOMSelection.setOffsets(input, offsets);
-	    }
-	  }
-	};
-
-	module.exports = ReactInputSelection;
-
-/***/ },
-/* 152 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ExecutionEnvironment = __webpack_require__(51);
-
-	var getNodeForCharacterOffset = __webpack_require__(153);
-	var getTextContentAccessor = __webpack_require__(55);
-
-	/**
-	 * While `isCollapsed` is available on the Selection object and `collapsed`
-	 * is available on the Range object, IE11 sometimes gets them wrong.
-	 * If the anchor/focus nodes and offsets are the same, the range is collapsed.
-	 */
-	function isCollapsed(anchorNode, anchorOffset, focusNode, focusOffset) {
-	  return anchorNode === focusNode && anchorOffset === focusOffset;
-	}
-
-	/**
-	 * Get the appropriate anchor and focus node/offset pairs for IE.
-	 *
-	 * The catch here is that IE's selection API doesn't provide information
-	 * about whether the selection is forward or backward, so we have to
-	 * behave as though it's always forward.
-	 *
-	 * IE text differs from modern selection in that it behaves as though
-	 * block elements end with a new line. This means character offsets will
-	 * differ between the two APIs.
-	 *
-	 * @param {DOMElement} node
-	 * @return {object}
-	 */
-	function getIEOffsets(node) {
-	  var selection = document.selection;
-	  var selectedRange = selection.createRange();
-	  var selectedLength = selectedRange.text.length;
-
-	  // Duplicate selection so we can move range without breaking user selection.
-	  var fromStart = selectedRange.duplicate();
-	  fromStart.moveToElementText(node);
-	  fromStart.setEndPoint('EndToStart', selectedRange);
-
-	  var startOffset = fromStart.text.length;
-	  var endOffset = startOffset + selectedLength;
-
-	  return {
-	    start: startOffset,
-	    end: endOffset
-	  };
-	}
-
-	/**
-	 * @param {DOMElement} node
-	 * @return {?object}
-	 */
-	function getModernOffsets(node) {
-	  var selection = window.getSelection && window.getSelection();
-
-	  if (!selection || selection.rangeCount === 0) {
-	    return null;
-	  }
-
-	  var anchorNode = selection.anchorNode;
-	  var anchorOffset = selection.anchorOffset;
-	  var focusNode = selection.focusNode;
-	  var focusOffset = selection.focusOffset;
-
-	  var currentRange = selection.getRangeAt(0);
-
-	  // In Firefox, range.startContainer and range.endContainer can be "anonymous
-	  // divs", e.g. the up/down buttons on an <input type="number">. Anonymous
-	  // divs do not seem to expose properties, triggering a "Permission denied
-	  // error" if any of its properties are accessed. The only seemingly possible
-	  // way to avoid erroring is to access a property that typically works for
-	  // non-anonymous divs and catch any error that may otherwise arise. See
-	  // https://bugzilla.mozilla.org/show_bug.cgi?id=208427
-	  try {
-	    /* eslint-disable no-unused-expressions */
-	    currentRange.startContainer.nodeType;
-	    currentRange.endContainer.nodeType;
-	    /* eslint-enable no-unused-expressions */
-	  } catch (e) {
-	    return null;
-	  }
-
-	  // If the node and offset values are the same, the selection is collapsed.
-	  // `Selection.isCollapsed` is available natively, but IE sometimes gets
-	  // this value wrong.
-	  var isSelectionCollapsed = isCollapsed(selection.anchorNode, selection.anchorOffset, selection.focusNode, selection.focusOffset);
-
-	  var rangeLength = isSelectionCollapsed ? 0 : currentRange.toString().length;
-
-	  var tempRange = currentRange.cloneRange();
-	  tempRange.selectNodeContents(node);
-	  tempRange.setEnd(currentRange.startContainer, currentRange.startOffset);
-
-	  var isTempRangeCollapsed = isCollapsed(tempRange.startContainer, tempRange.startOffset, tempRange.endContainer, tempRange.endOffset);
-
-	  var start = isTempRangeCollapsed ? 0 : tempRange.toString().length;
-	  var end = start + rangeLength;
-
-	  // Detect whether the selection is backward.
-	  var detectionRange = document.createRange();
-	  detectionRange.setStart(anchorNode, anchorOffset);
-	  detectionRange.setEnd(focusNode, focusOffset);
-	  var isBackward = detectionRange.collapsed;
-
-	  return {
-	    start: isBackward ? end : start,
-	    end: isBackward ? start : end
-	  };
-	}
-
-	/**
-	 * @param {DOMElement|DOMTextNode} node
-	 * @param {object} offsets
-	 */
-	function setIEOffsets(node, offsets) {
-	  var range = document.selection.createRange().duplicate();
-	  var start, end;
-
-	  if (offsets.end === undefined) {
-	    start = offsets.start;
-	    end = start;
-	  } else if (offsets.start > offsets.end) {
-	    start = offsets.end;
-	    end = offsets.start;
-	  } else {
-	    start = offsets.start;
-	    end = offsets.end;
-	  }
-
-	  range.moveToElementText(node);
-	  range.moveStart('character', start);
-	  range.setEndPoint('EndToStart', range);
-	  range.moveEnd('character', end - start);
-	  range.select();
-	}
-
-	/**
-	 * In modern non-IE browsers, we can support both forward and backward
-	 * selections.
-	 *
-	 * Note: IE10+ supports the Selection object, but it does not support
-	 * the `extend` method, which means that even in modern IE, it's not possible
-	 * to programmatically create a backward selection. Thus, for all IE
-	 * versions, we use the old IE API to create our selections.
-	 *
-	 * @param {DOMElement|DOMTextNode} node
-	 * @param {object} offsets
-	 */
-	function setModernOffsets(node, offsets) {
-	  if (!window.getSelection) {
-	    return;
-	  }
-
-	  var selection = window.getSelection();
-	  var length = node[getTextContentAccessor()].length;
-	  var start = Math.min(offsets.start, length);
-	  var end = offsets.end === undefined ? start : Math.min(offsets.end, length);
-
-	  // IE 11 uses modern selection, but doesn't support the extend method.
-	  // Flip backward selections, so we can set with a single range.
-	  if (!selection.extend && start > end) {
-	    var temp = end;
-	    end = start;
-	    start = temp;
-	  }
-
-	  var startMarker = getNodeForCharacterOffset(node, start);
-	  var endMarker = getNodeForCharacterOffset(node, end);
-
-	  if (startMarker && endMarker) {
-	    var range = document.createRange();
-	    range.setStart(startMarker.node, startMarker.offset);
-	    selection.removeAllRanges();
-
-	    if (start > end) {
-	      selection.addRange(range);
-	      selection.extend(endMarker.node, endMarker.offset);
-	    } else {
-	      range.setEnd(endMarker.node, endMarker.offset);
-	      selection.addRange(range);
-	    }
-	  }
-	}
-
-	var useIEOffsets = ExecutionEnvironment.canUseDOM && 'selection' in document && !('getSelection' in window);
-
-	var ReactDOMSelection = {
-	  /**
-	   * @param {DOMElement} node
-	   */
-	  getOffsets: useIEOffsets ? getIEOffsets : getModernOffsets,
-
-	  /**
-	   * @param {DOMElement|DOMTextNode} node
-	   * @param {object} offsets
-	   */
-	  setOffsets: useIEOffsets ? setIEOffsets : setModernOffsets
-	};
-
-	module.exports = ReactDOMSelection;
-
-/***/ },
-/* 153 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	/**
-	 * Given any node return the first leaf node without children.
-	 *
-	 * @param {DOMElement|DOMTextNode} node
-	 * @return {DOMElement|DOMTextNode}
-	 */
-
-	function getLeafNode(node) {
-	  while (node && node.firstChild) {
-	    node = node.firstChild;
-	  }
-	  return node;
-	}
-
-	/**
-	 * Get the next sibling within a container. This will walk up the
-	 * DOM if a node's siblings have been exhausted.
-	 *
-	 * @param {DOMElement|DOMTextNode} node
-	 * @return {?DOMElement|DOMTextNode}
-	 */
-	function getSiblingNode(node) {
-	  while (node) {
-	    if (node.nextSibling) {
-	      return node.nextSibling;
-	    }
-	    node = node.parentNode;
-	  }
-	}
-
-	/**
-	 * Get object describing the nodes which contain characters at offset.
-	 *
-	 * @param {DOMElement|DOMTextNode} root
-	 * @param {number} offset
-	 * @return {?object}
-	 */
-	function getNodeForCharacterOffset(root, offset) {
-	  var node = getLeafNode(root);
-	  var nodeStart = 0;
-	  var nodeEnd = 0;
-
-	  while (node) {
-	    if (node.nodeType === 3) {
-	      nodeEnd = nodeStart + node.textContent.length;
-
-	      if (nodeStart <= offset && nodeEnd >= offset) {
-	        return {
-	          node: node,
-	          offset: offset - nodeStart
-	        };
-	      }
-
-	      nodeStart = nodeEnd;
-	    }
-
-	    node = getLeafNode(getSiblingNode(node));
-	  }
-	}
-
-	module.exports = getNodeForCharacterOffset;
-
-/***/ },
-/* 154 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	var isTextNode = __webpack_require__(155);
-
-	/*eslint-disable no-bitwise */
-
-	/**
-	 * Checks if a given DOM node contains or is another DOM node.
-	 */
-	function containsNode(outerNode, innerNode) {
-	  if (!outerNode || !innerNode) {
-	    return false;
-	  } else if (outerNode === innerNode) {
-	    return true;
-	  } else if (isTextNode(outerNode)) {
-	    return false;
-	  } else if (isTextNode(innerNode)) {
-	    return containsNode(outerNode, innerNode.parentNode);
-	  } else if ('contains' in outerNode) {
-	    return outerNode.contains(innerNode);
-	  } else if (outerNode.compareDocumentPosition) {
-	    return !!(outerNode.compareDocumentPosition(innerNode) & 16);
-	  } else {
-	    return false;
-	  }
-	}
-
-	module.exports = containsNode;
-
-/***/ },
-/* 155 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * @typechecks
-	 */
-
-	var isNode = __webpack_require__(156);
-
-	/**
-	 * @param {*} object The object to check.
-	 * @return {boolean} Whether or not the object is a DOM text node.
-	 */
-	function isTextNode(object) {
-	  return isNode(object) && object.nodeType == 3;
-	}
-
-	module.exports = isTextNode;
-
-/***/ },
-/* 156 */
-/***/ function(module, exports) {
-
-	'use strict';
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * @typechecks
-	 */
-
-	/**
-	 * @param {*} object The object to check.
-	 * @return {boolean} Whether or not the object is a DOM node.
-	 */
-	function isNode(object) {
-	  return !!(object && (typeof Node === 'function' ? object instanceof Node : typeof object === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string'));
-	}
-
-	module.exports = isNode;
-
-/***/ },
-/* 157 */
-/***/ function(module, exports) {
-
-	'use strict';
-
-	/**
-	 * Copyright (c) 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * @typechecks
-	 */
-
-	/* eslint-disable fb-www/typeof-undefined */
-
-	/**
-	 * Same as document.activeElement but wraps in a try-catch block. In IE it is
-	 * not safe to call document.activeElement if there is nothing focused.
-	 *
-	 * The activeElement will be null only if the document or document body is not
-	 * yet defined.
-	 */
-	function getActiveElement() /*?DOMElement*/{
-	  if (typeof document === 'undefined') {
-	    return null;
-	  }
-	  try {
-	    return document.activeElement || document.body;
-	  } catch (e) {
-	    return document.body;
-	  }
-	}
-
-	module.exports = getActiveElement;
-
-/***/ },
-/* 158 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var NS = {
-	  xlink: 'http://www.w3.org/1999/xlink',
-	  xml: 'http://www.w3.org/XML/1998/namespace'
-	};
-
-	// We use attributes for everything SVG so let's avoid some duplication and run
-	// code instead.
-	// The following are all specified in the HTML config already so we exclude here.
-	// - class (as className)
-	// - color
-	// - height
-	// - id
-	// - lang
-	// - max
-	// - media
-	// - method
-	// - min
-	// - name
-	// - style
-	// - target
-	// - type
-	// - width
-	var ATTRS = {
-	  accentHeight: 'accent-height',
-	  accumulate: 0,
-	  additive: 0,
-	  alignmentBaseline: 'alignment-baseline',
-	  allowReorder: 'allowReorder',
-	  alphabetic: 0,
-	  amplitude: 0,
-	  arabicForm: 'arabic-form',
-	  ascent: 0,
-	  attributeName: 'attributeName',
-	  attributeType: 'attributeType',
-	  autoReverse: 'autoReverse',
-	  azimuth: 0,
-	  baseFrequency: 'baseFrequency',
-	  baseProfile: 'baseProfile',
-	  baselineShift: 'baseline-shift',
-	  bbox: 0,
-	  begin: 0,
-	  bias: 0,
-	  by: 0,
-	  calcMode: 'calcMode',
-	  capHeight: 'cap-height',
-	  clip: 0,
-	  clipPath: 'clip-path',
-	  clipRule: 'clip-rule',
-	  clipPathUnits: 'clipPathUnits',
-	  colorInterpolation: 'color-interpolation',
-	  colorInterpolationFilters: 'color-interpolation-filters',
-	  colorProfile: 'color-profile',
-	  colorRendering: 'color-rendering',
-	  contentScriptType: 'contentScriptType',
-	  contentStyleType: 'contentStyleType',
-	  cursor: 0,
-	  cx: 0,
-	  cy: 0,
-	  d: 0,
-	  decelerate: 0,
-	  descent: 0,
-	  diffuseConstant: 'diffuseConstant',
-	  direction: 0,
-	  display: 0,
-	  divisor: 0,
-	  dominantBaseline: 'dominant-baseline',
-	  dur: 0,
-	  dx: 0,
-	  dy: 0,
-	  edgeMode: 'edgeMode',
-	  elevation: 0,
-	  enableBackground: 'enable-background',
-	  end: 0,
-	  exponent: 0,
-	  externalResourcesRequired: 'externalResourcesRequired',
-	  fill: 0,
-	  fillOpacity: 'fill-opacity',
-	  fillRule: 'fill-rule',
-	  filter: 0,
-	  filterRes: 'filterRes',
-	  filterUnits: 'filterUnits',
-	  floodColor: 'flood-color',
-	  floodOpacity: 'flood-opacity',
-	  focusable: 0,
-	  fontFamily: 'font-family',
-	  fontSize: 'font-size',
-	  fontSizeAdjust: 'font-size-adjust',
-	  fontStretch: 'font-stretch',
-	  fontStyle: 'font-style',
-	  fontVariant: 'font-variant',
-	  fontWeight: 'font-weight',
-	  format: 0,
-	  from: 0,
-	  fx: 0,
-	  fy: 0,
-	  g1: 0,
-	  g2: 0,
-	  glyphName: 'glyph-name',
-	  glyphOrientationHorizontal: 'glyph-orientation-horizontal',
-	  glyphOrientationVertical: 'glyph-orientation-vertical',
-	  glyphRef: 'glyphRef',
-	  gradientTransform: 'gradientTransform',
-	  gradientUnits: 'gradientUnits',
-	  hanging: 0,
-	  horizAdvX: 'horiz-adv-x',
-	  horizOriginX: 'horiz-origin-x',
-	  ideographic: 0,
-	  imageRendering: 'image-rendering',
-	  'in': 0,
-	  in2: 0,
-	  intercept: 0,
-	  k: 0,
-	  k1: 0,
-	  k2: 0,
-	  k3: 0,
-	  k4: 0,
-	  kernelMatrix: 'kernelMatrix',
-	  kernelUnitLength: 'kernelUnitLength',
-	  kerning: 0,
-	  keyPoints: 'keyPoints',
-	  keySplines: 'keySplines',
-	  keyTimes: 'keyTimes',
-	  lengthAdjust: 'lengthAdjust',
-	  letterSpacing: 'letter-spacing',
-	  lightingColor: 'lighting-color',
-	  limitingConeAngle: 'limitingConeAngle',
-	  local: 0,
-	  markerEnd: 'marker-end',
-	  markerMid: 'marker-mid',
-	  markerStart: 'marker-start',
-	  markerHeight: 'markerHeight',
-	  markerUnits: 'markerUnits',
-	  markerWidth: 'markerWidth',
-	  mask: 0,
-	  maskContentUnits: 'maskContentUnits',
-	  maskUnits: 'maskUnits',
-	  mathematical: 0,
-	  mode: 0,
-	  numOctaves: 'numOctaves',
-	  offset: 0,
-	  opacity: 0,
-	  operator: 0,
-	  order: 0,
-	  orient: 0,
-	  orientation: 0,
-	  origin: 0,
-	  overflow: 0,
-	  overlinePosition: 'overline-position',
-	  overlineThickness: 'overline-thickness',
-	  paintOrder: 'paint-order',
-	  panose1: 'panose-1',
-	  pathLength: 'pathLength',
-	  patternContentUnits: 'patternContentUnits',
-	  patternTransform: 'patternTransform',
-	  patternUnits: 'patternUnits',
-	  pointerEvents: 'pointer-events',
-	  points: 0,
-	  pointsAtX: 'pointsAtX',
-	  pointsAtY: 'pointsAtY',
-	  pointsAtZ: 'pointsAtZ',
-	  preserveAlpha: 'preserveAlpha',
-	  preserveAspectRatio: 'preserveAspectRatio',
-	  primitiveUnits: 'primitiveUnits',
-	  r: 0,
-	  radius: 0,
-	  refX: 'refX',
-	  refY: 'refY',
-	  renderingIntent: 'rendering-intent',
-	  repeatCount: 'repeatCount',
-	  repeatDur: 'repeatDur',
-	  requiredExtensions: 'requiredExtensions',
-	  requiredFeatures: 'requiredFeatures',
-	  restart: 0,
-	  result: 0,
-	  rotate: 0,
-	  rx: 0,
-	  ry: 0,
-	  scale: 0,
-	  seed: 0,
-	  shapeRendering: 'shape-rendering',
-	  slope: 0,
-	  spacing: 0,
-	  specularConstant: 'specularConstant',
-	  specularExponent: 'specularExponent',
-	  speed: 0,
-	  spreadMethod: 'spreadMethod',
-	  startOffset: 'startOffset',
-	  stdDeviation: 'stdDeviation',
-	  stemh: 0,
-	  stemv: 0,
-	  stitchTiles: 'stitchTiles',
-	  stopColor: 'stop-color',
-	  stopOpacity: 'stop-opacity',
-	  strikethroughPosition: 'strikethrough-position',
-	  strikethroughThickness: 'strikethrough-thickness',
-	  string: 0,
-	  stroke: 0,
-	  strokeDasharray: 'stroke-dasharray',
-	  strokeDashoffset: 'stroke-dashoffset',
-	  strokeLinecap: 'stroke-linecap',
-	  strokeLinejoin: 'stroke-linejoin',
-	  strokeMiterlimit: 'stroke-miterlimit',
-	  strokeOpacity: 'stroke-opacity',
-	  strokeWidth: 'stroke-width',
-	  surfaceScale: 'surfaceScale',
-	  systemLanguage: 'systemLanguage',
-	  tableValues: 'tableValues',
-	  targetX: 'targetX',
-	  targetY: 'targetY',
-	  textAnchor: 'text-anchor',
-	  textDecoration: 'text-decoration',
-	  textRendering: 'text-rendering',
-	  textLength: 'textLength',
-	  to: 0,
-	  transform: 0,
-	  u1: 0,
-	  u2: 0,
-	  underlinePosition: 'underline-position',
-	  underlineThickness: 'underline-thickness',
-	  unicode: 0,
-	  unicodeBidi: 'unicode-bidi',
-	  unicodeRange: 'unicode-range',
-	  unitsPerEm: 'units-per-em',
-	  vAlphabetic: 'v-alphabetic',
-	  vHanging: 'v-hanging',
-	  vIdeographic: 'v-ideographic',
-	  vMathematical: 'v-mathematical',
-	  values: 0,
-	  vectorEffect: 'vector-effect',
-	  version: 0,
-	  vertAdvY: 'vert-adv-y',
-	  vertOriginX: 'vert-origin-x',
-	  vertOriginY: 'vert-origin-y',
-	  viewBox: 'viewBox',
-	  viewTarget: 'viewTarget',
-	  visibility: 0,
-	  widths: 0,
-	  wordSpacing: 'word-spacing',
-	  writingMode: 'writing-mode',
-	  x: 0,
-	  xHeight: 'x-height',
-	  x1: 0,
-	  x2: 0,
-	  xChannelSelector: 'xChannelSelector',
-	  xlinkActuate: 'xlink:actuate',
-	  xlinkArcrole: 'xlink:arcrole',
-	  xlinkHref: 'xlink:href',
-	  xlinkRole: 'xlink:role',
-	  xlinkShow: 'xlink:show',
-	  xlinkTitle: 'xlink:title',
-	  xlinkType: 'xlink:type',
-	  xmlBase: 'xml:base',
-	  xmlns: 0,
-	  xmlnsXlink: 'xmlns:xlink',
-	  xmlLang: 'xml:lang',
-	  xmlSpace: 'xml:space',
-	  y: 0,
-	  y1: 0,
-	  y2: 0,
-	  yChannelSelector: 'yChannelSelector',
-	  z: 0,
-	  zoomAndPan: 'zoomAndPan'
-	};
-
-	var SVGDOMPropertyConfig = {
-	  Properties: {},
-	  DOMAttributeNamespaces: {
-	    xlinkActuate: NS.xlink,
-	    xlinkArcrole: NS.xlink,
-	    xlinkHref: NS.xlink,
-	    xlinkRole: NS.xlink,
-	    xlinkShow: NS.xlink,
-	    xlinkTitle: NS.xlink,
-	    xlinkType: NS.xlink,
-	    xmlBase: NS.xml,
-	    xmlLang: NS.xml,
-	    xmlSpace: NS.xml
-	  },
-	  DOMAttributeNames: {}
-	};
-
-	Object.keys(ATTRS).forEach(function (key) {
-	  SVGDOMPropertyConfig.Properties[key] = 0;
-	  if (ATTRS[key]) {
-	    SVGDOMPropertyConfig.DOMAttributeNames[key] = ATTRS[key];
-	  }
-	});
-
-	module.exports = SVGDOMPropertyConfig;
-
-/***/ },
-/* 159 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var EventPropagators = __webpack_require__(42);
-	var ExecutionEnvironment = __webpack_require__(51);
-	var ReactDOMComponentTree = __webpack_require__(34);
-	var ReactInputSelection = __webpack_require__(151);
-	var SyntheticEvent = __webpack_require__(57);
-
-	var getActiveElement = __webpack_require__(157);
-	var isTextInputElement = __webpack_require__(75);
-	var shallowEqual = __webpack_require__(128);
-
-	var skipSelectionChangeEvent = ExecutionEnvironment.canUseDOM && 'documentMode' in document && document.documentMode <= 11;
-
-	var eventTypes = {
-	  select: {
-	    phasedRegistrationNames: {
-	      bubbled: 'onSelect',
-	      captured: 'onSelectCapture'
-	    },
-	    dependencies: ['topBlur', 'topContextMenu', 'topFocus', 'topKeyDown', 'topKeyUp', 'topMouseDown', 'topMouseUp', 'topSelectionChange']
-	  }
-	};
-
-	var activeElement = null;
-	var activeElementInst = null;
-	var lastSelection = null;
-	var mouseDown = false;
-
-	// Track whether a listener exists for this plugin. If none exist, we do
-	// not extract events. See #3639.
-	var hasListener = false;
-
-	/**
-	 * Get an object which is a unique representation of the current selection.
-	 *
-	 * The return value will not be consistent across nodes or browsers, but
-	 * two identical selections on the same node will return identical objects.
-	 *
-	 * @param {DOMElement} node
-	 * @return {object}
-	 */
-	function getSelection(node) {
-	  if ('selectionStart' in node && ReactInputSelection.hasSelectionCapabilities(node)) {
-	    return {
-	      start: node.selectionStart,
-	      end: node.selectionEnd
-	    };
-	  } else if (window.getSelection) {
-	    var selection = window.getSelection();
-	    return {
-	      anchorNode: selection.anchorNode,
-	      anchorOffset: selection.anchorOffset,
-	      focusNode: selection.focusNode,
-	      focusOffset: selection.focusOffset
-	    };
-	  } else if (document.selection) {
-	    var range = document.selection.createRange();
-	    return {
-	      parentElement: range.parentElement(),
-	      text: range.text,
-	      top: range.boundingTop,
-	      left: range.boundingLeft
-	    };
-	  }
-	}
-
-	/**
-	 * Poll selection to see whether it's changed.
-	 *
-	 * @param {object} nativeEvent
-	 * @return {?SyntheticEvent}
-	 */
-	function constructSelectEvent(nativeEvent, nativeEventTarget) {
-	  // Ensure we have the right element, and that the user is not dragging a
-	  // selection (this matches native `select` event behavior). In HTML5, select
-	  // fires only on input and textarea thus if there's no focused element we
-	  // won't dispatch.
-	  if (mouseDown || activeElement == null || activeElement !== getActiveElement()) {
-	    return null;
-	  }
-
-	  // Only fire when selection has actually changed.
-	  var currentSelection = getSelection(activeElement);
-	  if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {
-	    lastSelection = currentSelection;
-
-	    var syntheticEvent = SyntheticEvent.getPooled(eventTypes.select, activeElementInst, nativeEvent, nativeEventTarget);
-
-	    syntheticEvent.type = 'select';
-	    syntheticEvent.target = activeElement;
-
-	    EventPropagators.accumulateTwoPhaseDispatches(syntheticEvent);
-
-	    return syntheticEvent;
-	  }
-
-	  return null;
-	}
-
-	/**
-	 * This plugin creates an `onSelect` event that normalizes select events
-	 * across form elements.
-	 *
-	 * Supported elements are:
-	 * - input (see `isTextInputElement`)
-	 * - textarea
-	 * - contentEditable
-	 *
-	 * This differs from native browser implementations in the following ways:
-	 * - Fires on contentEditable fields as well as inputs.
-	 * - Fires for collapsed selection.
-	 * - Fires after user input.
-	 */
-	var SelectEventPlugin = {
-
-	  eventTypes: eventTypes,
-
-	  extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-	    if (!hasListener) {
-	      return null;
-	    }
-
-	    var targetNode = targetInst ? ReactDOMComponentTree.getNodeFromInstance(targetInst) : window;
-
-	    switch (topLevelType) {
-	      // Track the input node that has focus.
-	      case 'topFocus':
-	        if (isTextInputElement(targetNode) || targetNode.contentEditable === 'true') {
-	          activeElement = targetNode;
-	          activeElementInst = targetInst;
-	          lastSelection = null;
-	        }
-	        break;
-	      case 'topBlur':
-	        activeElement = null;
-	        activeElementInst = null;
-	        lastSelection = null;
-	        break;
-
-	      // Don't fire the event while the user is dragging. This matches the
-	      // semantics of the native select event.
-	      case 'topMouseDown':
-	        mouseDown = true;
-	        break;
-	      case 'topContextMenu':
-	      case 'topMouseUp':
-	        mouseDown = false;
-	        return constructSelectEvent(nativeEvent, nativeEventTarget);
-
-	      // Chrome and IE fire non-standard event when selection is changed (and
-	      // sometimes when it hasn't). IE's event fires out of order with respect
-	      // to key and input events on deletion, so we discard it.
-	      //
-	      // Firefox doesn't support selectionchange, so check selection status
-	      // after each key entry. The selection changes after keydown and before
-	      // keyup, but we check on keydown as well in the case of holding down a
-	      // key, when multiple keydown events are fired but only one keyup is.
-	      // This is also our approach for IE handling, for the reason above.
-	      case 'topSelectionChange':
-	        if (skipSelectionChangeEvent) {
-	          break;
-	        }
-	      // falls through
-	      case 'topKeyDown':
-	      case 'topKeyUp':
-	        return constructSelectEvent(nativeEvent, nativeEventTarget);
-	    }
-
-	    return null;
-	  },
-
-	  didPutListener: function (inst, registrationName, listener) {
-	    if (registrationName === 'onSelect') {
-	      hasListener = true;
-	    }
-	  }
-	};
-
-	module.exports = SelectEventPlugin;
-
-/***/ },
-/* 160 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var EventListener = __webpack_require__(147);
-	var EventPropagators = __webpack_require__(42);
-	var ReactDOMComponentTree = __webpack_require__(34);
-	var SyntheticAnimationEvent = __webpack_require__(161);
-	var SyntheticClipboardEvent = __webpack_require__(162);
-	var SyntheticEvent = __webpack_require__(57);
-	var SyntheticFocusEvent = __webpack_require__(163);
-	var SyntheticKeyboardEvent = __webpack_require__(164);
-	var SyntheticMouseEvent = __webpack_require__(78);
-	var SyntheticDragEvent = __webpack_require__(167);
-	var SyntheticTouchEvent = __webpack_require__(168);
-	var SyntheticTransitionEvent = __webpack_require__(169);
-	var SyntheticUIEvent = __webpack_require__(79);
-	var SyntheticWheelEvent = __webpack_require__(170);
-
-	var emptyFunction = __webpack_require__(48);
-	var getEventCharCode = __webpack_require__(165);
-	var invariant = __webpack_require__(37);
-
-	/**
-	 * Turns
-	 * ['abort', ...]
-	 * into
-	 * eventTypes = {
-	 *   'abort': {
-	 *     phasedRegistrationNames: {
-	 *       bubbled: 'onAbort',
-	 *       captured: 'onAbortCapture',
-	 *     },
-	 *     dependencies: ['topAbort'],
-	 *   },
-	 *   ...
-	 * };
-	 * topLevelEventsToDispatchConfig = {
-	 *   'topAbort': { sameConfig }
-	 * };
-	 */
-	var eventTypes = {};
-	var topLevelEventsToDispatchConfig = {};
-	['abort', 'animationEnd', 'animationIteration', 'animationStart', 'blur', 'canPlay', 'canPlayThrough', 'click', 'contextMenu', 'copy', 'cut', 'doubleClick', 'drag', 'dragEnd', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'dragStart', 'drop', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'focus', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'mouseDown', 'mouseMove', 'mouseOut', 'mouseOver', 'mouseUp', 'paste', 'pause', 'play', 'playing', 'progress', 'rateChange', 'reset', 'scroll', 'seeked', 'seeking', 'stalled', 'submit', 'suspend', 'timeUpdate', 'touchCancel', 'touchEnd', 'touchMove', 'touchStart', 'transitionEnd', 'volumeChange', 'waiting', 'wheel'].forEach(function (event) {
-	  var capitalizedEvent = event[0].toUpperCase() + event.slice(1);
-	  var onEvent = 'on' + capitalizedEvent;
-	  var topEvent = 'top' + capitalizedEvent;
-
-	  var type = {
-	    phasedRegistrationNames: {
-	      bubbled: onEvent,
-	      captured: onEvent + 'Capture'
-	    },
-	    dependencies: [topEvent]
-	  };
-	  eventTypes[event] = type;
-	  topLevelEventsToDispatchConfig[topEvent] = type;
-	});
-
-	var onClickListeners = {};
-
-	function getDictionaryKey(inst) {
-	  // Prevents V8 performance issue:
-	  // https://github.com/facebook/react/pull/7232
-	  return '.' + inst._rootNodeID;
-	}
-
-	function isInteractive(tag) {
-	  return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea';
-	}
-
-	var SimpleEventPlugin = {
-
-	  eventTypes: eventTypes,
-
-	  extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-	    var dispatchConfig = topLevelEventsToDispatchConfig[topLevelType];
-	    if (!dispatchConfig) {
-	      return null;
-	    }
-	    var EventConstructor;
-	    switch (topLevelType) {
-	      case 'topAbort':
-	      case 'topCanPlay':
-	      case 'topCanPlayThrough':
-	      case 'topDurationChange':
-	      case 'topEmptied':
-	      case 'topEncrypted':
-	      case 'topEnded':
-	      case 'topError':
-	      case 'topInput':
-	      case 'topInvalid':
-	      case 'topLoad':
-	      case 'topLoadedData':
-	      case 'topLoadedMetadata':
-	      case 'topLoadStart':
-	      case 'topPause':
-	      case 'topPlay':
-	      case 'topPlaying':
-	      case 'topProgress':
-	      case 'topRateChange':
-	      case 'topReset':
-	      case 'topSeeked':
-	      case 'topSeeking':
-	      case 'topStalled':
-	      case 'topSubmit':
-	      case 'topSuspend':
-	      case 'topTimeUpdate':
-	      case 'topVolumeChange':
-	      case 'topWaiting':
-	        // HTML Events
-	        // @see http://www.w3.org/TR/html5/index.html#events-0
-	        EventConstructor = SyntheticEvent;
-	        break;
-	      case 'topKeyPress':
-	        // Firefox creates a keypress event for function keys too. This removes
-	        // the unwanted keypress events. Enter is however both printable and
-	        // non-printable. One would expect Tab to be as well (but it isn't).
-	        if (getEventCharCode(nativeEvent) === 0) {
-	          return null;
-	        }
-	      /* falls through */
-	      case 'topKeyDown':
-	      case 'topKeyUp':
-	        EventConstructor = SyntheticKeyboardEvent;
-	        break;
-	      case 'topBlur':
-	      case 'topFocus':
-	        EventConstructor = SyntheticFocusEvent;
-	        break;
-	      case 'topClick':
-	        // Firefox creates a click event on right mouse clicks. This removes the
-	        // unwanted click events.
-	        if (nativeEvent.button === 2) {
-	          return null;
-	        }
-	      /* falls through */
-	      case 'topDoubleClick':
-	      case 'topMouseDown':
-	      case 'topMouseMove':
-	      case 'topMouseUp':
-	      // TODO: Disabled elements should not respond to mouse events
-	      /* falls through */
-	      case 'topMouseOut':
-	      case 'topMouseOver':
-	      case 'topContextMenu':
-	        EventConstructor = SyntheticMouseEvent;
-	        break;
-	      case 'topDrag':
-	      case 'topDragEnd':
-	      case 'topDragEnter':
-	      case 'topDragExit':
-	      case 'topDragLeave':
-	      case 'topDragOver':
-	      case 'topDragStart':
-	      case 'topDrop':
-	        EventConstructor = SyntheticDragEvent;
-	        break;
-	      case 'topTouchCancel':
-	      case 'topTouchEnd':
-	      case 'topTouchMove':
-	      case 'topTouchStart':
-	        EventConstructor = SyntheticTouchEvent;
-	        break;
-	      case 'topAnimationEnd':
-	      case 'topAnimationIteration':
-	      case 'topAnimationStart':
-	        EventConstructor = SyntheticAnimationEvent;
-	        break;
-	      case 'topTransitionEnd':
-	        EventConstructor = SyntheticTransitionEvent;
-	        break;
-	      case 'topScroll':
-	        EventConstructor = SyntheticUIEvent;
-	        break;
-	      case 'topWheel':
-	        EventConstructor = SyntheticWheelEvent;
-	        break;
-	      case 'topCopy':
-	      case 'topCut':
-	      case 'topPaste':
-	        EventConstructor = SyntheticClipboardEvent;
-	        break;
-	    }
-	    !EventConstructor ? process.env.NODE_ENV !== 'production' ? invariant(false, 'SimpleEventPlugin: Unhandled event type, `%s`.', topLevelType) : _prodInvariant('86', topLevelType) : void 0;
-	    var event = EventConstructor.getPooled(dispatchConfig, targetInst, nativeEvent, nativeEventTarget);
-	    EventPropagators.accumulateTwoPhaseDispatches(event);
-	    return event;
-	  },
-
-	  didPutListener: function (inst, registrationName, listener) {
-	    // Mobile Safari does not fire properly bubble click events on
-	    // non-interactive elements, which means delegated click listeners do not
-	    // fire. The workaround for this bug involves attaching an empty click
-	    // listener on the target node.
-	    // http://www.quirksmode.org/blog/archives/2010/09/click_event_del.html
-	    if (registrationName === 'onClick' && !isInteractive(inst._tag)) {
-	      var key = getDictionaryKey(inst);
-	      var node = ReactDOMComponentTree.getNodeFromInstance(inst);
-	      if (!onClickListeners[key]) {
-	        onClickListeners[key] = EventListener.listen(node, 'click', emptyFunction);
-	      }
-	    }
-	  },
-
-	  willDeleteListener: function (inst, registrationName) {
-	    if (registrationName === 'onClick' && !isInteractive(inst._tag)) {
-	      var key = getDictionaryKey(inst);
-	      onClickListeners[key].remove();
-	      delete onClickListeners[key];
-	    }
-	  }
-
-	};
-
-	module.exports = SimpleEventPlugin;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 161 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var SyntheticEvent = __webpack_require__(57);
-
-	/**
-	 * @interface Event
-	 * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
-	 * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent
-	 */
-	var AnimationEventInterface = {
-	  animationName: null,
-	  elapsedTime: null,
-	  pseudoElement: null
-	};
-
-	/**
-	 * @param {object} dispatchConfig Configuration used to dispatch this event.
-	 * @param {string} dispatchMarker Marker identifying the event target.
-	 * @param {object} nativeEvent Native browser event.
-	 * @extends {SyntheticEvent}
-	 */
-	function SyntheticAnimationEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
-	  return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
-	}
-
-	SyntheticEvent.augmentClass(SyntheticAnimationEvent, AnimationEventInterface);
-
-	module.exports = SyntheticAnimationEvent;
-
-/***/ },
-/* 162 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var SyntheticEvent = __webpack_require__(57);
-
-	/**
-	 * @interface Event
-	 * @see http://www.w3.org/TR/clipboard-apis/
-	 */
-	var ClipboardEventInterface = {
-	  clipboardData: function (event) {
-	    return 'clipboardData' in event ? event.clipboardData : window.clipboardData;
-	  }
-	};
-
-	/**
-	 * @param {object} dispatchConfig Configuration used to dispatch this event.
-	 * @param {string} dispatchMarker Marker identifying the event target.
-	 * @param {object} nativeEvent Native browser event.
-	 * @extends {SyntheticUIEvent}
-	 */
-	function SyntheticClipboardEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
-	  return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
-	}
-
-	SyntheticEvent.augmentClass(SyntheticClipboardEvent, ClipboardEventInterface);
-
-	module.exports = SyntheticClipboardEvent;
-
-/***/ },
-/* 163 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var SyntheticUIEvent = __webpack_require__(79);
-
-	/**
-	 * @interface FocusEvent
-	 * @see http://www.w3.org/TR/DOM-Level-3-Events/
-	 */
-	var FocusEventInterface = {
-	  relatedTarget: null
-	};
-
-	/**
-	 * @param {object} dispatchConfig Configuration used to dispatch this event.
-	 * @param {string} dispatchMarker Marker identifying the event target.
-	 * @param {object} nativeEvent Native browser event.
-	 * @extends {SyntheticUIEvent}
-	 */
-	function SyntheticFocusEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
-	  return SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
-	}
-
-	SyntheticUIEvent.augmentClass(SyntheticFocusEvent, FocusEventInterface);
-
-	module.exports = SyntheticFocusEvent;
-
-/***/ },
-/* 164 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var SyntheticUIEvent = __webpack_require__(79);
-
-	var getEventCharCode = __webpack_require__(165);
-	var getEventKey = __webpack_require__(166);
-	var getEventModifierState = __webpack_require__(81);
-
-	/**
-	 * @interface KeyboardEvent
-	 * @see http://www.w3.org/TR/DOM-Level-3-Events/
-	 */
-	var KeyboardEventInterface = {
-	  key: getEventKey,
-	  location: null,
-	  ctrlKey: null,
-	  shiftKey: null,
-	  altKey: null,
-	  metaKey: null,
-	  repeat: null,
-	  locale: null,
-	  getModifierState: getEventModifierState,
-	  // Legacy Interface
-	  charCode: function (event) {
-	    // `charCode` is the result of a KeyPress event and represents the value of
-	    // the actual printable character.
-
-	    // KeyPress is deprecated, but its replacement is not yet final and not
-	    // implemented in any major browser. Only KeyPress has charCode.
-	    if (event.type === 'keypress') {
-	      return getEventCharCode(event);
-	    }
-	    return 0;
-	  },
-	  keyCode: function (event) {
-	    // `keyCode` is the result of a KeyDown/Up event and represents the value of
-	    // physical keyboard key.
-
-	    // The actual meaning of the value depends on the users' keyboard layout
-	    // which cannot be detected. Assuming that it is a US keyboard layout
-	    // provides a surprisingly accurate mapping for US and European users.
-	    // Due to this, it is left to the user to implement at this time.
-	    if (event.type === 'keydown' || event.type === 'keyup') {
-	      return event.keyCode;
-	    }
-	    return 0;
-	  },
-	  which: function (event) {
-	    // `which` is an alias for either `keyCode` or `charCode` depending on the
-	    // type of the event.
-	    if (event.type === 'keypress') {
-	      return getEventCharCode(event);
-	    }
-	    if (event.type === 'keydown' || event.type === 'keyup') {
-	      return event.keyCode;
-	    }
-	    return 0;
-	  }
-	};
-
-	/**
-	 * @param {object} dispatchConfig Configuration used to dispatch this event.
-	 * @param {string} dispatchMarker Marker identifying the event target.
-	 * @param {object} nativeEvent Native browser event.
-	 * @extends {SyntheticUIEvent}
-	 */
-	function SyntheticKeyboardEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
-	  return SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
-	}
-
-	SyntheticUIEvent.augmentClass(SyntheticKeyboardEvent, KeyboardEventInterface);
-
-	module.exports = SyntheticKeyboardEvent;
-
-/***/ },
-/* 165 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	/**
-	 * `charCode` represents the actual "character code" and is safe to use with
-	 * `String.fromCharCode`. As such, only keys that correspond to printable
-	 * characters produce a valid `charCode`, the only exception to this is Enter.
-	 * The Tab-key is considered non-printable and does not have a `charCode`,
-	 * presumably because it does not produce a tab-character in browsers.
-	 *
-	 * @param {object} nativeEvent Native browser event.
-	 * @return {number} Normalized `charCode` property.
-	 */
-
-	function getEventCharCode(nativeEvent) {
-	  var charCode;
-	  var keyCode = nativeEvent.keyCode;
-
-	  if ('charCode' in nativeEvent) {
-	    charCode = nativeEvent.charCode;
-
-	    // FF does not set `charCode` for the Enter-key, check against `keyCode`.
-	    if (charCode === 0 && keyCode === 13) {
-	      charCode = 13;
-	    }
-	  } else {
-	    // IE8 does not implement `charCode`, but `keyCode` has the correct value.
-	    charCode = keyCode;
-	  }
-
-	  // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
-	  // Must not discard the (non-)printable Enter-key.
-	  if (charCode >= 32 || charCode === 13) {
-	    return charCode;
-	  }
-
-	  return 0;
-	}
-
-	module.exports = getEventCharCode;
-
-/***/ },
-/* 166 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var getEventCharCode = __webpack_require__(165);
-
-	/**
-	 * Normalization of deprecated HTML5 `key` values
-	 * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
-	 */
-	var normalizeKey = {
-	  'Esc': 'Escape',
-	  'Spacebar': ' ',
-	  'Left': 'ArrowLeft',
-	  'Up': 'ArrowUp',
-	  'Right': 'ArrowRight',
-	  'Down': 'ArrowDown',
-	  'Del': 'Delete',
-	  'Win': 'OS',
-	  'Menu': 'ContextMenu',
-	  'Apps': 'ContextMenu',
-	  'Scroll': 'ScrollLock',
-	  'MozPrintableKey': 'Unidentified'
-	};
-
-	/**
-	 * Translation from legacy `keyCode` to HTML5 `key`
-	 * Only special keys supported, all others depend on keyboard layout or browser
-	 * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
-	 */
-	var translateToKey = {
-	  8: 'Backspace',
-	  9: 'Tab',
-	  12: 'Clear',
-	  13: 'Enter',
-	  16: 'Shift',
-	  17: 'Control',
-	  18: 'Alt',
-	  19: 'Pause',
-	  20: 'CapsLock',
-	  27: 'Escape',
-	  32: ' ',
-	  33: 'PageUp',
-	  34: 'PageDown',
-	  35: 'End',
-	  36: 'Home',
-	  37: 'ArrowLeft',
-	  38: 'ArrowUp',
-	  39: 'ArrowRight',
-	  40: 'ArrowDown',
-	  45: 'Insert',
-	  46: 'Delete',
-	  112: 'F1', 113: 'F2', 114: 'F3', 115: 'F4', 116: 'F5', 117: 'F6',
-	  118: 'F7', 119: 'F8', 120: 'F9', 121: 'F10', 122: 'F11', 123: 'F12',
-	  144: 'NumLock',
-	  145: 'ScrollLock',
-	  224: 'Meta'
-	};
-
-	/**
-	 * @param {object} nativeEvent Native browser event.
-	 * @return {string} Normalized `key` property.
-	 */
-	function getEventKey(nativeEvent) {
-	  if (nativeEvent.key) {
-	    // Normalize inconsistent values reported by browsers due to
-	    // implementations of a working draft specification.
-
-	    // FireFox implements `key` but returns `MozPrintableKey` for all
-	    // printable characters (normalized to `Unidentified`), ignore it.
-	    var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
-	    if (key !== 'Unidentified') {
-	      return key;
-	    }
-	  }
-
-	  // Browser does not implement `key`, polyfill as much of it as we can.
-	  if (nativeEvent.type === 'keypress') {
-	    var charCode = getEventCharCode(nativeEvent);
-
-	    // The enter-key is technically both printable and non-printable and can
-	    // thus be captured by `keypress`, no other non-printable key should.
-	    return charCode === 13 ? 'Enter' : String.fromCharCode(charCode);
-	  }
-	  if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {
-	    // While user keyboard layout determines the actual meaning of each
-	    // `keyCode` value, almost all function keys have a universal value.
-	    return translateToKey[nativeEvent.keyCode] || 'Unidentified';
-	  }
-	  return '';
-	}
-
-	module.exports = getEventKey;
-
-/***/ },
-/* 167 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var SyntheticMouseEvent = __webpack_require__(78);
-
-	/**
-	 * @interface DragEvent
-	 * @see http://www.w3.org/TR/DOM-Level-3-Events/
-	 */
-	var DragEventInterface = {
-	  dataTransfer: null
-	};
-
-	/**
-	 * @param {object} dispatchConfig Configuration used to dispatch this event.
-	 * @param {string} dispatchMarker Marker identifying the event target.
-	 * @param {object} nativeEvent Native browser event.
-	 * @extends {SyntheticUIEvent}
-	 */
-	function SyntheticDragEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
-	  return SyntheticMouseEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
-	}
-
-	SyntheticMouseEvent.augmentClass(SyntheticDragEvent, DragEventInterface);
-
-	module.exports = SyntheticDragEvent;
-
-/***/ },
-/* 168 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var SyntheticUIEvent = __webpack_require__(79);
-
-	var getEventModifierState = __webpack_require__(81);
-
-	/**
-	 * @interface TouchEvent
-	 * @see http://www.w3.org/TR/touch-events/
-	 */
-	var TouchEventInterface = {
-	  touches: null,
-	  targetTouches: null,
-	  changedTouches: null,
-	  altKey: null,
-	  metaKey: null,
-	  ctrlKey: null,
-	  shiftKey: null,
-	  getModifierState: getEventModifierState
-	};
-
-	/**
-	 * @param {object} dispatchConfig Configuration used to dispatch this event.
-	 * @param {string} dispatchMarker Marker identifying the event target.
-	 * @param {object} nativeEvent Native browser event.
-	 * @extends {SyntheticUIEvent}
-	 */
-	function SyntheticTouchEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
-	  return SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
-	}
-
-	SyntheticUIEvent.augmentClass(SyntheticTouchEvent, TouchEventInterface);
-
-	module.exports = SyntheticTouchEvent;
-
-/***/ },
-/* 169 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var SyntheticEvent = __webpack_require__(57);
-
-	/**
-	 * @interface Event
-	 * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
-	 * @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent
-	 */
-	var TransitionEventInterface = {
-	  propertyName: null,
-	  elapsedTime: null,
-	  pseudoElement: null
-	};
-
-	/**
-	 * @param {object} dispatchConfig Configuration used to dispatch this event.
-	 * @param {string} dispatchMarker Marker identifying the event target.
-	 * @param {object} nativeEvent Native browser event.
-	 * @extends {SyntheticEvent}
-	 */
-	function SyntheticTransitionEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
-	  return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
-	}
-
-	SyntheticEvent.augmentClass(SyntheticTransitionEvent, TransitionEventInterface);
-
-	module.exports = SyntheticTransitionEvent;
-
-/***/ },
-/* 170 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var SyntheticMouseEvent = __webpack_require__(78);
-
-	/**
-	 * @interface WheelEvent
-	 * @see http://www.w3.org/TR/DOM-Level-3-Events/
-	 */
-	var WheelEventInterface = {
-	  deltaX: function (event) {
-	    return 'deltaX' in event ? event.deltaX :
-	    // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).
-	    'wheelDeltaX' in event ? -event.wheelDeltaX : 0;
-	  },
-	  deltaY: function (event) {
-	    return 'deltaY' in event ? event.deltaY :
-	    // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).
-	    'wheelDeltaY' in event ? -event.wheelDeltaY :
-	    // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).
-	    'wheelDelta' in event ? -event.wheelDelta : 0;
-	  },
-	  deltaZ: null,
-
-	  // Browsers without "deltaMode" is reporting in raw wheel delta where one
-	  // notch on the scroll is always +/- 120, roughly equivalent to pixels.
-	  // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or
-	  // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.
-	  deltaMode: null
-	};
-
-	/**
-	 * @param {object} dispatchConfig Configuration used to dispatch this event.
-	 * @param {string} dispatchMarker Marker identifying the event target.
-	 * @param {object} nativeEvent Native browser event.
-	 * @extends {SyntheticMouseEvent}
-	 */
-	function SyntheticWheelEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
-	  return SyntheticMouseEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
-	}
-
-	SyntheticMouseEvent.augmentClass(SyntheticWheelEvent, WheelEventInterface);
-
-	module.exports = SyntheticWheelEvent;
-
-/***/ },
-/* 171 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var DOMLazyTree = __webpack_require__(85);
-	var DOMProperty = __webpack_require__(36);
-	var React = __webpack_require__(2);
-	var ReactBrowserEventEmitter = __webpack_require__(109);
-	var ReactCurrentOwner = __webpack_require__(10);
-	var ReactDOMComponentTree = __webpack_require__(34);
-	var ReactDOMContainerInfo = __webpack_require__(172);
-	var ReactDOMFeatureFlags = __webpack_require__(173);
-	var ReactFeatureFlags = __webpack_require__(62);
-	var ReactInstanceMap = __webpack_require__(120);
-	var ReactInstrumentation = __webpack_require__(66);
-	var ReactMarkupChecksum = __webpack_require__(174);
-	var ReactReconciler = __webpack_require__(63);
-	var ReactUpdateQueue = __webpack_require__(140);
-	var ReactUpdates = __webpack_require__(60);
-
-	var emptyObject = __webpack_require__(127);
-	var instantiateReactComponent = __webpack_require__(122);
-	var invariant = __webpack_require__(37);
-	var setInnerHTML = __webpack_require__(87);
-	var shouldUpdateReactComponent = __webpack_require__(129);
-	var warning = __webpack_require__(47);
-
-	var ATTR_NAME = DOMProperty.ID_ATTRIBUTE_NAME;
-	var ROOT_ATTR_NAME = DOMProperty.ROOT_ATTRIBUTE_NAME;
-
-	var ELEMENT_NODE_TYPE = 1;
-	var DOC_NODE_TYPE = 9;
-	var DOCUMENT_FRAGMENT_NODE_TYPE = 11;
-
-	var instancesByReactRootID = {};
-
-	/**
-	 * Finds the index of the first character
-	 * that's not common between the two given strings.
-	 *
-	 * @return {number} the index of the character where the strings diverge
-	 */
-	function firstDifferenceIndex(string1, string2) {
-	  var minLen = Math.min(string1.length, string2.length);
-	  for (var i = 0; i < minLen; i++) {
-	    if (string1.charAt(i) !== string2.charAt(i)) {
-	      return i;
-	    }
-	  }
-	  return string1.length === string2.length ? -1 : minLen;
-	}
-
-	/**
-	 * @param {DOMElement|DOMDocument} container DOM element that may contain
-	 * a React component
-	 * @return {?*} DOM element that may have the reactRoot ID, or null.
-	 */
-	function getReactRootElementInContainer(container) {
-	  if (!container) {
-	    return null;
-	  }
-
-	  if (container.nodeType === DOC_NODE_TYPE) {
-	    return container.documentElement;
-	  } else {
-	    return container.firstChild;
-	  }
-	}
-
-	function internalGetID(node) {
-	  // If node is something like a window, document, or text node, none of
-	  // which support attributes or a .getAttribute method, gracefully return
-	  // the empty string, as if the attribute were missing.
-	  return node.getAttribute && node.getAttribute(ATTR_NAME) || '';
-	}
-
-	/**
-	 * Mounts this component and inserts it into the DOM.
-	 *
-	 * @param {ReactComponent} componentInstance The instance to mount.
-	 * @param {DOMElement} container DOM element to mount into.
-	 * @param {ReactReconcileTransaction} transaction
-	 * @param {boolean} shouldReuseMarkup If true, do not insert markup
-	 */
-	function mountComponentIntoNode(wrapperInstance, container, transaction, shouldReuseMarkup, context) {
-	  var markerName;
-	  if (ReactFeatureFlags.logTopLevelRenders) {
-	    var wrappedElement = wrapperInstance._currentElement.props.child;
-	    var type = wrappedElement.type;
-	    markerName = 'React mount: ' + (typeof type === 'string' ? type : type.displayName || type.name);
-	    console.time(markerName);
-	  }
-
-	  var markup = ReactReconciler.mountComponent(wrapperInstance, transaction, null, ReactDOMContainerInfo(wrapperInstance, container), context, 0 /* parentDebugID */
-	  );
-
-	  if (markerName) {
-	    console.timeEnd(markerName);
-	  }
-
-	  wrapperInstance._renderedComponent._topLevelWrapper = wrapperInstance;
-	  ReactMount._mountImageIntoNode(markup, container, wrapperInstance, shouldReuseMarkup, transaction);
-	}
-
-	/**
-	 * Batched mount.
-	 *
-	 * @param {ReactComponent} componentInstance The instance to mount.
-	 * @param {DOMElement} container DOM element to mount into.
-	 * @param {boolean} shouldReuseMarkup If true, do not insert markup
-	 */
-	function batchedMountComponentIntoNode(componentInstance, container, shouldReuseMarkup, context) {
-	  var transaction = ReactUpdates.ReactReconcileTransaction.getPooled(
-	  /* useCreateElement */
-	  !shouldReuseMarkup && ReactDOMFeatureFlags.useCreateElement);
-	  transaction.perform(mountComponentIntoNode, null, componentInstance, container, transaction, shouldReuseMarkup, context);
-	  ReactUpdates.ReactReconcileTransaction.release(transaction);
-	}
-
-	/**
-	 * Unmounts a component and removes it from the DOM.
-	 *
-	 * @param {ReactComponent} instance React component instance.
-	 * @param {DOMElement} container DOM element to unmount from.
-	 * @final
-	 * @internal
-	 * @see {ReactMount.unmountComponentAtNode}
-	 */
-	function unmountComponentFromNode(instance, container, safely) {
-	  if (process.env.NODE_ENV !== 'production') {
-	    ReactInstrumentation.debugTool.onBeginFlush();
-	  }
-	  ReactReconciler.unmountComponent(instance, safely);
-	  if (process.env.NODE_ENV !== 'production') {
-	    ReactInstrumentation.debugTool.onEndFlush();
-	  }
-
-	  if (container.nodeType === DOC_NODE_TYPE) {
-	    container = container.documentElement;
-	  }
-
-	  // http://jsperf.com/emptying-a-node
-	  while (container.lastChild) {
-	    container.removeChild(container.lastChild);
-	  }
-	}
-
-	/**
-	 * True if the supplied DOM node has a direct React-rendered child that is
-	 * not a React root element. Useful for warning in `render`,
-	 * `unmountComponentAtNode`, etc.
-	 *
-	 * @param {?DOMElement} node The candidate DOM node.
-	 * @return {boolean} True if the DOM element contains a direct child that was
-	 * rendered by React but is not a root element.
-	 * @internal
-	 */
-	function hasNonRootReactChild(container) {
-	  var rootEl = getReactRootElementInContainer(container);
-	  if (rootEl) {
-	    var inst = ReactDOMComponentTree.getInstanceFromNode(rootEl);
-	    return !!(inst && inst._hostParent);
-	  }
-	}
-
-	/**
-	 * True if the supplied DOM node is a React DOM element and
-	 * it has been rendered by another copy of React.
-	 *
-	 * @param {?DOMElement} node The candidate DOM node.
-	 * @return {boolean} True if the DOM has been rendered by another copy of React
-	 * @internal
-	 */
-	function nodeIsRenderedByOtherInstance(container) {
-	  var rootEl = getReactRootElementInContainer(container);
-	  return !!(rootEl && isReactNode(rootEl) && !ReactDOMComponentTree.getInstanceFromNode(rootEl));
-	}
-
-	/**
-	 * True if the supplied DOM node is a valid node element.
-	 *
-	 * @param {?DOMElement} node The candidate DOM node.
-	 * @return {boolean} True if the DOM is a valid DOM node.
-	 * @internal
-	 */
-	function isValidContainer(node) {
-	  return !!(node && (node.nodeType === ELEMENT_NODE_TYPE || node.nodeType === DOC_NODE_TYPE || node.nodeType === DOCUMENT_FRAGMENT_NODE_TYPE));
-	}
-
-	/**
-	 * True if the supplied DOM node is a valid React node element.
-	 *
-	 * @param {?DOMElement} node The candidate DOM node.
-	 * @return {boolean} True if the DOM is a valid React DOM node.
-	 * @internal
-	 */
-	function isReactNode(node) {
-	  return isValidContainer(node) && (node.hasAttribute(ROOT_ATTR_NAME) || node.hasAttribute(ATTR_NAME));
-	}
-
-	function getHostRootInstanceInContainer(container) {
-	  var rootEl = getReactRootElementInContainer(container);
-	  var prevHostInstance = rootEl && ReactDOMComponentTree.getInstanceFromNode(rootEl);
-	  return prevHostInstance && !prevHostInstance._hostParent ? prevHostInstance : null;
-	}
-
-	function getTopLevelWrapperInContainer(container) {
-	  var root = getHostRootInstanceInContainer(container);
-	  return root ? root._hostContainerInfo._topLevelWrapper : null;
-	}
-
-	/**
-	 * Temporary (?) hack so that we can store all top-level pending updates on
-	 * composites instead of having to worry about different types of components
-	 * here.
-	 */
-	var topLevelRootCounter = 1;
-	var TopLevelWrapper = function () {
-	  this.rootID = topLevelRootCounter++;
-	};
-	TopLevelWrapper.prototype.isReactComponent = {};
-	if (process.env.NODE_ENV !== 'production') {
-	  TopLevelWrapper.displayName = 'TopLevelWrapper';
-	}
-	TopLevelWrapper.prototype.render = function () {
-	  return this.props.child;
-	};
-	TopLevelWrapper.isReactTopLevelWrapper = true;
-
-	/**
-	 * Mounting is the process of initializing a React component by creating its
-	 * representative DOM elements and inserting them into a supplied `container`.
-	 * Any prior content inside `container` is destroyed in the process.
-	 *
-	 *   ReactMount.render(
-	 *     component,
-	 *     document.getElementById('container')
-	 *   );
-	 *
-	 *   <div id="container">                   <-- Supplied `container`.
-	 *     <div data-reactid=".3">              <-- Rendered reactRoot of React
-	 *       // ...                                 component.
-	 *     </div>
-	 *   </div>
-	 *
-	 * Inside of `container`, the first element rendered is the "reactRoot".
-	 */
-	var ReactMount = {
-
-	  TopLevelWrapper: TopLevelWrapper,
-
-	  /**
-	   * Used by devtools. The keys are not important.
-	   */
-	  _instancesByReactRootID: instancesByReactRootID,
-
-	  /**
-	   * 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();
-	  },
-
-	  /**
-	   * Take a component that's already mounted into the DOM and replace its props
-	   * @param {ReactComponent} prevComponent component instance already in the DOM
-	   * @param {ReactElement} nextElement component instance to render
-	   * @param {DOMElement} container container to render into
-	   * @param {?function} callback function triggered on completion
-	   */
-	  _updateRootComponent: function (prevComponent, nextElement, nextContext, container, callback) {
-	    ReactMount.scrollMonitor(container, function () {
-	      ReactUpdateQueue.enqueueElementInternal(prevComponent, nextElement, nextContext);
-	      if (callback) {
-	        ReactUpdateQueue.enqueueCallbackInternal(prevComponent, callback);
-	      }
-	    });
-
-	    return prevComponent;
-	  },
-
-	  /**
-	   * Render a new component into the DOM. Hooked by hooks!
-	   *
-	   * @param {ReactElement} nextElement element to render
-	   * @param {DOMElement} container container to render into
-	   * @param {boolean} shouldReuseMarkup if we should skip the markup insertion
-	   * @return {ReactComponent} nextComponent
-	   */
-	  _renderNewRootComponent: function (nextElement, container, shouldReuseMarkup, context) {
-	    // Various parts of our code (such as ReactCompositeComponent's
-	    // _renderValidatedComponent) assume that calls to render aren't nested;
-	    // verify that that's the case.
-	    process.env.NODE_ENV !== 'production' ? warning(ReactCurrentOwner.current == null, '_renderNewRootComponent(): Render methods should be a pure function ' + 'of props and state; triggering nested component updates from ' + 'render is not allowed. If necessary, trigger nested updates in ' + 'componentDidUpdate. Check the render method of %s.', ReactCurrentOwner.current && ReactCurrentOwner.current.getName() || 'ReactCompositeComponent') : void 0;
-
-	    !isValidContainer(container) ? process.env.NODE_ENV !== 'production' ? invariant(false, '_registerComponent(...): Target container is not a DOM element.') : _prodInvariant('37') : void 0;
-
-	    ReactBrowserEventEmitter.ensureScrollValueMonitoring();
-	    var componentInstance = instantiateReactComponent(nextElement, false);
-
-	    // The initial render is synchronous but any updates that happen during
-	    // rendering, in componentWillMount or componentDidMount, will be batched
-	    // according to the current batching strategy.
-
-	    ReactUpdates.batchedUpdates(batchedMountComponentIntoNode, componentInstance, container, shouldReuseMarkup, context);
-
-	    var wrapperID = componentInstance._instance.rootID;
-	    instancesByReactRootID[wrapperID] = componentInstance;
-
-	    return componentInstance;
-	  },
-
-	  /**
-	   * 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} parentComponent The conceptual parent of this render tree.
-	   * @param {ReactElement} nextElement Component element to render.
-	   * @param {DOMElement} container DOM element to render into.
-	   * @param {?function} callback function triggered on completion
-	   * @return {ReactComponent} Component instance rendered in `container`.
-	   */
-	  renderSubtreeIntoContainer: function (parentComponent, nextElement, container, callback) {
-	    !(parentComponent != null && ReactInstanceMap.has(parentComponent)) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'parentComponent must be a valid React Component') : _prodInvariant('38') : void 0;
-	    return ReactMount._renderSubtreeIntoContainer(parentComponent, nextElement, container, callback);
-	  },
-
-	  _renderSubtreeIntoContainer: function (parentComponent, nextElement, container, callback) {
-	    ReactUpdateQueue.validateCallback(callback, 'ReactDOM.render');
-	    !React.isValidElement(nextElement) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactDOM.render(): Invalid component element.%s', typeof nextElement === 'string' ? ' Instead of passing a string like \'div\', pass ' + 'React.createElement(\'div\') or <div />.' : typeof nextElement === 'function' ? ' Instead of passing a class like Foo, pass ' + 'React.createElement(Foo) or <Foo />.' :
-	    // Check if it quacks like an element
-	    nextElement != null && nextElement.props !== undefined ? ' This may be caused by unintentionally loading two independent ' + 'copies of React.' : '') : _prodInvariant('39', typeof nextElement === 'string' ? ' Instead of passing a string like \'div\', pass ' + 'React.createElement(\'div\') or <div />.' : typeof nextElement === 'function' ? ' Instead of passing a class like Foo, pass ' + 'React.createElement(Foo) or <Foo />.' : nextElement != null && nextElement.props !== undefined ? ' This may be caused by unintentionally loading two independent ' + 'copies of React.' : '') : void 0;
-
-	    process.env.NODE_ENV !== 'production' ? warning(!container || !container.tagName || container.tagName.toUpperCase() !== 'BODY', 'render(): Rendering components directly into document.body is ' + 'discouraged, since its children are often manipulated by third-party ' + 'scripts and browser extensions. This may lead to subtle ' + 'reconciliation issues. Try rendering into a container element created ' + 'for your app.') : void 0;
-
-	    var nextWrappedElement = React.createElement(TopLevelWrapper, { child: nextElement });
-
-	    var nextContext;
-	    if (parentComponent) {
-	      var parentInst = ReactInstanceMap.get(parentComponent);
-	      nextContext = parentInst._processChildContext(parentInst._context);
-	    } else {
-	      nextContext = emptyObject;
-	    }
-
-	    var prevComponent = getTopLevelWrapperInContainer(container);
-
-	    if (prevComponent) {
-	      var prevWrappedElement = prevComponent._currentElement;
-	      var prevElement = prevWrappedElement.props.child;
-	      if (shouldUpdateReactComponent(prevElement, nextElement)) {
-	        var publicInst = prevComponent._renderedComponent.getPublicInstance();
-	        var updatedCallback = callback && function () {
-	          callback.call(publicInst);
-	        };
-	        ReactMount._updateRootComponent(prevComponent, nextWrappedElement, nextContext, container, updatedCallback);
-	        return publicInst;
-	      } else {
-	        ReactMount.unmountComponentAtNode(container);
-	      }
-	    }
-
-	    var reactRootElement = getReactRootElementInContainer(container);
-	    var containerHasReactMarkup = reactRootElement && !!internalGetID(reactRootElement);
-	    var containerHasNonRootReactChild = hasNonRootReactChild(container);
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      process.env.NODE_ENV !== 'production' ? warning(!containerHasNonRootReactChild, 'render(...): Replacing React-rendered children with a new root ' + 'component. If you intended to update the children of this node, ' + 'you should instead have the existing children update their state ' + 'and render the new components instead of calling ReactDOM.render.') : void 0;
-
-	      if (!containerHasReactMarkup || reactRootElement.nextSibling) {
-	        var rootElementSibling = reactRootElement;
-	        while (rootElementSibling) {
-	          if (internalGetID(rootElementSibling)) {
-	            process.env.NODE_ENV !== 'production' ? warning(false, 'render(): Target node has markup rendered by React, but there ' + 'are unrelated nodes as well. This is most commonly caused by ' + 'white-space inserted around server-rendered markup.') : void 0;
-	            break;
-	          }
-	          rootElementSibling = rootElementSibling.nextSibling;
-	        }
-	      }
-	    }
-
-	    var shouldReuseMarkup = containerHasReactMarkup && !prevComponent && !containerHasNonRootReactChild;
-	    var component = ReactMount._renderNewRootComponent(nextWrappedElement, container, shouldReuseMarkup, nextContext)._renderedComponent.getPublicInstance();
-	    if (callback) {
-	      callback.call(component);
-	    }
-	    return component;
-	  },
-
-	  /**
-	   * Renders a React component into the DOM in the supplied `container`.
-	   * See https://facebook.github.io/react/docs/top-level-api.html#reactdom.render
-	   *
-	   * 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 {ReactElement} nextElement Component element to render.
-	   * @param {DOMElement} container DOM element to render into.
-	   * @param {?function} callback function triggered on completion
-	   * @return {ReactComponent} Component instance rendered in `container`.
-	   */
-	  render: function (nextElement, container, callback) {
-	    return ReactMount._renderSubtreeIntoContainer(null, nextElement, container, callback);
-	  },
-
-	  /**
-	   * Unmounts and destroys the React component rendered in the `container`.
-	   * See https://facebook.github.io/react/docs/top-level-api.html#reactdom.unmountcomponentatnode
-	   *
-	   * @param {DOMElement} container DOM element containing a React component.
-	   * @return {boolean} True if a component was found in and unmounted from
-	   *                   `container`
-	   */
-	  unmountComponentAtNode: function (container) {
-	    // Various parts of our code (such as ReactCompositeComponent's
-	    // _renderValidatedComponent) assume that calls to render aren't nested;
-	    // verify that that's the case. (Strictly speaking, unmounting won't cause a
-	    // render but we still don't expect to be in a render call here.)
-	    process.env.NODE_ENV !== 'production' ? warning(ReactCurrentOwner.current == null, 'unmountComponentAtNode(): Render methods should be a pure function ' + 'of props and state; triggering nested component updates from render ' + 'is not allowed. If necessary, trigger nested updates in ' + 'componentDidUpdate. Check the render method of %s.', ReactCurrentOwner.current && ReactCurrentOwner.current.getName() || 'ReactCompositeComponent') : void 0;
-
-	    !isValidContainer(container) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'unmountComponentAtNode(...): Target container is not a DOM element.') : _prodInvariant('40') : void 0;
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      process.env.NODE_ENV !== 'production' ? warning(!nodeIsRenderedByOtherInstance(container), 'unmountComponentAtNode(): The node you\'re attempting to unmount ' + 'was rendered by another copy of React.') : void 0;
-	    }
-
-	    var prevComponent = getTopLevelWrapperInContainer(container);
-	    if (!prevComponent) {
-	      // Check if the node being unmounted was rendered by React, but isn't a
-	      // root node.
-	      var containerHasNonRootReactChild = hasNonRootReactChild(container);
-
-	      // Check if the container itself is a React root node.
-	      var isContainerReactRoot = container.nodeType === 1 && container.hasAttribute(ROOT_ATTR_NAME);
-
-	      if (process.env.NODE_ENV !== 'production') {
-	        process.env.NODE_ENV !== 'production' ? warning(!containerHasNonRootReactChild, 'unmountComponentAtNode(): The node you\'re attempting to unmount ' + 'was rendered by React and is not a top-level container. %s', isContainerReactRoot ? 'You may have accidentally passed in a React root node instead ' + 'of its container.' : 'Instead, have the parent component update its state and ' + 'rerender in order to remove this component.') : void 0;
-	      }
-
-	      return false;
-	    }
-	    delete instancesByReactRootID[prevComponent._instance.rootID];
-	    ReactUpdates.batchedUpdates(unmountComponentFromNode, prevComponent, container, false);
-	    return true;
-	  },
-
-	  _mountImageIntoNode: function (markup, container, instance, shouldReuseMarkup, transaction) {
-	    !isValidContainer(container) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'mountComponentIntoNode(...): Target container is not valid.') : _prodInvariant('41') : void 0;
-
-	    if (shouldReuseMarkup) {
-	      var rootElement = getReactRootElementInContainer(container);
-	      if (ReactMarkupChecksum.canReuseMarkup(markup, rootElement)) {
-	        ReactDOMComponentTree.precacheNode(instance, rootElement);
-	        return;
-	      } else {
-	        var checksum = rootElement.getAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);
-	        rootElement.removeAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);
-
-	        var rootMarkup = rootElement.outerHTML;
-	        rootElement.setAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME, checksum);
-
-	        var normalizedMarkup = markup;
-	        if (process.env.NODE_ENV !== 'production') {
-	          // because rootMarkup is retrieved from the DOM, various normalizations
-	          // will have occurred which will not be present in `markup`. Here,
-	          // insert markup into a <div> or <iframe> depending on the container
-	          // type to perform the same normalizations before comparing.
-	          var normalizer;
-	          if (container.nodeType === ELEMENT_NODE_TYPE) {
-	            normalizer = document.createElement('div');
-	            normalizer.innerHTML = markup;
-	            normalizedMarkup = normalizer.innerHTML;
-	          } else {
-	            normalizer = document.createElement('iframe');
-	            document.body.appendChild(normalizer);
-	            normalizer.contentDocument.write(markup);
-	            normalizedMarkup = normalizer.contentDocument.documentElement.outerHTML;
-	            document.body.removeChild(normalizer);
-	          }
-	        }
-
-	        var diffIndex = firstDifferenceIndex(normalizedMarkup, rootMarkup);
-	        var difference = ' (client) ' + normalizedMarkup.substring(diffIndex - 20, diffIndex + 20) + '\n (server) ' + rootMarkup.substring(diffIndex - 20, diffIndex + 20);
-
-	        !(container.nodeType !== DOC_NODE_TYPE) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'You\'re trying to render a component to the document using server rendering but the checksum was invalid. This usually means you rendered a different component type or props on the client from the one on the server, or your render() methods are impure. React cannot handle this case due to cross-browser quirks by rendering at the document root. You should look for environment dependent code in your components and ensure the props are the same client and server side:\n%s', difference) : _prodInvariant('42', difference) : void 0;
-
-	        if (process.env.NODE_ENV !== 'production') {
-	          process.env.NODE_ENV !== 'production' ? warning(false, 'React attempted to reuse markup in a container but the ' + 'checksum was invalid. This generally means that you are ' + 'using server rendering and the markup generated on the ' + 'server was not what the client was expecting. React injected ' + 'new markup to compensate which works but you have lost many ' + 'of the benefits of server rendering. Instead, figure out ' + 'why the markup being generated is different on the client ' + 'or server:\n%s', difference) : void 0;
-	        }
-	      }
-	    }
-
-	    !(container.nodeType !== DOC_NODE_TYPE) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'You\'re trying to render a component to the document but you didn\'t use server rendering. We can\'t do this without using server rendering due to cross-browser quirks. See ReactDOMServer.renderToString() for server rendering.') : _prodInvariant('43') : void 0;
-
-	    if (transaction.useCreateElement) {
-	      while (container.lastChild) {
-	        container.removeChild(container.lastChild);
-	      }
-	      DOMLazyTree.insertTreeBefore(container, markup, null);
-	    } else {
-	      setInnerHTML(container, markup);
-	      ReactDOMComponentTree.precacheNode(instance, container.firstChild);
-	    }
-
-	    if (process.env.NODE_ENV !== 'production') {
-	      var hostNode = ReactDOMComponentTree.getInstanceFromNode(container.firstChild);
-	      if (hostNode._debugID !== 0) {
-	        ReactInstrumentation.debugTool.onHostOperation({
-	          instanceID: hostNode._debugID,
-	          type: 'mount',
-	          payload: markup.toString()
-	        });
-	      }
-	    }
-	  }
-	};
-
-	module.exports = ReactMount;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 172 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var validateDOMNesting = __webpack_require__(141);
-
-	var DOC_NODE_TYPE = 9;
-
-	function ReactDOMContainerInfo(topLevelWrapper, node) {
-	  var info = {
-	    _topLevelWrapper: topLevelWrapper,
-	    _idCounter: 1,
-	    _ownerDocument: node ? node.nodeType === DOC_NODE_TYPE ? node : node.ownerDocument : null,
-	    _node: node,
-	    _tag: node ? node.nodeName.toLowerCase() : null,
-	    _namespaceURI: node ? node.namespaceURI : null
-	  };
-	  if (process.env.NODE_ENV !== 'production') {
-	    info._ancestorInfo = node ? validateDOMNesting.updatedAncestorInfo(null, info._tag, null) : null;
-	  }
-	  return info;
-	}
-
-	module.exports = ReactDOMContainerInfo;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 173 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ReactDOMFeatureFlags = {
-	  useCreateElement: true,
-	  useFiber: false
-	};
-
-	module.exports = ReactDOMFeatureFlags;
-
-/***/ },
-/* 174 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var adler32 = __webpack_require__(175);
-
-	var TAG_END = /\/?>/;
-	var COMMENT_START = /^<\!\-\-/;
-
-	var ReactMarkupChecksum = {
-	  CHECKSUM_ATTR_NAME: 'data-react-checksum',
-
-	  /**
-	   * @param {string} markup Markup string
-	   * @return {string} Markup string with checksum attribute attached
-	   */
-	  addChecksumToMarkup: function (markup) {
-	    var checksum = adler32(markup);
-
-	    // Add checksum (handle both parent tags, comments and self-closing tags)
-	    if (COMMENT_START.test(markup)) {
-	      return markup;
-	    } else {
-	      return markup.replace(TAG_END, ' ' + ReactMarkupChecksum.CHECKSUM_ATTR_NAME + '="' + checksum + '"$&');
-	    }
-	  },
-
-	  /**
-	   * @param {string} markup to use
-	   * @param {DOMElement} element root React element
-	   * @returns {boolean} whether or not the markup is the same
-	   */
-	  canReuseMarkup: function (markup, element) {
-	    var existingChecksum = element.getAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);
-	    existingChecksum = existingChecksum && parseInt(existingChecksum, 10);
-	    var markupChecksum = adler32(markup);
-	    return markupChecksum === existingChecksum;
-	  }
-	};
-
-	module.exports = ReactMarkupChecksum;
-
-/***/ },
-/* 175 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 * 
-	 */
-
-	'use strict';
-
-	var MOD = 65521;
-
-	// adler32 is not cryptographically strong, and is only used to sanity check that
-	// markup generated on the server matches the markup generated on the client.
-	// This implementation (a modified version of the SheetJS version) has been optimized
-	// for our use case, at the expense of conforming to the adler32 specification
-	// for non-ascii inputs.
-	function adler32(data) {
-	  var a = 1;
-	  var b = 0;
-	  var i = 0;
-	  var l = data.length;
-	  var m = l & ~0x3;
-	  while (i < m) {
-	    var n = Math.min(i + 4096, m);
-	    for (; i < n; i += 4) {
-	      b += (a += data.charCodeAt(i)) + (a += data.charCodeAt(i + 1)) + (a += data.charCodeAt(i + 2)) + (a += data.charCodeAt(i + 3));
-	    }
-	    a %= MOD;
-	    b %= MOD;
-	  }
-	  for (; i < l; i++) {
-	    b += a += data.charCodeAt(i);
-	  }
-	  a %= MOD;
-	  b %= MOD;
-	  return a | b << 16;
-	}
-
-	module.exports = adler32;
-
-/***/ },
-/* 176 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	module.exports = '15.4.1';
-
-/***/ },
-/* 177 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var _prodInvariant = __webpack_require__(35);
-
-	var ReactCurrentOwner = __webpack_require__(10);
-	var ReactDOMComponentTree = __webpack_require__(34);
-	var ReactInstanceMap = __webpack_require__(120);
-
-	var getHostComponentFromComposite = __webpack_require__(178);
-	var invariant = __webpack_require__(37);
-	var warning = __webpack_require__(47);
-
-	/**
-	 * Returns the DOM node rendered by this element.
-	 *
-	 * See https://facebook.github.io/react/docs/top-level-api.html#reactdom.finddomnode
-	 *
-	 * @param {ReactComponent|DOMElement} componentOrElement
-	 * @return {?DOMElement} The root node of this element.
-	 */
-	function findDOMNode(componentOrElement) {
-	  if (process.env.NODE_ENV !== 'production') {
-	    var owner = ReactCurrentOwner.current;
-	    if (owner !== null) {
-	      process.env.NODE_ENV !== 'production' ? warning(owner._warnedAboutRefsInRender, '%s is accessing findDOMNode inside its render(). ' + 'render() should be a pure function of props and state. It should ' + 'never access something that requires stale data from the previous ' + 'render, such as refs. Move this logic to componentDidMount and ' + 'componentDidUpdate instead.', owner.getName() || 'A component') : void 0;
-	      owner._warnedAboutRefsInRender = true;
-	    }
-	  }
-	  if (componentOrElement == null) {
-	    return null;
-	  }
-	  if (componentOrElement.nodeType === 1) {
-	    return componentOrElement;
-	  }
-
-	  var inst = ReactInstanceMap.get(componentOrElement);
-	  if (inst) {
-	    inst = getHostComponentFromComposite(inst);
-	    return inst ? ReactDOMComponentTree.getNodeFromInstance(inst) : null;
-	  }
-
-	  if (typeof componentOrElement.render === 'function') {
-	     true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'findDOMNode was called on an unmounted component.') : _prodInvariant('44') : void 0;
-	  } else {
-	     true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Element appears to be neither ReactComponent nor DOMNode (keys: %s)', Object.keys(componentOrElement)) : _prodInvariant('45', Object.keys(componentOrElement)) : void 0;
-	  }
-	}
-
-	module.exports = findDOMNode;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 178 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ReactNodeTypes = __webpack_require__(124);
-
-	function getHostComponentFromComposite(inst) {
-	  var type;
-
-	  while ((type = inst._renderedNodeType) === ReactNodeTypes.COMPOSITE) {
-	    inst = inst._renderedComponent;
-	  }
-
-	  if (type === ReactNodeTypes.HOST) {
-	    return inst._renderedComponent;
-	  } else if (type === ReactNodeTypes.EMPTY) {
-	    return null;
-	  }
-	}
-
-	module.exports = getHostComponentFromComposite;
-
-/***/ },
-/* 179 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ReactMount = __webpack_require__(171);
-
-	module.exports = ReactMount.renderSubtreeIntoContainer;
-
-/***/ },
-/* 180 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var DOMProperty = __webpack_require__(36);
-	var EventPluginRegistry = __webpack_require__(44);
-	var ReactComponentTreeHook = __webpack_require__(26);
-
-	var warning = __webpack_require__(47);
-
-	if (process.env.NODE_ENV !== 'production') {
-	  var reactProps = {
-	    children: true,
-	    dangerouslySetInnerHTML: true,
-	    key: true,
-	    ref: true,
-
-	    autoFocus: true,
-	    defaultValue: true,
-	    valueLink: true,
-	    defaultChecked: true,
-	    checkedLink: true,
-	    innerHTML: true,
-	    suppressContentEditableWarning: true,
-	    onFocusIn: true,
-	    onFocusOut: true
-	  };
-	  var warnedProperties = {};
-
-	  var validateProperty = function (tagName, name, debugID) {
-	    if (DOMProperty.properties.hasOwnProperty(name) || DOMProperty.isCustomAttribute(name)) {
-	      return true;
-	    }
-	    if (reactProps.hasOwnProperty(name) && reactProps[name] || warnedProperties.hasOwnProperty(name) && warnedProperties[name]) {
-	      return true;
-	    }
-	    if (EventPluginRegistry.registrationNameModules.hasOwnProperty(name)) {
-	      return true;
-	    }
-	    warnedProperties[name] = true;
-	    var lowerCasedName = name.toLowerCase();
-
-	    // data-* attributes should be lowercase; suggest the lowercase version
-	    var standardName = DOMProperty.isCustomAttribute(lowerCasedName) ? lowerCasedName : DOMProperty.getPossibleStandardName.hasOwnProperty(lowerCasedName) ? DOMProperty.getPossibleStandardName[lowerCasedName] : null;
-
-	    var registrationName = EventPluginRegistry.possibleRegistrationNames.hasOwnProperty(lowerCasedName) ? EventPluginRegistry.possibleRegistrationNames[lowerCasedName] : null;
-
-	    if (standardName != null) {
-	      process.env.NODE_ENV !== 'production' ? warning(false, 'Unknown DOM property %s. Did you mean %s?%s', name, standardName, ReactComponentTreeHook.getStackAddendumByID(debugID)) : void 0;
-	      return true;
-	    } else if (registrationName != null) {
-	      process.env.NODE_ENV !== 'production' ? warning(false, 'Unknown event handler property %s. Did you mean `%s`?%s', name, registrationName, ReactComponentTreeHook.getStackAddendumByID(debugID)) : void 0;
-	      return true;
-	    } else {
-	      // We were unable to guess which prop the user intended.
-	      // It is likely that the user was just blindly spreading/forwarding props
-	      // Components should be careful to only render valid props/attributes.
-	      // Warning will be invoked in warnUnknownProperties to allow grouping.
-	      return false;
-	    }
-	  };
-	}
-
-	var warnUnknownProperties = function (debugID, element) {
-	  var unknownProps = [];
-	  for (var key in element.props) {
-	    var isValid = validateProperty(element.type, key, debugID);
-	    if (!isValid) {
-	      unknownProps.push(key);
-	    }
-	  }
-
-	  var unknownPropString = unknownProps.map(function (prop) {
-	    return '`' + prop + '`';
-	  }).join(', ');
-
-	  if (unknownProps.length === 1) {
-	    process.env.NODE_ENV !== 'production' ? warning(false, 'Unknown prop %s on <%s> tag. Remove this prop from the element. ' + 'For details, see https://fb.me/react-unknown-prop%s', unknownPropString, element.type, ReactComponentTreeHook.getStackAddendumByID(debugID)) : void 0;
-	  } else if (unknownProps.length > 1) {
-	    process.env.NODE_ENV !== 'production' ? warning(false, 'Unknown props %s on <%s> tag. Remove these props from the element. ' + 'For details, see https://fb.me/react-unknown-prop%s', unknownPropString, element.type, ReactComponentTreeHook.getStackAddendumByID(debugID)) : void 0;
-	  }
-	};
-
-	function handleElement(debugID, element) {
-	  if (element == null || typeof element.type !== 'string') {
-	    return;
-	  }
-	  if (element.type.indexOf('-') >= 0 || element.props.is) {
-	    return;
-	  }
-	  warnUnknownProperties(debugID, element);
-	}
-
-	var ReactDOMUnknownPropertyHook = {
-	  onBeforeMountComponent: function (debugID, element) {
-	    handleElement(debugID, element);
-	  },
-	  onBeforeUpdateComponent: function (debugID, element) {
-	    handleElement(debugID, element);
-	  }
-	};
-
-	module.exports = ReactDOMUnknownPropertyHook;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 181 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var ReactComponentTreeHook = __webpack_require__(26);
-
-	var warning = __webpack_require__(47);
-
-	var didWarnValueNull = false;
-
-	function handleElement(debugID, element) {
-	  if (element == null) {
-	    return;
-	  }
-	  if (element.type !== 'input' && element.type !== 'textarea' && element.type !== 'select') {
-	    return;
-	  }
-	  if (element.props != null && element.props.value === null && !didWarnValueNull) {
-	    process.env.NODE_ENV !== 'production' ? warning(false, '`value` prop on `%s` should not be null. ' + 'Consider using the empty string to clear the component or `undefined` ' + 'for uncontrolled components.%s', element.type, ReactComponentTreeHook.getStackAddendumByID(debugID)) : void 0;
-
-	    didWarnValueNull = true;
-	  }
-	}
-
-	var ReactDOMNullInputValuePropHook = {
-	  onBeforeMountComponent: function (debugID, element) {
-	    handleElement(debugID, element);
-	  },
-	  onBeforeUpdateComponent: function (debugID, element) {
-	    handleElement(debugID, element);
-	  }
-	};
-
-	module.exports = ReactDOMNullInputValuePropHook;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 182 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(process) {/**
-	 * Copyright 2013-present, Facebook, Inc.
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the BSD-style license found in the
-	 * LICENSE file in the root directory of this source tree. An additional grant
-	 * of patent rights can be found in the PATENTS file in the same directory.
-	 *
-	 */
-
-	'use strict';
-
-	var DOMProperty = __webpack_require__(36);
-	var ReactComponentTreeHook = __webpack_require__(26);
-
-	var warning = __webpack_require__(47);
-
-	var warnedProperties = {};
-	var rARIA = new RegExp('^(aria)-[' + DOMProperty.ATTRIBUTE_NAME_CHAR + ']*$');
-
-	function validateProperty(tagName, name, debugID) {
-	  if (warnedProperties.hasOwnProperty(name) && warnedProperties[name]) {
-	    return true;
-	  }
-
-	  if (rARIA.test(name)) {
-	    var lowerCasedName = name.toLowerCase();
-	    var standardName = DOMProperty.getPossibleStandardName.hasOwnProperty(lowerCasedName) ? DOMProperty.getPossibleStandardName[lowerCasedName] : null;
-
-	    // If this is an aria-* attribute, but is not listed in the known DOM
-	    // DOM properties, then it is an invalid aria-* attribute.
-	    if (standardName == null) {
-	      warnedProperties[name] = true;
-	      return false;
-	    }
-	    // aria-* attributes should be lowercase; suggest the lowercase version.
-	    if (name !== standardName) {
-	      process.env.NODE_ENV !== 'production' ? warning(false, 'Unknown ARIA attribute %s. Did you mean %s?%s', name, standardName, ReactComponentTreeHook.getStackAddendumByID(debugID)) : void 0;
-	      warnedProperties[name] = true;
-	      return true;
-	    }
-	  }
-
-	  return true;
-	}
-
-	function warnInvalidARIAProps(debugID, element) {
-	  var invalidProps = [];
-
-	  for (var key in element.props) {
-	    var isValid = validateProperty(element.type, key, debugID);
-	    if (!isValid) {
-	      invalidProps.push(key);
-	    }
-	  }
-
-	  var unknownPropString = invalidProps.map(function (prop) {
-	    return '`' + prop + '`';
-	  }).join(', ');
-
-	  if (invalidProps.length === 1) {
-	    process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid aria prop %s on <%s> tag. ' + 'For details, see https://fb.me/invalid-aria-prop%s', unknownPropString, element.type, ReactComponentTreeHook.getStackAddendumByID(debugID)) : void 0;
-	  } else if (invalidProps.length > 1) {
-	    process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid aria props %s on <%s> tag. ' + 'For details, see https://fb.me/invalid-aria-prop%s', unknownPropString, element.type, ReactComponentTreeHook.getStackAddendumByID(debugID)) : void 0;
-	  }
-	}
-
-	function handleElement(debugID, element) {
-	  if (element == null || typeof element.type !== 'string') {
-	    return;
-	  }
-	  if (element.type.indexOf('-') >= 0 || element.props.is) {
-	    return;
-	  }
-
-	  warnInvalidARIAProps(debugID, element);
-	}
-
-	var ReactDOMInvalidARIAHook = {
-	  onBeforeMountComponent: function (debugID, element) {
-	    if (process.env.NODE_ENV !== 'production') {
-	      handleElement(debugID, element);
-	    }
-	  },
-	  onBeforeUpdateComponent: function (debugID, element) {
-	    if (process.env.NODE_ENV !== 'production') {
-	      handleElement(debugID, element);
-	    }
-	  }
-	};
-
-	module.exports = ReactDOMInvalidARIAHook;
-	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
-
-/***/ },
-/* 183 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the license found in the
-	 *  LICENSE-examples file in the root directory of this source tree.
-	 */
-
-	// The primary React component to use.
-	module.exports = __webpack_require__(184).GraphiQL;
-
-/***/ },
-/* 184 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.GraphiQL = undefined;
-
-	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
-
-	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
-
-	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-	var _react = __webpack_require__(1);
-
-	var _react2 = _interopRequireDefault(_react);
-
-	var _reactDom = __webpack_require__(32);
-
-	var _reactDom2 = _interopRequireDefault(_reactDom);
-
-	var _graphql = __webpack_require__(185);
-
-	var _ExecuteButton = __webpack_require__(262);
-
-	var _ToolbarButton = __webpack_require__(263);
-
-	var _QueryEditor = __webpack_require__(264);
-
-	var _VariableEditor = __webpack_require__(290);
-
-	var _ResultViewer = __webpack_require__(295);
-
-	var _DocExplorer = __webpack_require__(299);
-
-	var _CodeMirrorSizer = __webpack_require__(301);
-
-	var _CodeMirrorSizer2 = _interopRequireDefault(_CodeMirrorSizer);
-
-	var _getQueryFacts = __webpack_require__(302);
-
-	var _getQueryFacts2 = _interopRequireDefault(_getQueryFacts);
-
-	var _getSelectedOperationName = __webpack_require__(303);
-
-	var _getSelectedOperationName2 = _interopRequireDefault(_getSelectedOperationName);
-
-	var _debounce = __webpack_require__(300);
-
-	var _debounce2 = _interopRequireDefault(_debounce);
-
-	var _find = __webpack_require__(304);
-
-	var _find2 = _interopRequireDefault(_find);
-
-	var _fillLeafs2 = __webpack_require__(305);
-
-	var _elementPosition = __webpack_require__(306);
-
-	var _introspectionQueries = __webpack_require__(307);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /**
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  Copyright (c) 2015, Facebook, Inc.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  All rights reserved.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  This source code is licensed under the license found in the
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  LICENSE-examples file in the root directory of this source tree.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
-
-	/**
-	 * GraphiQL
-	 *
-	 * This React component is responsible for rendering the GraphiQL editor.
-	 *
-	 * Props:
-	 *
-	 *   - fetcher: a function which accepts GraphQL-HTTP parameters and returns
-	 *     a Promise or Observable which resolves to the GraphQL parsed
-	 *     JSON response.
-	 *
-	 *   - schema: a GraphQLSchema instance or `null` if one is not to be used.
-	 *     If `undefined` is provided, GraphiQL will send an introspection query
-	 *     using the fetcher to produce a schema.
-	 *
-	 *   - query: an optional GraphQL string to use as the initial displayed query,
-	 *     if `undefined` is provided, the stored query or defaultQuery will
-	 *     be used.
-	 *
-	 *   - variables: an optional GraphQL string to use as the initial displayed
-	 *     query variables, if `undefined` is provided, the stored variables will
-	 *     be used.
-	 *
-	 *   - operationName: an optional name of which GraphQL operation should be
-	 *     executed.
-	 *
-	 *   - response: an optional JSON string to use as the initial displayed
-	 *     response. If not provided, no response will be initialy shown. You might
-	 *     provide this if illustrating the result of the initial query.
-	 *
-	 *   - storage: an instance of [Storage][] GraphiQL will use to persist state.
-	 *     Only `getItem` and `setItem` are called. Default: window.localStorage
-	 *
-	 *   - defaultQuery: an optional GraphQL string to use when no query is provided
-	 *     and no stored query exists from a previous session. If `undefined` is
-	 *     provided, GraphiQL will use its own default query.
-	 *
-	 *   - onEditQuery: an optional function which will be called when the Query
-	 *     editor changes. The argument to the function will be the query string.
-	 *
-	 *   - onEditVariables: an optional function which will be called when the Query
-	 *     varible editor changes. The argument to the function will be the
-	 *     variables string.
-	 *
-	 *   - onEditOperationName: an optional function which will be called when the
-	 *     operation name to be executed changes.
-	 *
-	 *   - onToggleDocs: an optional function which will be called when the
-	 *     docs will be toggled. The argument to the function will be a boolean
-	 *     whether the docs are now open or closed.
-	 *
-	 *   - getDefaultFieldNames: an optional function used to provide default fields
-	 *     to non-leaf fields which invalidly lack a selection set.
-	 *     Accepts a GraphQLType instance and returns an array of field names.
-	 *     If not provided, a default behavior will be used.
-	 *
-	 * Children:
-	 *
-	 *   - <GraphiQL.Logo> Replace the GraphiQL logo with your own.
-	 *
-	 *   - <GraphiQL.Toolbar> Add a custom toolbar above GraphiQL.
-	 *
-	 *   - <GraphiQL.ToolbarButton> Add a button to the toolbar above GraphiQL.
-	 *
-	 *   - <GraphiQL.Footer> Add a custom footer below GraphiQL Results.
-	 *
-	 *
-	 * [Storage]: https://developer.mozilla.org/en-US/docs/Web/API/Storage
-	 */
-	var GraphiQL = exports.GraphiQL = function (_React$Component) {
-	  _inherits(GraphiQL, _React$Component);
-
-	  function GraphiQL(props) {
-	    _classCallCheck(this, GraphiQL);
-
-	    // Ensure props are correct
-	    var _this = _possibleConstructorReturn(this, (GraphiQL.__proto__ || Object.getPrototypeOf(GraphiQL)).call(this, props));
-
-	    _initialiseProps.call(_this);
-
-	    if (typeof props.fetcher !== 'function') {
-	      throw new TypeError('GraphiQL requires a fetcher function.');
-	    }
-
-	    // Cache the storage instance
-	    _this._storage = props.storage || window.localStorage;
-
-	    // Determine the initial query to display.
-	    var query = props.query !== undefined ? props.query : _this._storageGet('query') !== null ? _this._storageGet('query') : props.defaultQuery !== undefined ? props.defaultQuery : defaultQuery;
-
-	    // Get the initial query facts.
-	    var queryFacts = (0, _getQueryFacts2.default)(props.schema, query);
-
-	    // Determine the initial variables to display.
-	    var variables = props.variables !== undefined ? props.variables : _this._storageGet('variables');
-
-	    // Determine the initial operationName to use.
-	    var operationName = props.operationName !== undefined ? props.operationName : (0, _getSelectedOperationName2.default)(null, _this._storageGet('operationName'), queryFacts && queryFacts.operations);
-
-	    // Initialize state
-	    _this.state = _extends({
-	      schema: props.schema,
-	      query: query,
-	      variables: variables,
-	      operationName: operationName,
-	      response: props.response,
-	      editorFlex: Number(_this._storageGet('editorFlex')) || 1,
-	      variableEditorOpen: Boolean(variables),
-	      variableEditorHeight: Number(_this._storageGet('variableEditorHeight')) || 200,
-	      docExplorerOpen: _this._storageGet('docExplorerOpen') === 'true' || false,
-	      docExplorerWidth: Number(_this._storageGet('docExplorerWidth')) || 350,
-	      isWaitingForResponse: false,
-	      subscription: null
-	    }, queryFacts);
-
-	    // Ensure only the last executed editor query is rendered.
-	    _this._editorQueryID = 0;
-
-	    // Subscribe to the browser window closing, treating it as an unmount.
-	    if ((typeof window === 'undefined' ? 'undefined' : _typeof(window)) === 'object') {
-	      window.addEventListener('beforeunload', function () {
-	        return _this.componentWillUnmount();
-	      });
-	    }
-	    return _this;
-	  }
-
-	  _createClass(GraphiQL, [{
-	    key: 'componentDidMount',
-	    value: function componentDidMount() {
-	      // Ensure a form of a schema exists (including `null`) and
-	      // if not, fetch one using an introspection query.
-	      this._ensureOfSchema();
-
-	      // Utility for keeping CodeMirror correctly sized.
-	      this.codeMirrorSizer = new _CodeMirrorSizer2.default();
-	    }
-	  }, {
-	    key: 'componentWillReceiveProps',
-	    value: function componentWillReceiveProps(nextProps) {
-	      var nextSchema = this.state.schema;
-	      var nextQuery = this.state.query;
-	      var nextVariables = this.state.variables;
-	      var nextOperationName = this.state.operationName;
-	      var nextResponse = this.state.response;
-
-	      if (nextProps.schema !== undefined) {
-	        nextSchema = nextProps.schema;
-	      }
-	      if (nextProps.query !== undefined) {
-	        nextQuery = nextProps.query;
-	      }
-	      if (nextProps.variables !== undefined) {
-	        nextVariables = nextProps.variables;
-	      }
-	      if (nextProps.operationName !== undefined) {
-	        nextOperationName = nextProps.operationName;
-	      }
-	      if (nextProps.response !== undefined) {
-	        nextResponse = nextProps.response;
-	      }
-	      if (nextSchema !== this.state.schema || nextQuery !== this.state.query || nextOperationName !== this.state.operationName) {
-	        this._updateQueryFacts(nextQuery);
-	      }
-
-	      this.setState({
-	        schema: nextSchema,
-	        query: nextQuery,
-	        variables: nextVariables,
-	        operationName: nextOperationName,
-	        response: nextResponse
-	      });
-	    }
-	  }, {
-	    key: 'componentDidUpdate',
-	    value: function componentDidUpdate() {
-	      // If this update caused DOM nodes to have changed sizes, update the
-	      // corresponding CodeMirror instance sizes to match.
-	      this.codeMirrorSizer.updateSizes([this.queryEditorComponent, this.variableEditorComponent, this.resultComponent]);
-	    }
-
-	    // When the component is about to unmount, store any persistable state, such
-	    // that when the component is remounted, it will use the last used values.
-
-	  }, {
-	    key: 'componentWillUnmount',
-	    value: function componentWillUnmount() {
-	      this._storageSet('query', this.state.query);
-	      this._storageSet('variables', this.state.variables || '');
-	      this._storageSet('operationName', this.state.operationName);
-	      this._storageSet('editorFlex', this.state.editorFlex);
-	      this._storageSet('variableEditorHeight', this.state.variableEditorHeight);
-	      this._storageSet('docExplorerWidth', this.state.docExplorerWidth);
-	      this._storageSet('docExplorerOpen', this.state.docExplorerOpen);
-	    }
-	  }, {
-	    key: 'render',
-	    value: function render() {
-	      var _this2 = this;
-
-	      var children = _react2.default.Children.toArray(this.props.children);
-
-	      var logo = (0, _find2.default)(children, function (child) {
-	        return child.type === GraphiQL.Logo;
-	      }) || _react2.default.createElement(GraphiQL.Logo, null);
-
-	      var toolbar = (0, _find2.default)(children, function (child) {
-	        return child.type === GraphiQL.Toolbar;
-	      }) || _react2.default.createElement(GraphiQL.Toolbar, null);
-
-	      var footer = (0, _find2.default)(children, function (child) {
-	        return child.type === GraphiQL.Footer;
-	      });
-
-	      var queryWrapStyle = {
-	        WebkitFlex: this.state.editorFlex,
-	        flex: this.state.editorFlex
-	      };
-
-	      var docWrapStyle = {
-	        display: this.state.docExplorerOpen ? 'block' : 'none',
-	        width: this.state.docExplorerWidth
-	      };
-
-	      var variableOpen = this.state.variableEditorOpen;
-	      var variableStyle = {
-	        height: variableOpen ? this.state.variableEditorHeight : null
-	      };
-
-	      return _react2.default.createElement(
-	        'div',
-	        { className: 'graphiql-container' },
-	        _react2.default.createElement(
-	          'div',
-	          { className: 'editorWrap' },
-	          _react2.default.createElement(
-	            'div',
-	            { className: 'topBarWrap' },
-	            _react2.default.createElement(
-	              'div',
-	              { className: 'topBar' },
-	              logo,
-	              _react2.default.createElement(_ExecuteButton.ExecuteButton, {
-	                isRunning: Boolean(this.state.subscription),
-	                onRun: this.handleRunQuery,
-	                onStop: this.handleStopQuery,
-	                operations: this.state.operations
-	              }),
-	              _react2.default.createElement(GraphiQL.ToolbarButton, {
-	                onClick: this.handlePrettifyQuery,
-	                title: 'Prettify Query',
-	                label: 'Prettify'
-	              }),
-	              toolbar
-	            ),
-	            !this.state.docExplorerOpen && _react2.default.createElement(
-	              'button',
-	              {
-	                className: 'docExplorerShow',
-	                onClick: this.handleToggleDocs },
-	              'Docs'
-	            )
-	          ),
-	          _react2.default.createElement(
-	            'div',
-	            {
-	              ref: function ref(n) {
-	                _this2.editorBarComponent = n;
-	              },
-	              className: 'editorBar',
-	              onMouseDown: this.handleResizeStart },
-	            _react2.default.createElement(
-	              'div',
-	              { className: 'queryWrap', style: queryWrapStyle },
-	              _react2.default.createElement(_QueryEditor.QueryEditor, {
-	                ref: function ref(n) {
-	                  _this2.queryEditorComponent = n;
-	                },
-	                schema: this.state.schema,
-	                value: this.state.query,
-	                onEdit: this.handleEditQuery,
-	                onHintInformationRender: this.handleHintInformationRender,
-	                onRunQuery: this.handleEditorRunQuery
-	              }),
-	              _react2.default.createElement(
-	                'div',
-	                { className: 'variable-editor', style: variableStyle },
-	                _react2.default.createElement(
-	                  'div',
-	                  {
-	                    className: 'variable-editor-title',
-	                    style: { cursor: variableOpen ? 'row-resize' : 'n-resize' },
-	                    onMouseDown: this.handleVariableResizeStart },
-	                  'Query Variables'
-	                ),
-	                _react2.default.createElement(_VariableEditor.VariableEditor, {
-	                  ref: function ref(n) {
-	                    _this2.variableEditorComponent = n;
-	                  },
-	                  value: this.state.variables,
-	                  variableToType: this.state.variableToType,
-	                  onEdit: this.handleEditVariables,
-	                  onHintInformationRender: this.handleHintInformationRender,
-	                  onRunQuery: this.handleEditorRunQuery
-	                })
-	              )
-	            ),
-	            _react2.default.createElement(
-	              'div',
-	              { className: 'resultWrap' },
-	              this.state.isWaitingForResponse && _react2.default.createElement(
-	                'div',
-	                { className: 'spinner-container' },
-	                _react2.default.createElement('div', { className: 'spinner' })
-	              ),
-	              _react2.default.createElement(_ResultViewer.ResultViewer, {
-	                ref: function ref(c) {
-	                  _this2.resultComponent = c;
-	                },
-	                value: this.state.response
-	              }),
-	              footer
-	            )
-	          )
-	        ),
-	        _react2.default.createElement(
-	          'div',
-	          { className: 'docExplorerWrap', style: docWrapStyle },
-	          _react2.default.createElement('div', {
-	            className: 'docExplorerResizer',
-	            onMouseDown: this.handleDocsResizeStart
-	          }),
-	          _react2.default.createElement(
-	            _DocExplorer.DocExplorer,
-	            {
-	              ref: function ref(c) {
-	                _this2.docExplorerComponent = c;
-	              },
-	              schema: this.state.schema },
-	            _react2.default.createElement(
-	              'div',
-	              { className: 'docExplorerHide', onClick: this.handleToggleDocs },
-	              '\u2715'
-	            )
-	          )
-	        )
-	      );
-	    }
-
-	    /**
-	     * Inspect the query, automatically filling in selection sets for non-leaf
-	     * fields which do not yet have them.
-	     *
-	     * @public
-	     */
-
-	  }, {
-	    key: 'autoCompleteLeafs',
-	    value: function autoCompleteLeafs() {
-	      var _this3 = this;
-
-	      var _fillLeafs = (0, _fillLeafs2.fillLeafs)(this.state.schema, this.state.query, this.props.getDefaultFieldNames),
-	          insertions = _fillLeafs.insertions,
-	          result = _fillLeafs.result;
-
-	      if (insertions && insertions.length > 0) {
-	        (function () {
-	          var editor = _this3.queryEditorComponent.getCodeMirror();
-	          editor.operation(function () {
-	            var cursor = editor.getCursor();
-	            var cursorIndex = editor.indexFromPos(cursor);
-	            editor.setValue(result);
-	            var added = 0;
-	            var markers = insertions.map(function (_ref) {
-	              var index = _ref.index,
-	                  string = _ref.string;
-	              return editor.markText(editor.posFromIndex(index + added), editor.posFromIndex(index + (added += string.length)), {
-	                className: 'autoInsertedLeaf',
-	                clearOnEnter: true,
-	                title: 'Automatically added leaf fields'
-	              });
-	            });
-	            setTimeout(function () {
-	              return markers.forEach(function (marker) {
-	                return marker.clear();
-	              });
-	            }, 7000);
-	            var newCursorIndex = cursorIndex;
-	            insertions.forEach(function (_ref2) {
-	              var index = _ref2.index,
-	                  string = _ref2.string;
-
-	              if (index < cursorIndex) {
-	                newCursorIndex += string.length;
-	              }
-	            });
-	            editor.setCursor(editor.posFromIndex(newCursorIndex));
-	          });
-	        })();
-	      }
-
-	      return result;
-	    }
-
-	    // Private methods
-
-	  }, {
-	    key: '_ensureOfSchema',
-	    value: function _ensureOfSchema() {
-	      var _this4 = this;
-
-	      // Only perform introspection if a schema is not provided (undefined)
-	      if (this.state.schema !== undefined) {
-	        return;
-	      }
-
-	      var fetcher = this.props.fetcher;
-
-	      var fetch = observableToPromise(fetcher({ query: _introspectionQueries.introspectionQuery }));
-	      if (!isPromise(fetch)) {
-	        this.setState({
-	          response: 'Fetcher did not return a Promise for introspection.'
-	        });
-	        return;
-	      }
-
-	      fetch.then(function (result) {
-	        if (result.data) {
-	          return result;
-	        }
-
-	        // Try the stock introspection query first, falling back on the
-	        // sans-subscriptions query for services which do not yet support it.
-	        var fetch2 = observableToPromise(fetcher({
-	          query: _introspectionQueries.introspectionQuerySansSubscriptions
-	        }));
-	        if (!isPromise(fetch)) {
-	          throw new Error('Fetcher did not return a Promise for introspection.');
-	        }
-	        return fetch2;
-	      }).then(function (result) {
-	        // If a schema was provided while this fetch was underway, then
-	        // satisfy the race condition by respecting the already
-	        // provided schema.
-	        if (_this4.state.schema !== undefined) {
-	          return;
-	        }
-
-	        if (result && result.data) {
-	          var schema = (0, _graphql.buildClientSchema)(result.data);
-	          var queryFacts = (0, _getQueryFacts2.default)(schema, _this4.state.query);
-	          _this4.setState(_extends({ schema: schema }, queryFacts));
-	        } else {
-	          var responseString = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
-	          _this4.setState({ response: responseString });
-	        }
-	      }).catch(function (error) {
-	        _this4.setState({ response: error && String(error.stack || error) });
-	      });
-	    }
-	  }, {
-	    key: '_storageGet',
-	    value: function _storageGet(name) {
-	      return this._storage && this._storage.getItem('graphiql:' + name);
-	    }
-	  }, {
-	    key: '_storageSet',
-	    value: function _storageSet(name, value) {
-	      if (this._storage) {
-	        this._storage.setItem('graphiql:' + name, value);
-	      }
-	    }
-	  }, {
-	    key: '_fetchQuery',
-	    value: function _fetchQuery(query, variables, operationName, cb) {
-	      var _this5 = this;
-
-	      var fetcher = this.props.fetcher;
-	      var jsonVariables = null;
-
-	      try {
-	        jsonVariables = variables && variables.trim() !== '' ? JSON.parse(variables) : null;
-	      } catch (error) {
-	        throw new Error('Variables are invalid JSON: ' + error.message + '.');
-	      }
-
-	      if ((typeof jsonVariables === 'undefined' ? 'undefined' : _typeof(jsonVariables)) !== 'object') {
-	        throw new Error('Variables are not a JSON object.');
-	      }
-
-	      var fetch = fetcher({
-	        query: query,
-	        variables: jsonVariables,
-	        operationName: operationName
-	      });
-
-	      if (isPromise(fetch)) {
-	        // If fetcher returned a Promise, then call the callback when the promise
-	        // resolves, otherwise handle the error.
-	        fetch.then(cb).catch(function (error) {
-	          _this5.setState({
-	            isWaitingForResponse: false,
-	            response: error && String(error.stack || error)
-	          });
-	        });
-	      } else if (isObservable(fetch)) {
-	        // If the fetcher returned an Observable, then subscribe to it, calling
-	        // the callback on each next value, and handling both errors and the
-	        // completion of the Observable. Returns a Subscription object.
-	        var subscription = fetch.subscribe({
-	          next: cb,
-	          error: function error(_error) {
-	            _this5.setState({
-	              isWaitingForResponse: false,
-	              response: _error && String(_error.stack || _error),
-	              subscription: null
-	            });
-	          },
-	          complete: function complete() {
-	            _this5.setState({
-	              isWaitingForResponse: false,
-	              subscription: null
-	            });
-	          }
-	        });
-
-	        return subscription;
-	      } else {
-	        throw new Error('Fetcher did not return Promise or Observable.');
-	      }
-	    }
-	  }, {
-	    key: '_runQueryAtCursor',
-	    value: function _runQueryAtCursor() {
-	      if (this.state.subscription) {
-	        this.handleStopQuery();
-	        return;
-	      }
-
-	      var operationName = void 0;
-	      var operations = this.state.operations;
-	      if (operations) {
-	        var editor = this.queryEditorComponent.getCodeMirror();
-	        if (editor.hasFocus()) {
-	          var cursor = editor.getCursor();
-	          var cursorIndex = editor.indexFromPos(cursor);
-
-	          // Loop through all operations to see if one contains the cursor.
-	          for (var i = 0; i < operations.length; i++) {
-	            var operation = operations[i];
-	            if (operation.loc.start <= cursorIndex && operation.loc.end >= cursorIndex) {
-	              operationName = operation.name && operation.name.value;
-	              break;
-	            }
-	          }
-	        }
-	      }
-
-	      this.handleRunQuery(operationName);
-	    }
-	  }, {
-	    key: '_didClickDragBar',
-	    value: function _didClickDragBar(event) {
-	      // Only for primary unmodified clicks
-	      if (event.button !== 0 || event.ctrlKey) {
-	        return false;
-	      }
-	      var target = event.target;
-	      // We use codemirror's gutter as the drag bar.
-	      if (target.className.indexOf('CodeMirror-gutter') !== 0) {
-	        return false;
-	      }
-	      // Specifically the result window's drag bar.
-	      var resultWindow = _reactDom2.default.findDOMNode(this.resultComponent);
-	      while (target) {
-	        if (target === resultWindow) {
-	          return true;
-	        }
-	        target = target.parentNode;
-	      }
-	      return false;
-	    }
-	  }]);
-
-	  return GraphiQL;
-	}(_react2.default.Component);
-
-	// Configure the UI by providing this Component as a child of GraphiQL.
-
-
-	GraphiQL.propTypes = {
-	  fetcher: _react.PropTypes.func.isRequired,
-	  schema: _react.PropTypes.instanceOf(_graphql.GraphQLSchema),
-	  query: _react.PropTypes.string,
-	  variables: _react.PropTypes.string,
-	  operationName: _react.PropTypes.string,
-	  response: _react.PropTypes.string,
-	  storage: _react.PropTypes.shape({
-	    getItem: _react.PropTypes.func,
-	    setItem: _react.PropTypes.func
-	  }),
-	  defaultQuery: _react.PropTypes.string,
-	  onEditQuery: _react.PropTypes.func,
-	  onEditVariables: _react.PropTypes.func,
-	  onEditOperationName: _react.PropTypes.func,
-	  onToggleDocs: _react.PropTypes.func,
-	  getDefaultFieldNames: _react.PropTypes.func
-	};
-
-	var _initialiseProps = function _initialiseProps() {
-	  var _this6 = this;
-
-	  this.handleRunQuery = function (selectedOperationName) {
-	    _this6._editorQueryID++;
-	    var queryID = _this6._editorQueryID;
-
-	    // Use the edited query after autoCompleteLeafs() runs or,
-	    // in case autoCompletion fails (the function returns undefined),
-	    // the current query from the editor.
-	    var editedQuery = _this6.autoCompleteLeafs() || _this6.state.query;
-	    var variables = _this6.state.variables;
-	    var operationName = _this6.state.operationName;
-
-	    // If an operation was explicitly provided, different from the current
-	    // operation name, then report that it changed.
-	    if (selectedOperationName && selectedOperationName !== operationName) {
-	      operationName = selectedOperationName;
-	      var onEditOperationName = _this6.props.onEditOperationName;
-	      if (onEditOperationName) {
-	        onEditOperationName(operationName);
-	      }
-	    }
-
-	    try {
-	      _this6.setState({
-	        isWaitingForResponse: true,
-	        response: null,
-	        operationName: operationName
-	      });
-
-	      // _fetchQuery may return a subscription.
-	      var subscription = _this6._fetchQuery(editedQuery, variables, operationName, function (result) {
-	        if (queryID === _this6._editorQueryID) {
-	          _this6.setState({
-	            isWaitingForResponse: false,
-	            response: JSON.stringify(result, null, 2)
-	          });
-	        }
-	      });
-
-	      _this6.setState({ subscription: subscription });
-	    } catch (error) {
-	      _this6.setState({
-	        isWaitingForResponse: false,
-	        response: error.message
-	      });
-	    }
-	  };
-
-	  this.handleStopQuery = function () {
-	    var subscription = _this6.state.subscription;
-	    _this6.setState({
-	      isWaitingForResponse: false,
-	      subscription: null
-	    });
-	    if (subscription) {
-	      subscription.unsubscribe();
-	    }
-	  };
-
-	  this.handlePrettifyQuery = function () {
-	    var query = (0, _graphql.print)((0, _graphql.parse)(_this6.state.query));
-	    var editor = _this6.queryEditorComponent.getCodeMirror();
-	    editor.setValue(query);
-	  };
-
-	  this.handleEditQuery = function (value) {
-	    if (_this6.state.schema) {
-	      _this6._updateQueryFacts(value);
-	    }
-	    _this6.setState({ query: value });
-	    if (_this6.props.onEditQuery) {
-	      return _this6.props.onEditQuery(value);
-	    }
-	  };
-
-	  this._updateQueryFacts = (0, _debounce2.default)(150, function (query) {
-	    var queryFacts = (0, _getQueryFacts2.default)(_this6.state.schema, query);
-	    if (queryFacts) {
-	      // Update operation name should any query names change.
-	      var operationName = (0, _getSelectedOperationName2.default)(_this6.state.operations, _this6.state.operationName, queryFacts.operations);
-
-	      // Report changing of operationName if it changed.
-	      var onEditOperationName = _this6.props.onEditOperationName;
-	      if (onEditOperationName && operationName !== _this6.state.operationName) {
-	        onEditOperationName(operationName);
-	      }
-
-	      _this6.setState(_extends({
-	        operationName: operationName
-	      }, queryFacts));
-	    }
-	  });
-
-	  this.handleEditVariables = function (value) {
-	    _this6.setState({ variables: value });
-	    if (_this6.props.onEditVariables) {
-	      _this6.props.onEditVariables(value);
-	    }
-	  };
-
-	  this.handleHintInformationRender = function (elem) {
-	    elem.addEventListener('click', _this6._onClickHintInformation);
-
-	    var _onRemoveFn = void 0;
-	    elem.addEventListener('DOMNodeRemoved', _onRemoveFn = function onRemoveFn() {
-	      elem.removeEventListener('DOMNodeRemoved', _onRemoveFn);
-	      elem.removeEventListener('click', _this6._onClickHintInformation);
-	    });
-	  };
-
-	  this.handleEditorRunQuery = function () {
-	    _this6._runQueryAtCursor();
-	  };
-
-	  this._onClickHintInformation = function (event) {
-	    if (event.target.className === 'typeName') {
-	      var typeName = event.target.innerHTML;
-	      var schema = _this6.state.schema;
-	      if (schema) {
-	        (function () {
-	          var type = schema.getType(typeName);
-	          if (type) {
-	            _this6.setState({ docExplorerOpen: true }, function () {
-	              _this6.docExplorerComponent.showDoc(type);
-	            });
-	          }
-	        })();
-	      }
-	    }
-	  };
-
-	  this.handleToggleDocs = function () {
-	    if (typeof _this6.props.onToggleDocs === 'function') {
-	      _this6.props.onToggleDocs(!_this6.state.docExplorerOpen);
-	    }
-	    _this6.setState({ docExplorerOpen: !_this6.state.docExplorerOpen });
-	  };
-
-	  this.handleResizeStart = function (downEvent) {
-	    if (!_this6._didClickDragBar(downEvent)) {
-	      return;
-	    }
-
-	    downEvent.preventDefault();
-
-	    var offset = downEvent.clientX - (0, _elementPosition.getLeft)(downEvent.target);
-
-	    var onMouseMove = function onMouseMove(moveEvent) {
-	      if (moveEvent.buttons === 0) {
-	        return onMouseUp();
-	      }
-
-	      var editorBar = _reactDom2.default.findDOMNode(_this6.editorBarComponent);
-	      var leftSize = moveEvent.clientX - (0, _elementPosition.getLeft)(editorBar) - offset;
-	      var rightSize = editorBar.clientWidth - leftSize;
-	      _this6.setState({ editorFlex: leftSize / rightSize });
-	    };
-
-	    var onMouseUp = function (_onMouseUp) {
-	      function onMouseUp() {
-	        return _onMouseUp.apply(this, arguments);
-	      }
-
-	      onMouseUp.toString = function () {
-	        return _onMouseUp.toString();
-	      };
-
-	      return onMouseUp;
-	    }(function () {
-	      document.removeEventListener('mousemove', onMouseMove);
-	      document.removeEventListener('mouseup', onMouseUp);
-	      onMouseMove = null;
-	      onMouseUp = null;
-	    });
-
-	    document.addEventListener('mousemove', onMouseMove);
-	    document.addEventListener('mouseup', onMouseUp);
-	  };
-
-	  this.handleDocsResizeStart = function (downEvent) {
-	    downEvent.preventDefault();
-
-	    var hadWidth = _this6.state.docExplorerWidth;
-	    var offset = downEvent.clientX - (0, _elementPosition.getLeft)(downEvent.target);
-
-	    var onMouseMove = function onMouseMove(moveEvent) {
-	      if (moveEvent.buttons === 0) {
-	        return onMouseUp();
-	      }
-
-	      var app = _reactDom2.default.findDOMNode(_this6);
-	      var cursorPos = moveEvent.clientX - (0, _elementPosition.getLeft)(app) - offset;
-	      var docsSize = app.clientWidth - cursorPos;
-
-	      if (docsSize < 100) {
-	        _this6.setState({ docExplorerOpen: false });
-	      } else {
-	        _this6.setState({
-	          docExplorerOpen: true,
-	          docExplorerWidth: Math.min(docsSize, 650)
-	        });
-	      }
-	    };
-
-	    var onMouseUp = function (_onMouseUp2) {
-	      function onMouseUp() {
-	        return _onMouseUp2.apply(this, arguments);
-	      }
-
-	      onMouseUp.toString = function () {
-	        return _onMouseUp2.toString();
-	      };
-
-	      return onMouseUp;
-	    }(function () {
-	      if (!_this6.state.docExplorerOpen) {
-	        _this6.setState({ docExplorerWidth: hadWidth });
-	      }
-
-	      document.removeEventListener('mousemove', onMouseMove);
-	      document.removeEventListener('mouseup', onMouseUp);
-	      onMouseMove = null;
-	      onMouseUp = null;
-	    });
-
-	    document.addEventListener('mousemove', onMouseMove);
-	    document.addEventListener('mouseup', onMouseUp);
-	  };
-
-	  this.handleVariableResizeStart = function (downEvent) {
-	    downEvent.preventDefault();
-
-	    var didMove = false;
-	    var wasOpen = _this6.state.variableEditorOpen;
-	    var hadHeight = _this6.state.variableEditorHeight;
-	    var offset = downEvent.clientY - (0, _elementPosition.getTop)(downEvent.target);
-
-	    var onMouseMove = function onMouseMove(moveEvent) {
-	      if (moveEvent.buttons === 0) {
-	        return onMouseUp();
-	      }
-
-	      didMove = true;
-
-	      var editorBar = _reactDom2.default.findDOMNode(_this6.editorBarComponent);
-	      var topSize = moveEvent.clientY - (0, _elementPosition.getTop)(editorBar) - offset;
-	      var bottomSize = editorBar.clientHeight - topSize;
-	      if (bottomSize < 60) {
-	        _this6.setState({
-	          variableEditorOpen: false,
-	          variableEditorHeight: hadHeight
-	        });
-	      } else {
-	        _this6.setState({
-	          variableEditorOpen: true,
-	          variableEditorHeight: bottomSize
-	        });
-	      }
-	    };
-
-	    var onMouseUp = function (_onMouseUp3) {
-	      function onMouseUp() {
-	        return _onMouseUp3.apply(this, arguments);
-	      }
-
-	      onMouseUp.toString = function () {
-	        return _onMouseUp3.toString();
-	      };
-
-	      return onMouseUp;
-	    }(function () {
-	      if (!didMove) {
-	        _this6.setState({ variableEditorOpen: !wasOpen });
-	      }
-
-	      document.removeEventListener('mousemove', onMouseMove);
-	      document.removeEventListener('mouseup', onMouseUp);
-	      onMouseMove = null;
-	      onMouseUp = null;
-	    });
-
-	    document.addEventListener('mousemove', onMouseMove);
-	    document.addEventListener('mouseup', onMouseUp);
-	  };
-	};
-
-	GraphiQL.Logo = function GraphiQLLogo(props) {
-	  return _react2.default.createElement(
-	    'div',
-	    { className: 'title' },
-	    props.children || _react2.default.createElement(
-	      'span',
-	      null,
-	      'Graph',
-	      _react2.default.createElement(
-	        'em',
-	        null,
-	        'i'
-	      ),
-	      'QL'
-	    )
-	  );
-	};
-
-	// Configure the UI by providing this Component as a child of GraphiQL.
-	GraphiQL.Toolbar = function GraphiQLToolbar(props) {
-	  return _react2.default.createElement(
-	    'div',
-	    { className: 'toolbar' },
-	    props.children
-	  );
-	};
-
-	// Add a button to the Toolbar.
-	GraphiQL.ToolbarButton = _ToolbarButton.ToolbarButton;
-
-	// Configure the UI by providing this Component as a child of GraphiQL.
-	GraphiQL.Footer = function GraphiQLFooter(props) {
-	  return _react2.default.createElement(
-	    'div',
-	    { className: 'footer' },
-	    props.children
-	  );
-	};
-
-	var defaultQuery = '# Welcome to GraphiQL\n#\n# GraphiQL is an in-browser IDE for writing, validating, and\n# testing GraphQL queries.\n#\n# Type queries into this side of the screen, and you will\n# see intelligent typeaheads aware of the current GraphQL type schema and\n# live syntax and validation errors highlighted within the text.\n#\n# To bring up the auto-complete at any point, just press Ctrl-Space.\n#\n# Press the run button above, or Cmd-Enter to execute the query, and the result\n# will appear in the pane to the right.\n\n';
-
-	// Duck-type promise detection.
-	function isPromise(value) {
-	  return (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && typeof value.then === 'function';
-	}
-
-	// Duck-type Observable.take(1).toPromise()
-	function observableToPromise(observable) {
-	  if (!isObservable(observable)) {
-	    return observable;
-	  }
-	  return new Promise(function (resolve, reject) {
-	    var subscription = observable.subscribe(function (v) {
-	      resolve(v);
-	      subscription.unsubscribe();
-	    }, reject, function () {
-	      reject(new Error('no value resolved'));
-	    });
-	  });
-	}
-
-	// Duck-type observable detection.
-	function isObservable(value) {
-	  return (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && typeof value.subscribe === 'function';
-	}
-
-/***/ },
-/* 185 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-
-	var _graphql = __webpack_require__(186);
-
-	Object.defineProperty(exports, 'graphql', {
-	  enumerable: true,
-	  get: function get() {
-	    return _graphql.graphql;
-	  }
-	});
-
-	var _type = __webpack_require__(248);
-
-	Object.defineProperty(exports, 'GraphQLSchema', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.GraphQLSchema;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLScalarType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.GraphQLScalarType;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLObjectType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.GraphQLObjectType;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLInterfaceType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.GraphQLInterfaceType;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLUnionType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.GraphQLUnionType;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLEnumType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.GraphQLEnumType;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLInputObjectType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.GraphQLInputObjectType;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLList', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.GraphQLList;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLNonNull', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.GraphQLNonNull;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLDirective', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.GraphQLDirective;
-	  }
-	});
-	Object.defineProperty(exports, 'TypeKind', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.TypeKind;
-	  }
-	});
-	Object.defineProperty(exports, 'DirectiveLocation', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.DirectiveLocation;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLInt', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.GraphQLInt;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLFloat', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.GraphQLFloat;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLString', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.GraphQLString;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLBoolean', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.GraphQLBoolean;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLID', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.GraphQLID;
-	  }
-	});
-	Object.defineProperty(exports, 'specifiedDirectives', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.specifiedDirectives;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLIncludeDirective', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.GraphQLIncludeDirective;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLSkipDirective', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.GraphQLSkipDirective;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLDeprecatedDirective', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.GraphQLDeprecatedDirective;
-	  }
-	});
-	Object.defineProperty(exports, 'DEFAULT_DEPRECATION_REASON', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.DEFAULT_DEPRECATION_REASON;
-	  }
-	});
-	Object.defineProperty(exports, 'SchemaMetaFieldDef', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.SchemaMetaFieldDef;
-	  }
-	});
-	Object.defineProperty(exports, 'TypeMetaFieldDef', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.TypeMetaFieldDef;
-	  }
-	});
-	Object.defineProperty(exports, 'TypeNameMetaFieldDef', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.TypeNameMetaFieldDef;
-	  }
-	});
-	Object.defineProperty(exports, '__Schema', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.__Schema;
-	  }
-	});
-	Object.defineProperty(exports, '__Directive', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.__Directive;
-	  }
-	});
-	Object.defineProperty(exports, '__DirectiveLocation', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.__DirectiveLocation;
-	  }
-	});
-	Object.defineProperty(exports, '__Type', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.__Type;
-	  }
-	});
-	Object.defineProperty(exports, '__Field', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.__Field;
-	  }
-	});
-	Object.defineProperty(exports, '__InputValue', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.__InputValue;
-	  }
-	});
-	Object.defineProperty(exports, '__EnumValue', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.__EnumValue;
-	  }
-	});
-	Object.defineProperty(exports, '__TypeKind', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.__TypeKind;
-	  }
-	});
-	Object.defineProperty(exports, 'isType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.isType;
-	  }
-	});
-	Object.defineProperty(exports, 'isInputType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.isInputType;
-	  }
-	});
-	Object.defineProperty(exports, 'isOutputType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.isOutputType;
-	  }
-	});
-	Object.defineProperty(exports, 'isLeafType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.isLeafType;
-	  }
-	});
-	Object.defineProperty(exports, 'isCompositeType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.isCompositeType;
-	  }
-	});
-	Object.defineProperty(exports, 'isAbstractType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.isAbstractType;
-	  }
-	});
-	Object.defineProperty(exports, 'getNullableType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.getNullableType;
-	  }
-	});
-	Object.defineProperty(exports, 'getNamedType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _type.getNamedType;
-	  }
-	});
-
-	var _language = __webpack_require__(191);
-
-	Object.defineProperty(exports, 'Source', {
-	  enumerable: true,
-	  get: function get() {
-	    return _language.Source;
-	  }
-	});
-	Object.defineProperty(exports, 'getLocation', {
-	  enumerable: true,
-	  get: function get() {
-	    return _language.getLocation;
-	  }
-	});
-	Object.defineProperty(exports, 'parse', {
-	  enumerable: true,
-	  get: function get() {
-	    return _language.parse;
-	  }
-	});
-	Object.defineProperty(exports, 'parseValue', {
-	  enumerable: true,
-	  get: function get() {
-	    return _language.parseValue;
-	  }
-	});
-	Object.defineProperty(exports, 'parseType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _language.parseType;
-	  }
-	});
-	Object.defineProperty(exports, 'print', {
-	  enumerable: true,
-	  get: function get() {
-	    return _language.print;
-	  }
-	});
-	Object.defineProperty(exports, 'visit', {
-	  enumerable: true,
-	  get: function get() {
-	    return _language.visit;
-	  }
-	});
-	Object.defineProperty(exports, 'visitInParallel', {
-	  enumerable: true,
-	  get: function get() {
-	    return _language.visitInParallel;
-	  }
-	});
-	Object.defineProperty(exports, 'visitWithTypeInfo', {
-	  enumerable: true,
-	  get: function get() {
-	    return _language.visitWithTypeInfo;
-	  }
-	});
-	Object.defineProperty(exports, 'Kind', {
-	  enumerable: true,
-	  get: function get() {
-	    return _language.Kind;
-	  }
-	});
-	Object.defineProperty(exports, 'TokenKind', {
-	  enumerable: true,
-	  get: function get() {
-	    return _language.TokenKind;
-	  }
-	});
-	Object.defineProperty(exports, 'BREAK', {
-	  enumerable: true,
-	  get: function get() {
-	    return _language.BREAK;
-	  }
-	});
-
-	var _execution = __webpack_require__(249);
-
-	Object.defineProperty(exports, 'execute', {
-	  enumerable: true,
-	  get: function get() {
-	    return _execution.execute;
-	  }
-	});
-
-	var _validation = __webpack_require__(250);
-
-	Object.defineProperty(exports, 'validate', {
-	  enumerable: true,
-	  get: function get() {
-	    return _validation.validate;
-	  }
-	});
-	Object.defineProperty(exports, 'specifiedRules', {
-	  enumerable: true,
-	  get: function get() {
-	    return _validation.specifiedRules;
-	  }
-	});
-
-	var _error = __webpack_require__(189);
-
-	Object.defineProperty(exports, 'GraphQLError', {
-	  enumerable: true,
-	  get: function get() {
-	    return _error.GraphQLError;
-	  }
-	});
-	Object.defineProperty(exports, 'formatError', {
-	  enumerable: true,
-	  get: function get() {
-	    return _error.formatError;
-	  }
-	});
-
-	var _utilities = __webpack_require__(251);
-
-	Object.defineProperty(exports, 'introspectionQuery', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.introspectionQuery;
-	  }
-	});
-	Object.defineProperty(exports, 'getOperationAST', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.getOperationAST;
-	  }
-	});
-	Object.defineProperty(exports, 'buildClientSchema', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.buildClientSchema;
-	  }
-	});
-	Object.defineProperty(exports, 'buildASTSchema', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.buildASTSchema;
-	  }
-	});
-	Object.defineProperty(exports, 'buildSchema', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.buildSchema;
-	  }
-	});
-	Object.defineProperty(exports, 'extendSchema', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.extendSchema;
-	  }
-	});
-	Object.defineProperty(exports, 'printSchema', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.printSchema;
-	  }
-	});
-	Object.defineProperty(exports, 'typeFromAST', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.typeFromAST;
-	  }
-	});
-	Object.defineProperty(exports, 'valueFromAST', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.valueFromAST;
-	  }
-	});
-	Object.defineProperty(exports, 'astFromValue', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.astFromValue;
-	  }
-	});
-	Object.defineProperty(exports, 'TypeInfo', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.TypeInfo;
-	  }
-	});
-	Object.defineProperty(exports, 'isValidJSValue', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.isValidJSValue;
-	  }
-	});
-	Object.defineProperty(exports, 'isValidLiteralValue', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.isValidLiteralValue;
-	  }
-	});
-	Object.defineProperty(exports, 'concatAST', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.concatAST;
-	  }
-	});
-	Object.defineProperty(exports, 'separateOperations', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.separateOperations;
-	  }
-	});
-	Object.defineProperty(exports, 'isEqualType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.isEqualType;
-	  }
-	});
-	Object.defineProperty(exports, 'isTypeSubTypeOf', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.isTypeSubTypeOf;
-	  }
-	});
-	Object.defineProperty(exports, 'doTypesOverlap', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.doTypesOverlap;
-	  }
-	});
-	Object.defineProperty(exports, 'assertValidName', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.assertValidName;
-	  }
-	});
-	Object.defineProperty(exports, 'findBreakingChanges', {
-	  enumerable: true,
-	  get: function get() {
-	    return _utilities.findBreakingChanges;
-	  }
-	});
-
-/***/ },
-/* 186 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.graphql = graphql;
-
-	var _source = __webpack_require__(187);
-
-	var _parser = __webpack_require__(188);
-
-	var _validate = __webpack_require__(201);
-
-	var _execute = __webpack_require__(244);
-
-	/**
-	 * This is the primary entry point function for fulfilling GraphQL operations
-	 * by parsing, validating, and executing a GraphQL document along side a
-	 * GraphQL schema.
-	 *
-	 * More sophisticated GraphQL servers, such as those which persist queries,
-	 * may wish to separate the validation and execution phases to a static time
-	 * tooling step, and a server runtime step.
-	 *
-	 * schema:
-	 *    The GraphQL type system to use when validating and executing a query.
-	 * requestString:
-	 *    A GraphQL language formatted string representing the requested operation.
-	 * rootValue:
-	 *    The value provided as the first argument to resolver functions on the top
-	 *    level type (e.g. the query object type).
-	 * variableValues:
-	 *    A mapping of variable name to runtime value to use for all variables
-	 *    defined in the requestString.
-	 * operationName:
-	 *    The name of the operation to use if requestString contains multiple
-	 *    possible operations. Can be omitted if requestString contains only
-	 *    one operation.
-	 */
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function graphql(schema, requestString, rootValue, contextValue, variableValues, operationName) {
-	  return new Promise(function (resolve) {
-	    var source = new _source.Source(requestString || '', 'GraphQL request');
-	    var documentAST = (0, _parser.parse)(source);
-	    var validationErrors = (0, _validate.validate)(schema, documentAST);
-	    if (validationErrors.length > 0) {
-	      resolve({ errors: validationErrors });
-	    } else {
-	      resolve((0, _execute.execute)(schema, documentAST, rootValue, contextValue, variableValues, operationName));
-	    }
-	  }).then(undefined, function (error) {
-	    return { errors: [error] };
-	  });
-	}
-
-	/**
-	 * The result of a GraphQL parse, validation and execution.
-	 *
-	 * `data` is the result of a successful execution of the query.
-	 * `errors` is included when any errors occurred as a non-empty array.
-	 */
-
-/***/ },
-/* 187 */
-/***/ function(module, exports) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	/**
-	 * A representation of source input to GraphQL. The name is optional,
-	 * but is mostly useful for clients who store GraphQL documents in
-	 * source files; for example, if the GraphQL input is in a file Foo.graphql,
-	 * it might be useful for name to be "Foo.graphql".
-	 */
-	var Source = exports.Source = function Source(body, name) {
-	  _classCallCheck(this, Source);
-
-	  this.body = body;
-	  this.name = name || 'GraphQL';
-	};
-
-/***/ },
-/* 188 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.parse = parse;
-	exports.parseValue = parseValue;
-	exports.parseType = parseType;
-	exports.parseConstValue = parseConstValue;
-	exports.parseTypeReference = parseTypeReference;
-	exports.parseNamedType = parseNamedType;
-
-	var _source = __webpack_require__(187);
-
-	var _error = __webpack_require__(189);
-
-	var _lexer = __webpack_require__(193);
-
-	var _kinds = __webpack_require__(196);
-
-	/**
-	 * Given a GraphQL source, parses it into a Document.
-	 * Throws GraphQLError if a syntax error is encountered.
-	 */
-
-
-	/**
-	 * Configuration options to control parser behavior
-	 */
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function parse(source, options) {
-	  var sourceObj = typeof source === 'string' ? new _source.Source(source) : source;
-	  var lexer = (0, _lexer.createLexer)(sourceObj, options || {});
-	  return parseDocument(lexer);
-	}
-
-	/**
-	 * Given a string containing a GraphQL value (ex. `[42]`), parse the AST for
-	 * that value.
-	 * Throws GraphQLError if a syntax error is encountered.
-	 *
-	 * This is useful within tools that operate upon GraphQL Values directly and
-	 * in isolation of complete GraphQL documents.
-	 *
-	 * Consider providing the results to the utility function: valueFromAST().
-	 */
-	function parseValue(source, options) {
-	  var sourceObj = typeof source === 'string' ? new _source.Source(source) : source;
-	  var lexer = (0, _lexer.createLexer)(sourceObj, options || {});
-	  expect(lexer, _lexer.TokenKind.SOF);
-	  var value = parseValueLiteral(lexer, false);
-	  expect(lexer, _lexer.TokenKind.EOF);
-	  return value;
-	}
-
-	/**
-	 * Given a string containing a GraphQL Type (ex. `[Int!]`), parse the AST for
-	 * that type.
-	 * Throws GraphQLError if a syntax error is encountered.
-	 *
-	 * This is useful within tools that operate upon GraphQL Types directly and
-	 * in isolation of complete GraphQL documents.
-	 *
-	 * Consider providing the results to the utility function: typeFromAST().
-	 */
-	function parseType(source, options) {
-	  var sourceObj = typeof source === 'string' ? new _source.Source(source) : source;
-	  var lexer = (0, _lexer.createLexer)(sourceObj, options || {});
-	  expect(lexer, _lexer.TokenKind.SOF);
-	  var type = parseTypeReference(lexer);
-	  expect(lexer, _lexer.TokenKind.EOF);
-	  return type;
-	}
-
-	/**
-	 * Converts a name lex token into a name parse node.
-	 */
-	function parseName(lexer) {
-	  var token = expect(lexer, _lexer.TokenKind.NAME);
-	  return {
-	    kind: _kinds.NAME,
-	    value: token.value,
-	    loc: loc(lexer, token)
-	  };
-	}
-
-	// Implements the parsing rules in the Document section.
-
-	/**
-	 * Document : Definition+
-	 */
-	function parseDocument(lexer) {
-	  var start = lexer.token;
-	  expect(lexer, _lexer.TokenKind.SOF);
-	  var definitions = [];
-	  do {
-	    definitions.push(parseDefinition(lexer));
-	  } while (!skip(lexer, _lexer.TokenKind.EOF));
-
-	  return {
-	    kind: _kinds.DOCUMENT,
-	    definitions: definitions,
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * Definition :
-	 *   - OperationDefinition
-	 *   - FragmentDefinition
-	 *   - TypeSystemDefinition
-	 */
-	function parseDefinition(lexer) {
-	  if (peek(lexer, _lexer.TokenKind.BRACE_L)) {
-	    return parseOperationDefinition(lexer);
-	  }
-
-	  if (peek(lexer, _lexer.TokenKind.NAME)) {
-	    switch (lexer.token.value) {
-	      // Note: subscription is an experimental non-spec addition.
-	      case 'query':
-	      case 'mutation':
-	      case 'subscription':
-	        return parseOperationDefinition(lexer);
-
-	      case 'fragment':
-	        return parseFragmentDefinition(lexer);
-
-	      // Note: the Type System IDL is an experimental non-spec addition.
-	      case 'schema':
-	      case 'scalar':
-	      case 'type':
-	      case 'interface':
-	      case 'union':
-	      case 'enum':
-	      case 'input':
-	      case 'extend':
-	      case 'directive':
-	        return parseTypeSystemDefinition(lexer);
-	    }
-	  }
-
-	  throw unexpected(lexer);
-	}
-
-	// Implements the parsing rules in the Operations section.
-
-	/**
-	 * OperationDefinition :
-	 *  - SelectionSet
-	 *  - OperationType Name? VariableDefinitions? Directives? SelectionSet
-	 */
-	function parseOperationDefinition(lexer) {
-	  var start = lexer.token;
-	  if (peek(lexer, _lexer.TokenKind.BRACE_L)) {
-	    return {
-	      kind: _kinds.OPERATION_DEFINITION,
-	      operation: 'query',
-	      name: null,
-	      variableDefinitions: null,
-	      directives: [],
-	      selectionSet: parseSelectionSet(lexer),
-	      loc: loc(lexer, start)
-	    };
-	  }
-	  var operation = parseOperationType(lexer);
-	  var name = void 0;
-	  if (peek(lexer, _lexer.TokenKind.NAME)) {
-	    name = parseName(lexer);
-	  }
-	  return {
-	    kind: _kinds.OPERATION_DEFINITION,
-	    operation: operation,
-	    name: name,
-	    variableDefinitions: parseVariableDefinitions(lexer),
-	    directives: parseDirectives(lexer),
-	    selectionSet: parseSelectionSet(lexer),
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * OperationType : one of query mutation subscription
-	 */
-	function parseOperationType(lexer) {
-	  var operationToken = expect(lexer, _lexer.TokenKind.NAME);
-	  switch (operationToken.value) {
-	    case 'query':
-	      return 'query';
-	    case 'mutation':
-	      return 'mutation';
-	    // Note: subscription is an experimental non-spec addition.
-	    case 'subscription':
-	      return 'subscription';
-	  }
-
-	  throw unexpected(lexer, operationToken);
-	}
-
-	/**
-	 * VariableDefinitions : ( VariableDefinition+ )
-	 */
-	function parseVariableDefinitions(lexer) {
-	  return peek(lexer, _lexer.TokenKind.PAREN_L) ? many(lexer, _lexer.TokenKind.PAREN_L, parseVariableDefinition, _lexer.TokenKind.PAREN_R) : [];
-	}
-
-	/**
-	 * VariableDefinition : Variable : Type DefaultValue?
-	 */
-	function parseVariableDefinition(lexer) {
-	  var start = lexer.token;
-	  return {
-	    kind: _kinds.VARIABLE_DEFINITION,
-	    variable: parseVariable(lexer),
-	    type: (expect(lexer, _lexer.TokenKind.COLON), parseTypeReference(lexer)),
-	    defaultValue: skip(lexer, _lexer.TokenKind.EQUALS) ? parseValueLiteral(lexer, true) : null,
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * Variable : $ Name
-	 */
-	function parseVariable(lexer) {
-	  var start = lexer.token;
-	  expect(lexer, _lexer.TokenKind.DOLLAR);
-	  return {
-	    kind: _kinds.VARIABLE,
-	    name: parseName(lexer),
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * SelectionSet : { Selection+ }
-	 */
-	function parseSelectionSet(lexer) {
-	  var start = lexer.token;
-	  return {
-	    kind: _kinds.SELECTION_SET,
-	    selections: many(lexer, _lexer.TokenKind.BRACE_L, parseSelection, _lexer.TokenKind.BRACE_R),
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * Selection :
-	 *   - Field
-	 *   - FragmentSpread
-	 *   - InlineFragment
-	 */
-	function parseSelection(lexer) {
-	  return peek(lexer, _lexer.TokenKind.SPREAD) ? parseFragment(lexer) : parseField(lexer);
-	}
-
-	/**
-	 * Field : Alias? Name Arguments? Directives? SelectionSet?
-	 *
-	 * Alias : Name :
-	 */
-	function parseField(lexer) {
-	  var start = lexer.token;
-
-	  var nameOrAlias = parseName(lexer);
-	  var alias = void 0;
-	  var name = void 0;
-	  if (skip(lexer, _lexer.TokenKind.COLON)) {
-	    alias = nameOrAlias;
-	    name = parseName(lexer);
-	  } else {
-	    alias = null;
-	    name = nameOrAlias;
-	  }
-
-	  return {
-	    kind: _kinds.FIELD,
-	    alias: alias,
-	    name: name,
-	    arguments: parseArguments(lexer),
-	    directives: parseDirectives(lexer),
-	    selectionSet: peek(lexer, _lexer.TokenKind.BRACE_L) ? parseSelectionSet(lexer) : null,
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * Arguments : ( Argument+ )
-	 */
-	function parseArguments(lexer) {
-	  return peek(lexer, _lexer.TokenKind.PAREN_L) ? many(lexer, _lexer.TokenKind.PAREN_L, parseArgument, _lexer.TokenKind.PAREN_R) : [];
-	}
-
-	/**
-	 * Argument : Name : Value
-	 */
-	function parseArgument(lexer) {
-	  var start = lexer.token;
-	  return {
-	    kind: _kinds.ARGUMENT,
-	    name: parseName(lexer),
-	    value: (expect(lexer, _lexer.TokenKind.COLON), parseValueLiteral(lexer, false)),
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	// Implements the parsing rules in the Fragments section.
-
-	/**
-	 * Corresponds to both FragmentSpread and InlineFragment in the spec.
-	 *
-	 * FragmentSpread : ... FragmentName Directives?
-	 *
-	 * InlineFragment : ... TypeCondition? Directives? SelectionSet
-	 */
-	function parseFragment(lexer) {
-	  var start = lexer.token;
-	  expect(lexer, _lexer.TokenKind.SPREAD);
-	  if (peek(lexer, _lexer.TokenKind.NAME) && lexer.token.value !== 'on') {
-	    return {
-	      kind: _kinds.FRAGMENT_SPREAD,
-	      name: parseFragmentName(lexer),
-	      directives: parseDirectives(lexer),
-	      loc: loc(lexer, start)
-	    };
-	  }
-	  var typeCondition = null;
-	  if (lexer.token.value === 'on') {
-	    lexer.advance();
-	    typeCondition = parseNamedType(lexer);
-	  }
-	  return {
-	    kind: _kinds.INLINE_FRAGMENT,
-	    typeCondition: typeCondition,
-	    directives: parseDirectives(lexer),
-	    selectionSet: parseSelectionSet(lexer),
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * FragmentDefinition :
-	 *   - fragment FragmentName on TypeCondition Directives? SelectionSet
-	 *
-	 * TypeCondition : NamedType
-	 */
-	function parseFragmentDefinition(lexer) {
-	  var start = lexer.token;
-	  expectKeyword(lexer, 'fragment');
-	  return {
-	    kind: _kinds.FRAGMENT_DEFINITION,
-	    name: parseFragmentName(lexer),
-	    typeCondition: (expectKeyword(lexer, 'on'), parseNamedType(lexer)),
-	    directives: parseDirectives(lexer),
-	    selectionSet: parseSelectionSet(lexer),
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * FragmentName : Name but not `on`
-	 */
-	function parseFragmentName(lexer) {
-	  if (lexer.token.value === 'on') {
-	    throw unexpected(lexer);
-	  }
-	  return parseName(lexer);
-	}
-
-	// Implements the parsing rules in the Values section.
-
-	/**
-	 * Value[Const] :
-	 *   - [~Const] Variable
-	 *   - IntValue
-	 *   - FloatValue
-	 *   - StringValue
-	 *   - BooleanValue
-	 *   - EnumValue
-	 *   - ListValue[?Const]
-	 *   - ObjectValue[?Const]
-	 *
-	 * BooleanValue : one of `true` `false`
-	 *
-	 * EnumValue : Name but not `true`, `false` or `null`
-	 */
-	function parseValueLiteral(lexer, isConst) {
-	  var token = lexer.token;
-	  switch (token.kind) {
-	    case _lexer.TokenKind.BRACKET_L:
-	      return parseList(lexer, isConst);
-	    case _lexer.TokenKind.BRACE_L:
-	      return parseObject(lexer, isConst);
-	    case _lexer.TokenKind.INT:
-	      lexer.advance();
-	      return {
-	        kind: _kinds.INT,
-	        value: token.value,
-	        loc: loc(lexer, token)
-	      };
-	    case _lexer.TokenKind.FLOAT:
-	      lexer.advance();
-	      return {
-	        kind: _kinds.FLOAT,
-	        value: token.value,
-	        loc: loc(lexer, token)
-	      };
-	    case _lexer.TokenKind.STRING:
-	      lexer.advance();
-	      return {
-	        kind: _kinds.STRING,
-	        value: token.value,
-	        loc: loc(lexer, token)
-	      };
-	    case _lexer.TokenKind.NAME:
-	      if (token.value === 'true' || token.value === 'false') {
-	        lexer.advance();
-	        return {
-	          kind: _kinds.BOOLEAN,
-	          value: token.value === 'true',
-	          loc: loc(lexer, token)
-	        };
-	      } else if (token.value !== 'null') {
-	        lexer.advance();
-	        return {
-	          kind: _kinds.ENUM,
-	          value: token.value,
-	          loc: loc(lexer, token)
-	        };
-	      }
-	      break;
-	    case _lexer.TokenKind.DOLLAR:
-	      if (!isConst) {
-	        return parseVariable(lexer);
-	      }
-	      break;
-	  }
-	  throw unexpected(lexer);
-	}
-
-	function parseConstValue(lexer) {
-	  return parseValueLiteral(lexer, true);
-	}
-
-	function parseValueValue(lexer) {
-	  return parseValueLiteral(lexer, false);
-	}
-
-	/**
-	 * ListValue[Const] :
-	 *   - [ ]
-	 *   - [ Value[?Const]+ ]
-	 */
-	function parseList(lexer, isConst) {
-	  var start = lexer.token;
-	  var item = isConst ? parseConstValue : parseValueValue;
-	  return {
-	    kind: _kinds.LIST,
-	    values: any(lexer, _lexer.TokenKind.BRACKET_L, item, _lexer.TokenKind.BRACKET_R),
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * ObjectValue[Const] :
-	 *   - { }
-	 *   - { ObjectField[?Const]+ }
-	 */
-	function parseObject(lexer, isConst) {
-	  var start = lexer.token;
-	  expect(lexer, _lexer.TokenKind.BRACE_L);
-	  var fields = [];
-	  while (!skip(lexer, _lexer.TokenKind.BRACE_R)) {
-	    fields.push(parseObjectField(lexer, isConst));
-	  }
-	  return {
-	    kind: _kinds.OBJECT,
-	    fields: fields,
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * ObjectField[Const] : Name : Value[?Const]
-	 */
-	function parseObjectField(lexer, isConst) {
-	  var start = lexer.token;
-	  return {
-	    kind: _kinds.OBJECT_FIELD,
-	    name: parseName(lexer),
-	    value: (expect(lexer, _lexer.TokenKind.COLON), parseValueLiteral(lexer, isConst)),
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	// Implements the parsing rules in the Directives section.
-
-	/**
-	 * Directives : Directive+
-	 */
-	function parseDirectives(lexer) {
-	  var directives = [];
-	  while (peek(lexer, _lexer.TokenKind.AT)) {
-	    directives.push(parseDirective(lexer));
-	  }
-	  return directives;
-	}
-
-	/**
-	 * Directive : @ Name Arguments?
-	 */
-	function parseDirective(lexer) {
-	  var start = lexer.token;
-	  expect(lexer, _lexer.TokenKind.AT);
-	  return {
-	    kind: _kinds.DIRECTIVE,
-	    name: parseName(lexer),
-	    arguments: parseArguments(lexer),
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	// Implements the parsing rules in the Types section.
-
-	/**
-	 * Type :
-	 *   - NamedType
-	 *   - ListType
-	 *   - NonNullType
-	 */
-	function parseTypeReference(lexer) {
-	  var start = lexer.token;
-	  var type = void 0;
-	  if (skip(lexer, _lexer.TokenKind.BRACKET_L)) {
-	    type = parseTypeReference(lexer);
-	    expect(lexer, _lexer.TokenKind.BRACKET_R);
-	    type = {
-	      kind: _kinds.LIST_TYPE,
-	      type: type,
-	      loc: loc(lexer, start)
-	    };
-	  } else {
-	    type = parseNamedType(lexer);
-	  }
-	  if (skip(lexer, _lexer.TokenKind.BANG)) {
-	    return {
-	      kind: _kinds.NON_NULL_TYPE,
-	      type: type,
-	      loc: loc(lexer, start)
-	    };
-	  }
-	  return type;
-	}
-
-	/**
-	 * NamedType : Name
-	 */
-	function parseNamedType(lexer) {
-	  var start = lexer.token;
-	  return {
-	    kind: _kinds.NAMED_TYPE,
-	    name: parseName(lexer),
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	// Implements the parsing rules in the Type Definition section.
-
-	/**
-	 * TypeSystemDefinition :
-	 *   - SchemaDefinition
-	 *   - TypeDefinition
-	 *   - TypeExtensionDefinition
-	 *   - DirectiveDefinition
-	 *
-	 * TypeDefinition :
-	 *   - ScalarTypeDefinition
-	 *   - ObjectTypeDefinition
-	 *   - InterfaceTypeDefinition
-	 *   - UnionTypeDefinition
-	 *   - EnumTypeDefinition
-	 *   - InputObjectTypeDefinition
-	 */
-	function parseTypeSystemDefinition(lexer) {
-	  if (peek(lexer, _lexer.TokenKind.NAME)) {
-	    switch (lexer.token.value) {
-	      case 'schema':
-	        return parseSchemaDefinition(lexer);
-	      case 'scalar':
-	        return parseScalarTypeDefinition(lexer);
-	      case 'type':
-	        return parseObjectTypeDefinition(lexer);
-	      case 'interface':
-	        return parseInterfaceTypeDefinition(lexer);
-	      case 'union':
-	        return parseUnionTypeDefinition(lexer);
-	      case 'enum':
-	        return parseEnumTypeDefinition(lexer);
-	      case 'input':
-	        return parseInputObjectTypeDefinition(lexer);
-	      case 'extend':
-	        return parseTypeExtensionDefinition(lexer);
-	      case 'directive':
-	        return parseDirectiveDefinition(lexer);
-	    }
-	  }
-
-	  throw unexpected(lexer);
-	}
-
-	/**
-	 * SchemaDefinition : schema Directives? { OperationTypeDefinition+ }
-	 *
-	 * OperationTypeDefinition : OperationType : NamedType
-	 */
-	function parseSchemaDefinition(lexer) {
-	  var start = lexer.token;
-	  expectKeyword(lexer, 'schema');
-	  var directives = parseDirectives(lexer);
-	  var operationTypes = many(lexer, _lexer.TokenKind.BRACE_L, parseOperationTypeDefinition, _lexer.TokenKind.BRACE_R);
-	  return {
-	    kind: _kinds.SCHEMA_DEFINITION,
-	    directives: directives,
-	    operationTypes: operationTypes,
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	function parseOperationTypeDefinition(lexer) {
-	  var start = lexer.token;
-	  var operation = parseOperationType(lexer);
-	  expect(lexer, _lexer.TokenKind.COLON);
-	  var type = parseNamedType(lexer);
-	  return {
-	    kind: _kinds.OPERATION_TYPE_DEFINITION,
-	    operation: operation,
-	    type: type,
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * ScalarTypeDefinition : scalar Name Directives?
-	 */
-	function parseScalarTypeDefinition(lexer) {
-	  var start = lexer.token;
-	  expectKeyword(lexer, 'scalar');
-	  var name = parseName(lexer);
-	  var directives = parseDirectives(lexer);
-	  return {
-	    kind: _kinds.SCALAR_TYPE_DEFINITION,
-	    name: name,
-	    directives: directives,
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * ObjectTypeDefinition :
-	 *   - type Name ImplementsInterfaces? Directives? { FieldDefinition+ }
-	 */
-	function parseObjectTypeDefinition(lexer) {
-	  var start = lexer.token;
-	  expectKeyword(lexer, 'type');
-	  var name = parseName(lexer);
-	  var interfaces = parseImplementsInterfaces(lexer);
-	  var directives = parseDirectives(lexer);
-	  var fields = any(lexer, _lexer.TokenKind.BRACE_L, parseFieldDefinition, _lexer.TokenKind.BRACE_R);
-	  return {
-	    kind: _kinds.OBJECT_TYPE_DEFINITION,
-	    name: name,
-	    interfaces: interfaces,
-	    directives: directives,
-	    fields: fields,
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * ImplementsInterfaces : implements NamedType+
-	 */
-	function parseImplementsInterfaces(lexer) {
-	  var types = [];
-	  if (lexer.token.value === 'implements') {
-	    lexer.advance();
-	    do {
-	      types.push(parseNamedType(lexer));
-	    } while (peek(lexer, _lexer.TokenKind.NAME));
-	  }
-	  return types;
-	}
-
-	/**
-	 * FieldDefinition : Name ArgumentsDefinition? : Type Directives?
-	 */
-	function parseFieldDefinition(lexer) {
-	  var start = lexer.token;
-	  var name = parseName(lexer);
-	  var args = parseArgumentDefs(lexer);
-	  expect(lexer, _lexer.TokenKind.COLON);
-	  var type = parseTypeReference(lexer);
-	  var directives = parseDirectives(lexer);
-	  return {
-	    kind: _kinds.FIELD_DEFINITION,
-	    name: name,
-	    arguments: args,
-	    type: type,
-	    directives: directives,
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * ArgumentsDefinition : ( InputValueDefinition+ )
-	 */
-	function parseArgumentDefs(lexer) {
-	  if (!peek(lexer, _lexer.TokenKind.PAREN_L)) {
-	    return [];
-	  }
-	  return many(lexer, _lexer.TokenKind.PAREN_L, parseInputValueDef, _lexer.TokenKind.PAREN_R);
-	}
-
-	/**
-	 * InputValueDefinition : Name : Type DefaultValue? Directives?
-	 */
-	function parseInputValueDef(lexer) {
-	  var start = lexer.token;
-	  var name = parseName(lexer);
-	  expect(lexer, _lexer.TokenKind.COLON);
-	  var type = parseTypeReference(lexer);
-	  var defaultValue = null;
-	  if (skip(lexer, _lexer.TokenKind.EQUALS)) {
-	    defaultValue = parseConstValue(lexer);
-	  }
-	  var directives = parseDirectives(lexer);
-	  return {
-	    kind: _kinds.INPUT_VALUE_DEFINITION,
-	    name: name,
-	    type: type,
-	    defaultValue: defaultValue,
-	    directives: directives,
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * InterfaceTypeDefinition : interface Name Directives? { FieldDefinition+ }
-	 */
-	function parseInterfaceTypeDefinition(lexer) {
-	  var start = lexer.token;
-	  expectKeyword(lexer, 'interface');
-	  var name = parseName(lexer);
-	  var directives = parseDirectives(lexer);
-	  var fields = any(lexer, _lexer.TokenKind.BRACE_L, parseFieldDefinition, _lexer.TokenKind.BRACE_R);
-	  return {
-	    kind: _kinds.INTERFACE_TYPE_DEFINITION,
-	    name: name,
-	    directives: directives,
-	    fields: fields,
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * UnionTypeDefinition : union Name Directives? = UnionMembers
-	 */
-	function parseUnionTypeDefinition(lexer) {
-	  var start = lexer.token;
-	  expectKeyword(lexer, 'union');
-	  var name = parseName(lexer);
-	  var directives = parseDirectives(lexer);
-	  expect(lexer, _lexer.TokenKind.EQUALS);
-	  var types = parseUnionMembers(lexer);
-	  return {
-	    kind: _kinds.UNION_TYPE_DEFINITION,
-	    name: name,
-	    directives: directives,
-	    types: types,
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * UnionMembers :
-	 *   - NamedType
-	 *   - UnionMembers | NamedType
-	 */
-	function parseUnionMembers(lexer) {
-	  var members = [];
-	  do {
-	    members.push(parseNamedType(lexer));
-	  } while (skip(lexer, _lexer.TokenKind.PIPE));
-	  return members;
-	}
-
-	/**
-	 * EnumTypeDefinition : enum Name Directives? { EnumValueDefinition+ }
-	 */
-	function parseEnumTypeDefinition(lexer) {
-	  var start = lexer.token;
-	  expectKeyword(lexer, 'enum');
-	  var name = parseName(lexer);
-	  var directives = parseDirectives(lexer);
-	  var values = many(lexer, _lexer.TokenKind.BRACE_L, parseEnumValueDefinition, _lexer.TokenKind.BRACE_R);
-	  return {
-	    kind: _kinds.ENUM_TYPE_DEFINITION,
-	    name: name,
-	    directives: directives,
-	    values: values,
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * EnumValueDefinition : EnumValue Directives?
-	 *
-	 * EnumValue : Name
-	 */
-	function parseEnumValueDefinition(lexer) {
-	  var start = lexer.token;
-	  var name = parseName(lexer);
-	  var directives = parseDirectives(lexer);
-	  return {
-	    kind: _kinds.ENUM_VALUE_DEFINITION,
-	    name: name,
-	    directives: directives,
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * InputObjectTypeDefinition : input Name Directives? { InputValueDefinition+ }
-	 */
-	function parseInputObjectTypeDefinition(lexer) {
-	  var start = lexer.token;
-	  expectKeyword(lexer, 'input');
-	  var name = parseName(lexer);
-	  var directives = parseDirectives(lexer);
-	  var fields = any(lexer, _lexer.TokenKind.BRACE_L, parseInputValueDef, _lexer.TokenKind.BRACE_R);
-	  return {
-	    kind: _kinds.INPUT_OBJECT_TYPE_DEFINITION,
-	    name: name,
-	    directives: directives,
-	    fields: fields,
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * TypeExtensionDefinition : extend ObjectTypeDefinition
-	 */
-	function parseTypeExtensionDefinition(lexer) {
-	  var start = lexer.token;
-	  expectKeyword(lexer, 'extend');
-	  var definition = parseObjectTypeDefinition(lexer);
-	  return {
-	    kind: _kinds.TYPE_EXTENSION_DEFINITION,
-	    definition: definition,
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * DirectiveDefinition :
-	 *   - directive @ Name ArgumentsDefinition? on DirectiveLocations
-	 */
-	function parseDirectiveDefinition(lexer) {
-	  var start = lexer.token;
-	  expectKeyword(lexer, 'directive');
-	  expect(lexer, _lexer.TokenKind.AT);
-	  var name = parseName(lexer);
-	  var args = parseArgumentDefs(lexer);
-	  expectKeyword(lexer, 'on');
-	  var locations = parseDirectiveLocations(lexer);
-	  return {
-	    kind: _kinds.DIRECTIVE_DEFINITION,
-	    name: name,
-	    arguments: args,
-	    locations: locations,
-	    loc: loc(lexer, start)
-	  };
-	}
-
-	/**
-	 * DirectiveLocations :
-	 *   - Name
-	 *   - DirectiveLocations | Name
-	 */
-	function parseDirectiveLocations(lexer) {
-	  var locations = [];
-	  do {
-	    locations.push(parseName(lexer));
-	  } while (skip(lexer, _lexer.TokenKind.PIPE));
-	  return locations;
-	}
-
-	// Core parsing utility functions
-
-	/**
-	 * Returns a location object, used to identify the place in
-	 * the source that created a given parsed object.
-	 */
-	function loc(lexer, startToken) {
-	  if (!lexer.options.noLocation) {
-	    return new Loc(startToken, lexer.lastToken, lexer.source);
-	  }
-	}
-
-	function Loc(startToken, endToken, source) {
-	  this.start = startToken.start;
-	  this.end = endToken.end;
-	  this.startToken = startToken;
-	  this.endToken = endToken;
-	  this.source = source;
-	}
-
-	// Print a simplified form when appearing in JSON/util.inspect.
-	Loc.prototype.toJSON = Loc.prototype.inspect = function toJSON() {
-	  return { start: this.start, end: this.end };
-	};
-
-	/**
-	 * Determines if the next token is of a given kind
-	 */
-	function peek(lexer, kind) {
-	  return lexer.token.kind === kind;
-	}
-
-	/**
-	 * If the next token is of the given kind, return true after advancing
-	 * the lexer. Otherwise, do not change the parser state and return false.
-	 */
-	function skip(lexer, kind) {
-	  var match = lexer.token.kind === kind;
-	  if (match) {
-	    lexer.advance();
-	  }
-	  return match;
-	}
-
-	/**
-	 * If the next token is of the given kind, return that token after advancing
-	 * the lexer. Otherwise, do not change the parser state and throw an error.
-	 */
-	function expect(lexer, kind) {
-	  var token = lexer.token;
-	  if (token.kind === kind) {
-	    lexer.advance();
-	    return token;
-	  }
-	  throw (0, _error.syntaxError)(lexer.source, token.start, 'Expected ' + kind + ', found ' + (0, _lexer.getTokenDesc)(token));
-	}
-
-	/**
-	 * If the next token is a keyword with the given value, return that token after
-	 * advancing the lexer. Otherwise, do not change the parser state and return
-	 * false.
-	 */
-	function expectKeyword(lexer, value) {
-	  var token = lexer.token;
-	  if (token.kind === _lexer.TokenKind.NAME && token.value === value) {
-	    lexer.advance();
-	    return token;
-	  }
-	  throw (0, _error.syntaxError)(lexer.source, token.start, 'Expected "' + value + '", found ' + (0, _lexer.getTokenDesc)(token));
-	}
-
-	/**
-	 * Helper function for creating an error when an unexpected lexed token
-	 * is encountered.
-	 */
-	function unexpected(lexer, atToken) {
-	  var token = atToken || lexer.token;
-	  return (0, _error.syntaxError)(lexer.source, token.start, 'Unexpected ' + (0, _lexer.getTokenDesc)(token));
-	}
-
-	/**
-	 * Returns a possibly empty list of parse nodes, determined by
-	 * the parseFn. This list begins with a lex token of openKind
-	 * and ends with a lex token of closeKind. Advances the parser
-	 * to the next lex token after the closing token.
-	 */
-	function any(lexer, openKind, parseFn, closeKind) {
-	  expect(lexer, openKind);
-	  var nodes = [];
-	  while (!skip(lexer, closeKind)) {
-	    nodes.push(parseFn(lexer));
-	  }
-	  return nodes;
-	}
-
-	/**
-	 * Returns a non-empty list of parse nodes, determined by
-	 * the parseFn. This list begins with a lex token of openKind
-	 * and ends with a lex token of closeKind. Advances the parser
-	 * to the next lex token after the closing token.
-	 */
-	function many(lexer, openKind, parseFn, closeKind) {
-	  expect(lexer, openKind);
-	  var nodes = [parseFn(lexer)];
-	  while (!skip(lexer, closeKind)) {
-	    nodes.push(parseFn(lexer));
-	  }
-	  return nodes;
-	}
-
-/***/ },
-/* 189 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-
-	var _GraphQLError = __webpack_require__(190);
-
-	Object.defineProperty(exports, 'GraphQLError', {
-	  enumerable: true,
-	  get: function get() {
-	    return _GraphQLError.GraphQLError;
-	  }
-	});
-
-	var _syntaxError = __webpack_require__(197);
-
-	Object.defineProperty(exports, 'syntaxError', {
-	  enumerable: true,
-	  get: function get() {
-	    return _syntaxError.syntaxError;
-	  }
-	});
-
-	var _locatedError = __webpack_require__(198);
-
-	Object.defineProperty(exports, 'locatedError', {
-	  enumerable: true,
-	  get: function get() {
-	    return _locatedError.locatedError;
-	  }
-	});
-
-	var _formatError = __webpack_require__(199);
-
-	Object.defineProperty(exports, 'formatError', {
-	  enumerable: true,
-	  get: function get() {
-	    return _formatError.formatError;
-	  }
-	});
-
-/***/ },
-/* 190 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.GraphQLError = GraphQLError;
-
-	var _language = __webpack_require__(191);
-
-	/**
-	 * A GraphQLError describes an Error found during the parse, validate, or
-	 * execute phases of performing a GraphQL operation. In addition to a message
-	 * and stack trace, it also includes information about the locations in a
-	 * GraphQL document and/or execution result that correspond to the Error.
-	 */
-	function GraphQLError( // eslint-disable-line no-redeclare
-	message, nodes, source, positions, path, originalError) {
-	  // Include (non-enumerable) stack trace.
-	  if (originalError && originalError.stack) {
-	    Object.defineProperty(this, 'stack', {
-	      value: originalError.stack,
-	      writable: true,
-	      configurable: true
-	    });
-	  } else if (Error.captureStackTrace) {
-	    Error.captureStackTrace(this, GraphQLError);
-	  } else {
-	    Object.defineProperty(this, 'stack', {
-	      value: Error().stack,
-	      writable: true,
-	      configurable: true
-	    });
-	  }
-
-	  // Compute locations in the source for the given nodes/positions.
-	  var _source = source;
-	  if (!_source && nodes && nodes.length > 0) {
-	    var node = nodes[0];
-	    _source = node && node.loc && node.loc.source;
-	  }
-
-	  var _positions = positions;
-	  if (!_positions && nodes) {
-	    _positions = nodes.filter(function (node) {
-	      return Boolean(node.loc);
-	    }).map(function (node) {
-	      return node.loc.start;
-	    });
-	  }
-	  if (_positions && _positions.length === 0) {
-	    _positions = undefined;
-	  }
-
-	  var _locations = void 0;
-	  var _source2 = _source; // seems here Flow need a const to resolve type.
-	  if (_source2 && _positions) {
-	    _locations = _positions.map(function (pos) {
-	      return (0, _language.getLocation)(_source2, pos);
-	    });
-	  }
-
-	  Object.defineProperties(this, {
-	    message: {
-	      value: message,
-	      // By being enumerable, JSON.stringify will include `message` in the
-	      // resulting output. This ensures that the simplist possible GraphQL
-	      // service adheres to the spec.
-	      enumerable: true,
-	      writable: true
-	    },
-	    locations: {
-	      // Coercing falsey values to undefined ensures they will not be included
-	      // in JSON.stringify() when not provided.
-	      value: _locations || undefined,
-	      // By being enumerable, JSON.stringify will include `locations` in the
-	      // resulting output. This ensures that the simplist possible GraphQL
-	      // service adheres to the spec.
-	      enumerable: true
-	    },
-	    path: {
-	      // Coercing falsey values to undefined ensures they will not be included
-	      // in JSON.stringify() when not provided.
-	      value: path || undefined,
-	      // By being enumerable, JSON.stringify will include `path` in the
-	      // resulting output. This ensures that the simplist possible GraphQL
-	      // service adheres to the spec.
-	      enumerable: true
-	    },
-	    nodes: {
-	      value: nodes || undefined
-	    },
-	    source: {
-	      value: _source || undefined
-	    },
-	    positions: {
-	      value: _positions || undefined
-	    },
-	    originalError: {
-	      value: originalError
-	    }
-	  });
-	}
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	GraphQLError.prototype = Object.create(Error.prototype, {
-	  constructor: { value: GraphQLError },
-	  name: { value: 'GraphQLError' }
-	});
-
-/***/ },
-/* 191 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.BREAK = exports.visitWithTypeInfo = exports.visitInParallel = exports.visit = exports.Source = exports.print = exports.parseType = exports.parseValue = exports.parse = exports.TokenKind = exports.createLexer = exports.Kind = exports.getLocation = undefined;
-
-	var _location = __webpack_require__(192);
-
-	Object.defineProperty(exports, 'getLocation', {
-	  enumerable: true,
-	  get: function get() {
-	    return _location.getLocation;
-	  }
-	});
-
-	var _lexer = __webpack_require__(193);
-
-	Object.defineProperty(exports, 'createLexer', {
-	  enumerable: true,
-	  get: function get() {
-	    return _lexer.createLexer;
-	  }
-	});
-	Object.defineProperty(exports, 'TokenKind', {
-	  enumerable: true,
-	  get: function get() {
-	    return _lexer.TokenKind;
-	  }
-	});
-
-	var _parser = __webpack_require__(188);
-
-	Object.defineProperty(exports, 'parse', {
-	  enumerable: true,
-	  get: function get() {
-	    return _parser.parse;
-	  }
-	});
-	Object.defineProperty(exports, 'parseValue', {
-	  enumerable: true,
-	  get: function get() {
-	    return _parser.parseValue;
-	  }
-	});
-	Object.defineProperty(exports, 'parseType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _parser.parseType;
-	  }
-	});
-
-	var _printer = __webpack_require__(194);
-
-	Object.defineProperty(exports, 'print', {
-	  enumerable: true,
-	  get: function get() {
-	    return _printer.print;
-	  }
-	});
-
-	var _source = __webpack_require__(187);
-
-	Object.defineProperty(exports, 'Source', {
-	  enumerable: true,
-	  get: function get() {
-	    return _source.Source;
-	  }
-	});
-
-	var _visitor = __webpack_require__(195);
-
-	Object.defineProperty(exports, 'visit', {
-	  enumerable: true,
-	  get: function get() {
-	    return _visitor.visit;
-	  }
-	});
-	Object.defineProperty(exports, 'visitInParallel', {
-	  enumerable: true,
-	  get: function get() {
-	    return _visitor.visitInParallel;
-	  }
-	});
-	Object.defineProperty(exports, 'visitWithTypeInfo', {
-	  enumerable: true,
-	  get: function get() {
-	    return _visitor.visitWithTypeInfo;
-	  }
-	});
-	Object.defineProperty(exports, 'BREAK', {
-	  enumerable: true,
-	  get: function get() {
-	    return _visitor.BREAK;
-	  }
-	});
-
-	var _kinds = __webpack_require__(196);
-
-	var Kind = _interopRequireWildcard(_kinds);
-
-	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-	exports.Kind = Kind;
-
-/***/ },
-/* 192 */
-/***/ function(module, exports) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.getLocation = getLocation;
-
-
-	/**
-	 * Takes a Source and a UTF-8 character offset, and returns the corresponding
-	 * line and column as a SourceLocation.
-	 */
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function getLocation(source, position) {
-	  var lineRegexp = /\r\n|[\n\r]/g;
-	  var line = 1;
-	  var column = position + 1;
-	  var match = void 0;
-	  while ((match = lineRegexp.exec(source.body)) && match.index < position) {
-	    line += 1;
-	    column = position + 1 - (match.index + match[0].length);
-	  }
-	  return { line: line, column: column };
-	}
-
-	/**
-	 * Represents a location in a Source.
-	 */
-
-/***/ },
-/* 193 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.TokenKind = undefined;
-	exports.createLexer = createLexer;
-	exports.getTokenDesc = getTokenDesc;
-
-	var _error = __webpack_require__(189);
-
-	/**
-	 * Given a Source object, this returns a Lexer for that source.
-	 * A Lexer is a stateful stream generator in that every time
-	 * it is advanced, it returns the next token in the Source. Assuming the
-	 * source lexes, the final Token emitted by the lexer will be of kind
-	 * EOF, after which the lexer will repeatedly return the same EOF token
-	 * whenever called.
-	 */
-	function createLexer(source, options) {
-	  var startOfFileToken = new Tok(SOF, 0, 0, 0, 0, null);
-	  var lexer = {
-	    source: source,
-	    options: options,
-	    lastToken: startOfFileToken,
-	    token: startOfFileToken,
-	    line: 1,
-	    lineStart: 0,
-	    advance: advanceLexer
-	  };
-	  return lexer;
-	} /*  /
-	  /**
-	   *  Copyright (c) 2015, Facebook, Inc.
-	   *  All rights reserved.
-	   *
-	   *  This source code is licensed under the BSD-style license found in the
-	   *  LICENSE file in the root directory of this source tree. An additional grant
-	   *  of patent rights can be found in the PATENTS file in the same directory.
-	   */
-
-	function advanceLexer() {
-	  var token = this.lastToken = this.token;
-	  if (token.kind !== EOF) {
-	    do {
-	      token = token.next = readToken(this, token);
-	    } while (token.kind === COMMENT);
-	    this.token = token;
-	  }
-	  return token;
-	}
-
-	/**
-	 * The return type of createLexer.
-	 */
-
-
-	// Each kind of token.
-	var SOF = '<SOF>';
-	var EOF = '<EOF>';
-	var BANG = '!';
-	var DOLLAR = '$';
-	var PAREN_L = '(';
-	var PAREN_R = ')';
-	var SPREAD = '...';
-	var COLON = ':';
-	var EQUALS = '=';
-	var AT = '@';
-	var BRACKET_L = '[';
-	var BRACKET_R = ']';
-	var BRACE_L = '{';
-	var PIPE = '|';
-	var BRACE_R = '}';
-	var NAME = 'Name';
-	var INT = 'Int';
-	var FLOAT = 'Float';
-	var STRING = 'String';
-	var COMMENT = 'Comment';
-
-	/**
-	 * An exported enum describing the different kinds of tokens that the
-	 * lexer emits.
-	 */
-	var TokenKind = exports.TokenKind = {
-	  SOF: SOF,
-	  EOF: EOF,
-	  BANG: BANG,
-	  DOLLAR: DOLLAR,
-	  PAREN_L: PAREN_L,
-	  PAREN_R: PAREN_R,
-	  SPREAD: SPREAD,
-	  COLON: COLON,
-	  EQUALS: EQUALS,
-	  AT: AT,
-	  BRACKET_L: BRACKET_L,
-	  BRACKET_R: BRACKET_R,
-	  BRACE_L: BRACE_L,
-	  PIPE: PIPE,
-	  BRACE_R: BRACE_R,
-	  NAME: NAME,
-	  INT: INT,
-	  FLOAT: FLOAT,
-	  STRING: STRING,
-	  COMMENT: COMMENT
-	};
-
-	/**
-	 * A helper function to describe a token as a string for debugging
-	 */
-	function getTokenDesc(token) {
-	  var value = token.value;
-	  return value ? token.kind + ' "' + value + '"' : token.kind;
-	}
-
-	var charCodeAt = String.prototype.charCodeAt;
-	var slice = String.prototype.slice;
-
-	/**
-	 * Helper function for constructing the Token object.
-	 */
-	function Tok(kind, start, end, line, column, prev, value) {
-	  this.kind = kind;
-	  this.start = start;
-	  this.end = end;
-	  this.line = line;
-	  this.column = column;
-	  this.value = value;
-	  this.prev = prev;
-	  this.next = null;
-	}
-
-	// Print a simplified form when appearing in JSON/util.inspect.
-	Tok.prototype.toJSON = Tok.prototype.inspect = function toJSON() {
-	  return {
-	    kind: this.kind,
-	    value: this.value,
-	    line: this.line,
-	    column: this.column
-	  };
-	};
-
-	function printCharCode(code) {
-	  return (
-	    // NaN/undefined represents access beyond the end of the file.
-	    isNaN(code) ? EOF :
-	    // Trust JSON for ASCII.
-	    code < 0x007F ? JSON.stringify(String.fromCharCode(code)) :
-	    // Otherwise print the escaped form.
-	    '"\\u' + ('00' + code.toString(16).toUpperCase()).slice(-4) + '"'
-	  );
-	}
-
-	/**
-	 * Gets the next token from the source starting at the given position.
-	 *
-	 * This skips over whitespace and comments until it finds the next lexable
-	 * token, then lexes punctuators immediately or calls the appropriate helper
-	 * function for more complicated tokens.
-	 */
-	function readToken(lexer, prev) {
-	  var source = lexer.source;
-	  var body = source.body;
-	  var bodyLength = body.length;
-
-	  var position = positionAfterWhitespace(body, prev.end, lexer);
-	  var line = lexer.line;
-	  var col = 1 + position - lexer.lineStart;
-
-	  if (position >= bodyLength) {
-	    return new Tok(EOF, bodyLength, bodyLength, line, col, prev);
-	  }
-
-	  var code = charCodeAt.call(body, position);
-
-	  // SourceCharacter
-	  if (code < 0x0020 && code !== 0x0009 && code !== 0x000A && code !== 0x000D) {
-	    throw (0, _error.syntaxError)(source, position, 'Invalid character ' + printCharCode(code) + '.');
-	  }
-
-	  switch (code) {
-	    // !
-	    case 33:
-	      return new Tok(BANG, position, position + 1, line, col, prev);
-	    // #
-	    case 35:
-	      return readComment(source, position, line, col, prev);
-	    // $
-	    case 36:
-	      return new Tok(DOLLAR, position, position + 1, line, col, prev);
-	    // (
-	    case 40:
-	      return new Tok(PAREN_L, position, position + 1, line, col, prev);
-	    // )
-	    case 41:
-	      return new Tok(PAREN_R, position, position + 1, line, col, prev);
-	    // .
-	    case 46:
-	      if (charCodeAt.call(body, position + 1) === 46 && charCodeAt.call(body, position + 2) === 46) {
-	        return new Tok(SPREAD, position, position + 3, line, col, prev);
-	      }
-	      break;
-	    // :
-	    case 58:
-	      return new Tok(COLON, position, position + 1, line, col, prev);
-	    // =
-	    case 61:
-	      return new Tok(EQUALS, position, position + 1, line, col, prev);
-	    // @
-	    case 64:
-	      return new Tok(AT, position, position + 1, line, col, prev);
-	    // [
-	    case 91:
-	      return new Tok(BRACKET_L, position, position + 1, line, col, prev);
-	    // ]
-	    case 93:
-	      return new Tok(BRACKET_R, position, position + 1, line, col, prev);
-	    // {
-	    case 123:
-	      return new Tok(BRACE_L, position, position + 1, line, col, prev);
-	    // |
-	    case 124:
-	      return new Tok(PIPE, position, position + 1, line, col, prev);
-	    // }
-	    case 125:
-	      return new Tok(BRACE_R, position, position + 1, line, col, prev);
-	    // A-Z _ a-z
-	    case 65:case 66:case 67:case 68:case 69:case 70:case 71:case 72:
-	    case 73:case 74:case 75:case 76:case 77:case 78:case 79:case 80:
-	    case 81:case 82:case 83:case 84:case 85:case 86:case 87:case 88:
-	    case 89:case 90:
-	    case 95:
-	    case 97:case 98:case 99:case 100:case 101:case 102:case 103:case 104:
-	    case 105:case 106:case 107:case 108:case 109:case 110:case 111:
-	    case 112:case 113:case 114:case 115:case 116:case 117:case 118:
-	    case 119:case 120:case 121:case 122:
-	      return readName(source, position, line, col, prev);
-	    // - 0-9
-	    case 45:
-	    case 48:case 49:case 50:case 51:case 52:
-	    case 53:case 54:case 55:case 56:case 57:
-	      return readNumber(source, position, code, line, col, prev);
-	    // "
-	    case 34:
-	      return readString(source, position, line, col, prev);
-	  }
-
-	  throw (0, _error.syntaxError)(source, position, 'Unexpected character ' + printCharCode(code) + '.');
-	}
-
-	/**
-	 * Reads from body starting at startPosition until it finds a non-whitespace
-	 * or commented character, then returns the position of that character for
-	 * lexing.
-	 */
-	function positionAfterWhitespace(body, startPosition, lexer) {
-	  var bodyLength = body.length;
-	  var position = startPosition;
-	  while (position < bodyLength) {
-	    var code = charCodeAt.call(body, position);
-	    // tab | space | comma | BOM
-	    if (code === 9 || code === 32 || code === 44 || code === 0xFEFF) {
-	      ++position;
-	    } else if (code === 10) {
-	      // new line
-	      ++position;
-	      ++lexer.line;
-	      lexer.lineStart = position;
-	    } else if (code === 13) {
-	      // carriage return
-	      if (charCodeAt.call(body, position + 1) === 10) {
-	        position += 2;
-	      } else {
-	        ++position;
-	      }
-	      ++lexer.line;
-	      lexer.lineStart = position;
-	    } else {
-	      break;
-	    }
-	  }
-	  return position;
-	}
-
-	/**
-	 * Reads a comment token from the source file.
-	 *
-	 * #[\u0009\u0020-\uFFFF]*
-	 */
-	function readComment(source, start, line, col, prev) {
-	  var body = source.body;
-	  var code = void 0;
-	  var position = start;
-
-	  do {
-	    code = charCodeAt.call(body, ++position);
-	  } while (code !== null && (
-	  // SourceCharacter but not LineTerminator
-	  code > 0x001F || code === 0x0009));
-
-	  return new Tok(COMMENT, start, position, line, col, prev, slice.call(body, start + 1, position));
-	}
-
-	/**
-	 * Reads a number token from the source file, either a float
-	 * or an int depending on whether a decimal point appears.
-	 *
-	 * Int:   -?(0|[1-9][0-9]*)
-	 * Float: -?(0|[1-9][0-9]*)(\.[0-9]+)?((E|e)(+|-)?[0-9]+)?
-	 */
-	function readNumber(source, start, firstCode, line, col, prev) {
-	  var body = source.body;
-	  var code = firstCode;
-	  var position = start;
-	  var isFloat = false;
-
-	  if (code === 45) {
-	    // -
-	    code = charCodeAt.call(body, ++position);
-	  }
-
-	  if (code === 48) {
-	    // 0
-	    code = charCodeAt.call(body, ++position);
-	    if (code >= 48 && code <= 57) {
-	      throw (0, _error.syntaxError)(source, position, 'Invalid number, unexpected digit after 0: ' + printCharCode(code) + '.');
-	    }
-	  } else {
-	    position = readDigits(source, position, code);
-	    code = charCodeAt.call(body, position);
-	  }
-
-	  if (code === 46) {
-	    // .
-	    isFloat = true;
-
-	    code = charCodeAt.call(body, ++position);
-	    position = readDigits(source, position, code);
-	    code = charCodeAt.call(body, position);
-	  }
-
-	  if (code === 69 || code === 101) {
-	    // E e
-	    isFloat = true;
-
-	    code = charCodeAt.call(body, ++position);
-	    if (code === 43 || code === 45) {
-	      // + -
-	      code = charCodeAt.call(body, ++position);
-	    }
-	    position = readDigits(source, position, code);
-	  }
-
-	  return new Tok(isFloat ? FLOAT : INT, start, position, line, col, prev, slice.call(body, start, position));
-	}
-
-	/**
-	 * Returns the new position in the source after reading digits.
-	 */
-	function readDigits(source, start, firstCode) {
-	  var body = source.body;
-	  var position = start;
-	  var code = firstCode;
-	  if (code >= 48 && code <= 57) {
-	    // 0 - 9
-	    do {
-	      code = charCodeAt.call(body, ++position);
-	    } while (code >= 48 && code <= 57); // 0 - 9
-	    return position;
-	  }
-	  throw (0, _error.syntaxError)(source, position, 'Invalid number, expected digit but got: ' + printCharCode(code) + '.');
-	}
-
-	/**
-	 * Reads a string token from the source file.
-	 *
-	 * "([^"\\\u000A\u000D]|(\\(u[0-9a-fA-F]{4}|["\\/bfnrt])))*"
-	 */
-	function readString(source, start, line, col, prev) {
-	  var body = source.body;
-	  var position = start + 1;
-	  var chunkStart = position;
-	  var code = 0;
-	  var value = '';
-
-	  while (position < body.length && (code = charCodeAt.call(body, position)) !== null &&
-	  // not LineTerminator
-	  code !== 0x000A && code !== 0x000D &&
-	  // not Quote (")
-	  code !== 34) {
-	    // SourceCharacter
-	    if (code < 0x0020 && code !== 0x0009) {
-	      throw (0, _error.syntaxError)(source, position, 'Invalid character within String: ' + printCharCode(code) + '.');
-	    }
-
-	    ++position;
-	    if (code === 92) {
-	      // \
-	      value += slice.call(body, chunkStart, position - 1);
-	      code = charCodeAt.call(body, position);
-	      switch (code) {
-	        case 34:
-	          value += '"';break;
-	        case 47:
-	          value += '\/';break;
-	        case 92:
-	          value += '\\';break;
-	        case 98:
-	          value += '\b';break;
-	        case 102:
-	          value += '\f';break;
-	        case 110:
-	          value += '\n';break;
-	        case 114:
-	          value += '\r';break;
-	        case 116:
-	          value += '\t';break;
-	        case 117:
-	          // u
-	          var charCode = uniCharCode(charCodeAt.call(body, position + 1), charCodeAt.call(body, position + 2), charCodeAt.call(body, position + 3), charCodeAt.call(body, position + 4));
-	          if (charCode < 0) {
-	            throw (0, _error.syntaxError)(source, position, 'Invalid character escape sequence: ' + ('\\u' + body.slice(position + 1, position + 5) + '.'));
-	          }
-	          value += String.fromCharCode(charCode);
-	          position += 4;
-	          break;
-	        default:
-	          throw (0, _error.syntaxError)(source, position, 'Invalid character escape sequence: \\' + String.fromCharCode(code) + '.');
-	      }
-	      ++position;
-	      chunkStart = position;
-	    }
-	  }
-
-	  if (code !== 34) {
-	    // quote (")
-	    throw (0, _error.syntaxError)(source, position, 'Unterminated string.');
-	  }
-
-	  value += slice.call(body, chunkStart, position);
-	  return new Tok(STRING, start, position + 1, line, col, prev, value);
-	}
-
-	/**
-	 * Converts four hexidecimal chars to the integer that the
-	 * string represents. For example, uniCharCode('0','0','0','f')
-	 * will return 15, and uniCharCode('0','0','f','f') returns 255.
-	 *
-	 * Returns a negative number on error, if a char was invalid.
-	 *
-	 * This is implemented by noting that char2hex() returns -1 on error,
-	 * which means the result of ORing the char2hex() will also be negative.
-	 */
-	function uniCharCode(a, b, c, d) {
-	  return char2hex(a) << 12 | char2hex(b) << 8 | char2hex(c) << 4 | char2hex(d);
-	}
-
-	/**
-	 * Converts a hex character to its integer value.
-	 * '0' becomes 0, '9' becomes 9
-	 * 'A' becomes 10, 'F' becomes 15
-	 * 'a' becomes 10, 'f' becomes 15
-	 *
-	 * Returns -1 on error.
-	 */
-	function char2hex(a) {
-	  return a >= 48 && a <= 57 ? a - 48 : // 0-9
-	  a >= 65 && a <= 70 ? a - 55 : // A-F
-	  a >= 97 && a <= 102 ? a - 87 : // a-f
-	  -1;
-	}
-
-	/**
-	 * Reads an alphanumeric + underscore name from the source.
-	 *
-	 * [_A-Za-z][_0-9A-Za-z]*
-	 */
-	function readName(source, position, line, col, prev) {
-	  var body = source.body;
-	  var bodyLength = body.length;
-	  var end = position + 1;
-	  var code = 0;
-	  while (end !== bodyLength && (code = charCodeAt.call(body, end)) !== null && (code === 95 || // _
-	  code >= 48 && code <= 57 || // 0-9
-	  code >= 65 && code <= 90 || // A-Z
-	  code >= 97 && code <= 122 // a-z
-	  )) {
-	    ++end;
-	  }
-	  return new Tok(NAME, position, end, line, col, prev, slice.call(body, position, end));
-	}
-
-/***/ },
-/* 194 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.print = print;
-
-	var _visitor = __webpack_require__(195);
-
-	/**
-	 * Converts an AST into a string, using one set of reasonable
-	 * formatting rules.
-	 */
-	function print(ast) {
-	  return (0, _visitor.visit)(ast, { leave: printDocASTReducer });
-	} /**
-	   *  Copyright (c) 2015, Facebook, Inc.
-	   *  All rights reserved.
-	   *
-	   *  This source code is licensed under the BSD-style license found in the
-	   *  LICENSE file in the root directory of this source tree. An additional grant
-	   *  of patent rights can be found in the PATENTS file in the same directory.
-	   */
-
-	var printDocASTReducer = {
-	  Name: function Name(node) {
-	    return node.value;
-	  },
-	  Variable: function Variable(node) {
-	    return '$' + node.name;
-	  },
-
-	  // Document
-
-	  Document: function Document(node) {
-	    return join(node.definitions, '\n\n') + '\n';
-	  },
-
-	  OperationDefinition: function OperationDefinition(node) {
-	    var op = node.operation;
-	    var name = node.name;
-	    var varDefs = wrap('(', join(node.variableDefinitions, ', '), ')');
-	    var directives = join(node.directives, ' ');
-	    var selectionSet = node.selectionSet;
-	    // Anonymous queries with no directives or variable definitions can use
-	    // the query short form.
-	    return !name && !directives && !varDefs && op === 'query' ? selectionSet : join([op, join([name, varDefs]), directives, selectionSet], ' ');
-	  },
-
-
-	  VariableDefinition: function VariableDefinition(_ref) {
-	    var variable = _ref.variable;
-	    var type = _ref.type;
-	    var defaultValue = _ref.defaultValue;
-	    return variable + ': ' + type + wrap(' = ', defaultValue);
-	  },
-
-	  SelectionSet: function SelectionSet(_ref2) {
-	    var selections = _ref2.selections;
-	    return block(selections);
-	  },
-
-	  Field: function Field(_ref3) {
-	    var alias = _ref3.alias;
-	    var name = _ref3.name;
-	    var args = _ref3.arguments;
-	    var directives = _ref3.directives;
-	    var selectionSet = _ref3.selectionSet;
-	    return join([wrap('', alias, ': ') + name + wrap('(', join(args, ', '), ')'), join(directives, ' '), selectionSet], ' ');
-	  },
-
-	  Argument: function Argument(_ref4) {
-	    var name = _ref4.name;
-	    var value = _ref4.value;
-	    return name + ': ' + value;
-	  },
-
-	  // Fragments
-
-	  FragmentSpread: function FragmentSpread(_ref5) {
-	    var name = _ref5.name;
-	    var directives = _ref5.directives;
-	    return '...' + name + wrap(' ', join(directives, ' '));
-	  },
-
-	  InlineFragment: function InlineFragment(_ref6) {
-	    var typeCondition = _ref6.typeCondition;
-	    var directives = _ref6.directives;
-	    var selectionSet = _ref6.selectionSet;
-	    return join(['...', wrap('on ', typeCondition), join(directives, ' '), selectionSet], ' ');
-	  },
-
-	  FragmentDefinition: function FragmentDefinition(_ref7) {
-	    var name = _ref7.name;
-	    var typeCondition = _ref7.typeCondition;
-	    var directives = _ref7.directives;
-	    var selectionSet = _ref7.selectionSet;
-	    return 'fragment ' + name + ' on ' + typeCondition + ' ' + wrap('', join(directives, ' '), ' ') + selectionSet;
-	  },
-
-	  // Value
-
-	  IntValue: function IntValue(_ref8) {
-	    var value = _ref8.value;
-	    return value;
-	  },
-	  FloatValue: function FloatValue(_ref9) {
-	    var value = _ref9.value;
-	    return value;
-	  },
-	  StringValue: function StringValue(_ref10) {
-	    var value = _ref10.value;
-	    return JSON.stringify(value);
-	  },
-	  BooleanValue: function BooleanValue(_ref11) {
-	    var value = _ref11.value;
-	    return JSON.stringify(value);
-	  },
-	  EnumValue: function EnumValue(_ref12) {
-	    var value = _ref12.value;
-	    return value;
-	  },
-	  ListValue: function ListValue(_ref13) {
-	    var values = _ref13.values;
-	    return '[' + join(values, ', ') + ']';
-	  },
-	  ObjectValue: function ObjectValue(_ref14) {
-	    var fields = _ref14.fields;
-	    return '{' + join(fields, ', ') + '}';
-	  },
-	  ObjectField: function ObjectField(_ref15) {
-	    var name = _ref15.name;
-	    var value = _ref15.value;
-	    return name + ': ' + value;
-	  },
-
-	  // Directive
-
-	  Directive: function Directive(_ref16) {
-	    var name = _ref16.name;
-	    var args = _ref16.arguments;
-	    return '@' + name + wrap('(', join(args, ', '), ')');
-	  },
-
-	  // Type
-
-	  NamedType: function NamedType(_ref17) {
-	    var name = _ref17.name;
-	    return name;
-	  },
-	  ListType: function ListType(_ref18) {
-	    var type = _ref18.type;
-	    return '[' + type + ']';
-	  },
-	  NonNullType: function NonNullType(_ref19) {
-	    var type = _ref19.type;
-	    return type + '!';
-	  },
-
-	  // Type System Definitions
-
-	  SchemaDefinition: function SchemaDefinition(_ref20) {
-	    var directives = _ref20.directives;
-	    var operationTypes = _ref20.operationTypes;
-	    return join(['schema', join(directives, ' '), block(operationTypes)], ' ');
-	  },
-
-	  OperationTypeDefinition: function OperationTypeDefinition(_ref21) {
-	    var operation = _ref21.operation;
-	    var type = _ref21.type;
-	    return operation + ': ' + type;
-	  },
-
-	  ScalarTypeDefinition: function ScalarTypeDefinition(_ref22) {
-	    var name = _ref22.name;
-	    var directives = _ref22.directives;
-	    return join(['scalar', name, join(directives, ' ')], ' ');
-	  },
-
-	  ObjectTypeDefinition: function ObjectTypeDefinition(_ref23) {
-	    var name = _ref23.name;
-	    var interfaces = _ref23.interfaces;
-	    var directives = _ref23.directives;
-	    var fields = _ref23.fields;
-	    return join(['type', name, wrap('implements ', join(interfaces, ', ')), join(directives, ' '), block(fields)], ' ');
-	  },
-
-	  FieldDefinition: function FieldDefinition(_ref24) {
-	    var name = _ref24.name;
-	    var args = _ref24.arguments;
-	    var type = _ref24.type;
-	    var directives = _ref24.directives;
-	    return name + wrap('(', join(args, ', '), ')') + ': ' + type + wrap(' ', join(directives, ' '));
-	  },
-
-	  InputValueDefinition: function InputValueDefinition(_ref25) {
-	    var name = _ref25.name;
-	    var type = _ref25.type;
-	    var defaultValue = _ref25.defaultValue;
-	    var directives = _ref25.directives;
-	    return join([name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')], ' ');
-	  },
-
-	  InterfaceTypeDefinition: function InterfaceTypeDefinition(_ref26) {
-	    var name = _ref26.name;
-	    var directives = _ref26.directives;
-	    var fields = _ref26.fields;
-	    return join(['interface', name, join(directives, ' '), block(fields)], ' ');
-	  },
-
-	  UnionTypeDefinition: function UnionTypeDefinition(_ref27) {
-	    var name = _ref27.name;
-	    var directives = _ref27.directives;
-	    var types = _ref27.types;
-	    return join(['union', name, join(directives, ' '), '= ' + join(types, ' | ')], ' ');
-	  },
-
-	  EnumTypeDefinition: function EnumTypeDefinition(_ref28) {
-	    var name = _ref28.name;
-	    var directives = _ref28.directives;
-	    var values = _ref28.values;
-	    return join(['enum', name, join(directives, ' '), block(values)], ' ');
-	  },
-
-	  EnumValueDefinition: function EnumValueDefinition(_ref29) {
-	    var name = _ref29.name;
-	    var directives = _ref29.directives;
-	    return join([name, join(directives, ' ')], ' ');
-	  },
-
-	  InputObjectTypeDefinition: function InputObjectTypeDefinition(_ref30) {
-	    var name = _ref30.name;
-	    var directives = _ref30.directives;
-	    var fields = _ref30.fields;
-	    return join(['input', name, join(directives, ' '), block(fields)], ' ');
-	  },
-
-	  TypeExtensionDefinition: function TypeExtensionDefinition(_ref31) {
-	    var definition = _ref31.definition;
-	    return 'extend ' + definition;
-	  },
-
-	  DirectiveDefinition: function DirectiveDefinition(_ref32) {
-	    var name = _ref32.name;
-	    var args = _ref32.arguments;
-	    var locations = _ref32.locations;
-	    return 'directive @' + name + wrap('(', join(args, ', '), ')') + ' on ' + join(locations, ' | ');
-	  }
-	};
-
-	/**
-	 * Given maybeArray, print an empty string if it is null or empty, otherwise
-	 * print all items together separated by separator if provided
-	 */
-	function join(maybeArray, separator) {
-	  return maybeArray ? maybeArray.filter(function (x) {
-	    return x;
-	  }).join(separator || '') : '';
-	}
-
-	/**
-	 * Given array, print each item on its own line, wrapped in an
-	 * indented "{ }" block.
-	 */
-	function block(array) {
-	  return array && array.length !== 0 ? indent('{\n' + join(array, '\n')) + '\n}' : '{}';
-	}
-
-	/**
-	 * If maybeString is not null or empty, then wrap with start and end, otherwise
-	 * print an empty string.
-	 */
-	function wrap(start, maybeString, end) {
-	  return maybeString ? start + maybeString + (end || '') : '';
-	}
-
-	function indent(maybeString) {
-	  return maybeString && maybeString.replace(/\n/g, '\n  ');
-	}
-
-/***/ },
-/* 195 */
-/***/ function(module, exports) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.visit = visit;
-	exports.visitInParallel = visitInParallel;
-	exports.visitWithTypeInfo = visitWithTypeInfo;
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	var QueryDocumentKeys = exports.QueryDocumentKeys = {
-	  Name: [],
-
-	  Document: ['definitions'],
-	  OperationDefinition: ['name', 'variableDefinitions', 'directives', 'selectionSet'],
-	  VariableDefinition: ['variable', 'type', 'defaultValue'],
-	  Variable: ['name'],
-	  SelectionSet: ['selections'],
-	  Field: ['alias', 'name', 'arguments', 'directives', 'selectionSet'],
-	  Argument: ['name', 'value'],
-
-	  FragmentSpread: ['name', 'directives'],
-	  InlineFragment: ['typeCondition', 'directives', 'selectionSet'],
-	  FragmentDefinition: ['name', 'typeCondition', 'directives', 'selectionSet'],
-
-	  IntValue: [],
-	  FloatValue: [],
-	  StringValue: [],
-	  BooleanValue: [],
-	  EnumValue: [],
-	  ListValue: ['values'],
-	  ObjectValue: ['fields'],
-	  ObjectField: ['name', 'value'],
-
-	  Directive: ['name', 'arguments'],
-
-	  NamedType: ['name'],
-	  ListType: ['type'],
-	  NonNullType: ['type'],
-
-	  SchemaDefinition: ['directives', 'operationTypes'],
-	  OperationTypeDefinition: ['type'],
-
-	  ScalarTypeDefinition: ['name', 'directives'],
-	  ObjectTypeDefinition: ['name', 'interfaces', 'directives', 'fields'],
-	  FieldDefinition: ['name', 'arguments', 'type', 'directives'],
-	  InputValueDefinition: ['name', 'type', 'defaultValue', 'directives'],
-	  InterfaceTypeDefinition: ['name', 'directives', 'fields'],
-	  UnionTypeDefinition: ['name', 'directives', 'types'],
-	  EnumTypeDefinition: ['name', 'directives', 'values'],
-	  EnumValueDefinition: ['name', 'directives'],
-	  InputObjectTypeDefinition: ['name', 'directives', 'fields'],
-
-	  TypeExtensionDefinition: ['definition'],
-
-	  DirectiveDefinition: ['name', 'arguments', 'locations']
-	};
-
-	var BREAK = exports.BREAK = {};
-
-	/**
-	 * visit() will walk through an AST using a depth first traversal, calling
-	 * the visitor's enter function at each node in the traversal, and calling the
-	 * leave function after visiting that node and all of its child nodes.
-	 *
-	 * By returning different values from the enter and leave functions, the
-	 * behavior of the visitor can be altered, including skipping over a sub-tree of
-	 * the AST (by returning false), editing the AST by returning a value or null
-	 * to remove the value, or to stop the whole traversal by returning BREAK.
-	 *
-	 * When using visit() to edit an AST, the original AST will not be modified, and
-	 * a new version of the AST with the changes applied will be returned from the
-	 * visit function.
-	 *
-	 *     const editedAST = visit(ast, {
-	 *       enter(node, key, parent, path, ancestors) {
-	 *         // @return
-	 *         //   undefined: no action
-	 *         //   false: skip visiting this node
-	 *         //   visitor.BREAK: stop visiting altogether
-	 *         //   null: delete this node
-	 *         //   any value: replace this node with the returned value
-	 *       },
-	 *       leave(node, key, parent, path, ancestors) {
-	 *         // @return
-	 *         //   undefined: no action
-	 *         //   false: no action
-	 *         //   visitor.BREAK: stop visiting altogether
-	 *         //   null: delete this node
-	 *         //   any value: replace this node with the returned value
-	 *       }
-	 *     });
-	 *
-	 * Alternatively to providing enter() and leave() functions, a visitor can
-	 * instead provide functions named the same as the kinds of AST nodes, or
-	 * enter/leave visitors at a named key, leading to four permutations of
-	 * visitor API:
-	 *
-	 * 1) Named visitors triggered when entering a node a specific kind.
-	 *
-	 *     visit(ast, {
-	 *       Kind(node) {
-	 *         // enter the "Kind" node
-	 *       }
-	 *     })
-	 *
-	 * 2) Named visitors that trigger upon entering and leaving a node of
-	 *    a specific kind.
-	 *
-	 *     visit(ast, {
-	 *       Kind: {
-	 *         enter(node) {
-	 *           // enter the "Kind" node
-	 *         }
-	 *         leave(node) {
-	 *           // leave the "Kind" node
-	 *         }
-	 *       }
-	 *     })
-	 *
-	 * 3) Generic visitors that trigger upon entering and leaving any node.
-	 *
-	 *     visit(ast, {
-	 *       enter(node) {
-	 *         // enter any node
-	 *       },
-	 *       leave(node) {
-	 *         // leave any node
-	 *       }
-	 *     })
-	 *
-	 * 4) Parallel visitors for entering and leaving nodes of a specific kind.
-	 *
-	 *     visit(ast, {
-	 *       enter: {
-	 *         Kind(node) {
-	 *           // enter the "Kind" node
-	 *         }
-	 *       },
-	 *       leave: {
-	 *         Kind(node) {
-	 *           // leave the "Kind" node
-	 *         }
-	 *       }
-	 *     })
-	 */
-	function visit(root, visitor, keyMap) {
-	  var visitorKeys = keyMap || QueryDocumentKeys;
-
-	  var stack = void 0;
-	  var inArray = Array.isArray(root);
-	  var keys = [root];
-	  var index = -1;
-	  var edits = [];
-	  var parent = void 0;
-	  var path = [];
-	  var ancestors = [];
-	  var newRoot = root;
-
-	  do {
-	    index++;
-	    var isLeaving = index === keys.length;
-	    var key = void 0;
-	    var node = void 0;
-	    var isEdited = isLeaving && edits.length !== 0;
-	    if (isLeaving) {
-	      key = ancestors.length === 0 ? undefined : path.pop();
-	      node = parent;
-	      parent = ancestors.pop();
-	      if (isEdited) {
-	        if (inArray) {
-	          node = node.slice();
-	        } else {
-	          var clone = {};
-	          for (var k in node) {
-	            if (node.hasOwnProperty(k)) {
-	              clone[k] = node[k];
-	            }
-	          }
-	          node = clone;
-	        }
-	        var editOffset = 0;
-	        for (var ii = 0; ii < edits.length; ii++) {
-	          var editKey = edits[ii][0];
-	          var editValue = edits[ii][1];
-	          if (inArray) {
-	            editKey -= editOffset;
-	          }
-	          if (inArray && editValue === null) {
-	            node.splice(editKey, 1);
-	            editOffset++;
-	          } else {
-	            node[editKey] = editValue;
-	          }
-	        }
-	      }
-	      index = stack.index;
-	      keys = stack.keys;
-	      edits = stack.edits;
-	      inArray = stack.inArray;
-	      stack = stack.prev;
-	    } else {
-	      key = parent ? inArray ? index : keys[index] : undefined;
-	      node = parent ? parent[key] : newRoot;
-	      if (node === null || node === undefined) {
-	        continue;
-	      }
-	      if (parent) {
-	        path.push(key);
-	      }
-	    }
-
-	    var result = void 0;
-	    if (!Array.isArray(node)) {
-	      if (!isNode(node)) {
-	        throw new Error('Invalid AST Node: ' + JSON.stringify(node));
-	      }
-	      var visitFn = getVisitFn(visitor, node.kind, isLeaving);
-	      if (visitFn) {
-	        result = visitFn.call(visitor, node, key, parent, path, ancestors);
-
-	        if (result === BREAK) {
-	          break;
-	        }
-
-	        if (result === false) {
-	          if (!isLeaving) {
-	            path.pop();
-	            continue;
-	          }
-	        } else if (result !== undefined) {
-	          edits.push([key, result]);
-	          if (!isLeaving) {
-	            if (isNode(result)) {
-	              node = result;
-	            } else {
-	              path.pop();
-	              continue;
-	            }
-	          }
-	        }
-	      }
-	    }
-
-	    if (result === undefined && isEdited) {
-	      edits.push([key, node]);
-	    }
-
-	    if (!isLeaving) {
-	      stack = { inArray: inArray, index: index, keys: keys, edits: edits, prev: stack };
-	      inArray = Array.isArray(node);
-	      keys = inArray ? node : visitorKeys[node.kind] || [];
-	      index = -1;
-	      edits = [];
-	      if (parent) {
-	        ancestors.push(parent);
-	      }
-	      parent = node;
-	    }
-	  } while (stack !== undefined);
-
-	  if (edits.length !== 0) {
-	    newRoot = edits[edits.length - 1][1];
-	  }
-
-	  return newRoot;
-	}
-
-	function isNode(maybeNode) {
-	  return maybeNode && typeof maybeNode.kind === 'string';
-	}
-
-	/**
-	 * Creates a new visitor instance which delegates to many visitors to run in
-	 * parallel. Each visitor will be visited for each node before moving on.
-	 *
-	 * If a prior visitor edits a node, no following visitors will see that node.
-	 */
-	function visitInParallel(visitors) {
-	  var skipping = new Array(visitors.length);
-
-	  return {
-	    enter: function enter(node) {
-	      for (var i = 0; i < visitors.length; i++) {
-	        if (!skipping[i]) {
-	          var fn = getVisitFn(visitors[i], node.kind, /* isLeaving */false);
-	          if (fn) {
-	            var result = fn.apply(visitors[i], arguments);
-	            if (result === false) {
-	              skipping[i] = node;
-	            } else if (result === BREAK) {
-	              skipping[i] = BREAK;
-	            } else if (result !== undefined) {
-	              return result;
-	            }
-	          }
-	        }
-	      }
-	    },
-	    leave: function leave(node) {
-	      for (var i = 0; i < visitors.length; i++) {
-	        if (!skipping[i]) {
-	          var fn = getVisitFn(visitors[i], node.kind, /* isLeaving */true);
-	          if (fn) {
-	            var result = fn.apply(visitors[i], arguments);
-	            if (result === BREAK) {
-	              skipping[i] = BREAK;
-	            } else if (result !== undefined && result !== false) {
-	              return result;
-	            }
-	          }
-	        } else if (skipping[i] === node) {
-	          skipping[i] = null;
-	        }
-	      }
-	    }
-	  };
-	}
-
-	/**
-	 * Creates a new visitor instance which maintains a provided TypeInfo instance
-	 * along with visiting visitor.
-	 */
-	function visitWithTypeInfo(typeInfo, visitor) {
-	  return {
-	    enter: function enter(node) {
-	      typeInfo.enter(node);
-	      var fn = getVisitFn(visitor, node.kind, /* isLeaving */false);
-	      if (fn) {
-	        var result = fn.apply(visitor, arguments);
-	        if (result !== undefined) {
-	          typeInfo.leave(node);
-	          if (isNode(result)) {
-	            typeInfo.enter(result);
-	          }
-	        }
-	        return result;
-	      }
-	    },
-	    leave: function leave(node) {
-	      var fn = getVisitFn(visitor, node.kind, /* isLeaving */true);
-	      var result = void 0;
-	      if (fn) {
-	        result = fn.apply(visitor, arguments);
-	      }
-	      typeInfo.leave(node);
-	      return result;
-	    }
-	  };
-	}
-
-	/**
-	 * Given a visitor instance, if it is leaving or not, and a node kind, return
-	 * the function the visitor runtime should call.
-	 */
-	function getVisitFn(visitor, kind, isLeaving) {
-	  var kindVisitor = visitor[kind];
-	  if (kindVisitor) {
-	    if (!isLeaving && typeof kindVisitor === 'function') {
-	      // { Kind() {} }
-	      return kindVisitor;
-	    }
-	    var kindSpecificVisitor = isLeaving ? kindVisitor.leave : kindVisitor.enter;
-	    if (typeof kindSpecificVisitor === 'function') {
-	      // { Kind: { enter() {}, leave() {} } }
-	      return kindSpecificVisitor;
-	    }
-	  } else {
-	    var specificVisitor = isLeaving ? visitor.leave : visitor.enter;
-	    if (specificVisitor) {
-	      if (typeof specificVisitor === 'function') {
-	        // { enter() {}, leave() {} }
-	        return specificVisitor;
-	      }
-	      var specificKindVisitor = specificVisitor[kind];
-	      if (typeof specificKindVisitor === 'function') {
-	        // { enter: { Kind() {} }, leave: { Kind() {} } }
-	        return specificKindVisitor;
-	      }
-	    }
-	  }
-	}
-
-/***/ },
-/* 196 */
-/***/ function(module, exports) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	// Name
-
-	var NAME = exports.NAME = 'Name';
-
-	// Document
-
-	var DOCUMENT = exports.DOCUMENT = 'Document';
-	var OPERATION_DEFINITION = exports.OPERATION_DEFINITION = 'OperationDefinition';
-	var VARIABLE_DEFINITION = exports.VARIABLE_DEFINITION = 'VariableDefinition';
-	var VARIABLE = exports.VARIABLE = 'Variable';
-	var SELECTION_SET = exports.SELECTION_SET = 'SelectionSet';
-	var FIELD = exports.FIELD = 'Field';
-	var ARGUMENT = exports.ARGUMENT = 'Argument';
-
-	// Fragments
-
-	var FRAGMENT_SPREAD = exports.FRAGMENT_SPREAD = 'FragmentSpread';
-	var INLINE_FRAGMENT = exports.INLINE_FRAGMENT = 'InlineFragment';
-	var FRAGMENT_DEFINITION = exports.FRAGMENT_DEFINITION = 'FragmentDefinition';
-
-	// Values
-
-	var INT = exports.INT = 'IntValue';
-	var FLOAT = exports.FLOAT = 'FloatValue';
-	var STRING = exports.STRING = 'StringValue';
-	var BOOLEAN = exports.BOOLEAN = 'BooleanValue';
-	var ENUM = exports.ENUM = 'EnumValue';
-	var LIST = exports.LIST = 'ListValue';
-	var OBJECT = exports.OBJECT = 'ObjectValue';
-	var OBJECT_FIELD = exports.OBJECT_FIELD = 'ObjectField';
-
-	// Directives
-
-	var DIRECTIVE = exports.DIRECTIVE = 'Directive';
-
-	// Types
-
-	var NAMED_TYPE = exports.NAMED_TYPE = 'NamedType';
-	var LIST_TYPE = exports.LIST_TYPE = 'ListType';
-	var NON_NULL_TYPE = exports.NON_NULL_TYPE = 'NonNullType';
-
-	// Type System Definitions
-
-	var SCHEMA_DEFINITION = exports.SCHEMA_DEFINITION = 'SchemaDefinition';
-	var OPERATION_TYPE_DEFINITION = exports.OPERATION_TYPE_DEFINITION = 'OperationTypeDefinition';
-
-	// Type Definitions
-
-	var SCALAR_TYPE_DEFINITION = exports.SCALAR_TYPE_DEFINITION = 'ScalarTypeDefinition';
-	var OBJECT_TYPE_DEFINITION = exports.OBJECT_TYPE_DEFINITION = 'ObjectTypeDefinition';
-	var FIELD_DEFINITION = exports.FIELD_DEFINITION = 'FieldDefinition';
-	var INPUT_VALUE_DEFINITION = exports.INPUT_VALUE_DEFINITION = 'InputValueDefinition';
-	var INTERFACE_TYPE_DEFINITION = exports.INTERFACE_TYPE_DEFINITION = 'InterfaceTypeDefinition';
-	var UNION_TYPE_DEFINITION = exports.UNION_TYPE_DEFINITION = 'UnionTypeDefinition';
-	var ENUM_TYPE_DEFINITION = exports.ENUM_TYPE_DEFINITION = 'EnumTypeDefinition';
-	var ENUM_VALUE_DEFINITION = exports.ENUM_VALUE_DEFINITION = 'EnumValueDefinition';
-	var INPUT_OBJECT_TYPE_DEFINITION = exports.INPUT_OBJECT_TYPE_DEFINITION = 'InputObjectTypeDefinition';
-
-	// Type Extensions
-
-	var TYPE_EXTENSION_DEFINITION = exports.TYPE_EXTENSION_DEFINITION = 'TypeExtensionDefinition';
-
-	// Directive Definitions
-
-	var DIRECTIVE_DEFINITION = exports.DIRECTIVE_DEFINITION = 'DirectiveDefinition';
-
-/***/ },
-/* 197 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.syntaxError = syntaxError;
-
-	var _location = __webpack_require__(192);
-
-	var _GraphQLError = __webpack_require__(190);
-
-	/**
-	 * Produces a GraphQLError representing a syntax error, containing useful
-	 * descriptive information about the syntax error's position in the source.
-	 */
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function syntaxError(source, position, description) {
-	  var location = (0, _location.getLocation)(source, position);
-	  var error = new _GraphQLError.GraphQLError('Syntax Error ' + source.name + ' (' + location.line + ':' + location.column + ') ' + description + '\n\n' + highlightSourceAtLocation(source, location), undefined, source, [position]);
-	  return error;
-	}
-
-	/**
-	 * Render a helpful description of the location of the error in the GraphQL
-	 * Source document.
-	 */
-	function highlightSourceAtLocation(source, location) {
-	  var line = location.line;
-	  var prevLineNum = (line - 1).toString();
-	  var lineNum = line.toString();
-	  var nextLineNum = (line + 1).toString();
-	  var padLen = nextLineNum.length;
-	  var lines = source.body.split(/\r\n|[\n\r]/g);
-	  return (line >= 2 ? lpad(padLen, prevLineNum) + ': ' + lines[line - 2] + '\n' : '') + lpad(padLen, lineNum) + ': ' + lines[line - 1] + '\n' + Array(2 + padLen + location.column).join(' ') + '^\n' + (line < lines.length ? lpad(padLen, nextLineNum) + ': ' + lines[line] + '\n' : '');
-	}
-
-	function lpad(len, str) {
-	  return Array(len - str.length + 1).join(' ') + str;
-	}
-
-/***/ },
-/* 198 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.locatedError = locatedError;
-
-	var _GraphQLError = __webpack_require__(190);
-
-	/**
-	 * Given an arbitrary Error, presumably thrown while attempting to execute a
-	 * GraphQL operation, produce a new GraphQLError aware of the location in the
-	 * document responsible for the original Error.
-	 */
-	function locatedError(originalError, nodes, path) {
-	  // Note: this uses a brand-check to support GraphQL errors originating from
-	  // other contexts.
-	  if (originalError && originalError.locations) {
-	    return originalError;
-	  }
-
-	  var message = originalError ? originalError.message || String(originalError) : 'An unknown error occurred.';
-	  return new _GraphQLError.GraphQLError(message, nodes, undefined, undefined, path, originalError);
-	}
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-/***/ },
-/* 199 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.formatError = formatError;
-
-	var _invariant = __webpack_require__(200);
-
-	var _invariant2 = _interopRequireDefault(_invariant);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 * Given a GraphQLError, format it according to the rules described by the
-	 * Response Format, Errors section of the GraphQL Specification.
-	 */
-	function formatError(error) {
-	  (0, _invariant2.default)(error, 'Received null or undefined error.');
-	  return {
-	    message: error.message,
-	    locations: error.locations
-	  };
-	}
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-/***/ },
-/* 200 */
-/***/ function(module, exports) {
-
-	"use strict";
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.default = invariant;
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function invariant(condition, message) {
-	  if (!condition) {
-	    throw new Error(message);
-	  }
-	}
-
-/***/ },
-/* 201 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.ValidationContext = undefined;
-	exports.validate = validate;
-	exports.visitUsingRules = visitUsingRules;
-
-	var _invariant = __webpack_require__(200);
-
-	var _invariant2 = _interopRequireDefault(_invariant);
-
-	var _error = __webpack_require__(189);
-
-	var _visitor = __webpack_require__(195);
-
-	var _kinds = __webpack_require__(196);
-
-	var Kind = _interopRequireWildcard(_kinds);
-
-	var _schema = __webpack_require__(202);
-
-	var _TypeInfo = __webpack_require__(213);
-
-	var _specifiedRules = __webpack_require__(215);
-
-	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	/**
-	 * Implements the "Validation" section of the spec.
-	 *
-	 * Validation runs synchronously, returning an array of encountered errors, or
-	 * an empty array if no errors were encountered and the document is valid.
-	 *
-	 * A list of specific validation rules may be provided. If not provided, the
-	 * default list of rules defined by the GraphQL specification will be used.
-	 *
-	 * Each validation rules is a function which returns a visitor
-	 * (see the language/visitor API). Visitor methods are expected to return
-	 * GraphQLErrors, or Arrays of GraphQLErrors when invalid.
-	 */
-	function validate(schema, ast, rules) {
-	  (0, _invariant2.default)(schema, 'Must provide schema');
-	  (0, _invariant2.default)(ast, 'Must provide document');
-	  (0, _invariant2.default)(schema instanceof _schema.GraphQLSchema, 'Schema must be an instance of GraphQLSchema. Also ensure that there are ' + 'not multiple versions of GraphQL installed in your node_modules directory.');
-	  var typeInfo = new _TypeInfo.TypeInfo(schema);
-	  return visitUsingRules(schema, typeInfo, ast, rules || _specifiedRules.specifiedRules);
-	}
-
-	/**
-	 * This uses a specialized visitor which runs multiple visitors in parallel,
-	 * while maintaining the visitor skip and break API.
-	 *
-	 * @internal
-	 */
-	function visitUsingRules(schema, typeInfo, documentAST, rules) {
-	  var context = new ValidationContext(schema, documentAST, typeInfo);
-	  var visitors = rules.map(function (rule) {
-	    return rule(context);
-	  });
-	  // Visit the whole document with each instance of all provided rules.
-	  (0, _visitor.visit)(documentAST, (0, _visitor.visitWithTypeInfo)(typeInfo, (0, _visitor.visitInParallel)(visitors)));
-	  return context.getErrors();
-	}
-
-	/**
-	 * An instance of this class is passed as the "this" context to all validators,
-	 * allowing access to commonly useful contextual information from within a
-	 * validation rule.
-	 */
-	var ValidationContext = exports.ValidationContext = function () {
-	  function ValidationContext(schema, ast, typeInfo) {
-	    _classCallCheck(this, ValidationContext);
-
-	    this._schema = schema;
-	    this._ast = ast;
-	    this._typeInfo = typeInfo;
-	    this._errors = [];
-	    this._fragmentSpreads = new Map();
-	    this._recursivelyReferencedFragments = new Map();
-	    this._variableUsages = new Map();
-	    this._recursiveVariableUsages = new Map();
-	  }
-
-	  ValidationContext.prototype.reportError = function reportError(error) {
-	    this._errors.push(error);
-	  };
-
-	  ValidationContext.prototype.getErrors = function getErrors() {
-	    return this._errors;
-	  };
-
-	  ValidationContext.prototype.getSchema = function getSchema() {
-	    return this._schema;
-	  };
-
-	  ValidationContext.prototype.getDocument = function getDocument() {
-	    return this._ast;
-	  };
-
-	  ValidationContext.prototype.getFragment = function getFragment(name) {
-	    var fragments = this._fragments;
-	    if (!fragments) {
-	      this._fragments = fragments = this.getDocument().definitions.reduce(function (frags, statement) {
-	        if (statement.kind === Kind.FRAGMENT_DEFINITION) {
-	          frags[statement.name.value] = statement;
-	        }
-	        return frags;
-	      }, {});
-	    }
-	    return fragments[name];
-	  };
-
-	  ValidationContext.prototype.getFragmentSpreads = function getFragmentSpreads(node) {
-	    var spreads = this._fragmentSpreads.get(node);
-	    if (!spreads) {
-	      spreads = [];
-	      var setsToVisit = [node];
-	      while (setsToVisit.length !== 0) {
-	        var set = setsToVisit.pop();
-	        for (var i = 0; i < set.selections.length; i++) {
-	          var selection = set.selections[i];
-	          if (selection.kind === Kind.FRAGMENT_SPREAD) {
-	            spreads.push(selection);
-	          } else if (selection.selectionSet) {
-	            setsToVisit.push(selection.selectionSet);
-	          }
-	        }
-	      }
-	      this._fragmentSpreads.set(node, spreads);
-	    }
-	    return spreads;
-	  };
-
-	  ValidationContext.prototype.getRecursivelyReferencedFragments = function getRecursivelyReferencedFragments(operation) {
-	    var fragments = this._recursivelyReferencedFragments.get(operation);
-	    if (!fragments) {
-	      fragments = [];
-	      var collectedNames = Object.create(null);
-	      var nodesToVisit = [operation.selectionSet];
-	      while (nodesToVisit.length !== 0) {
-	        var _node = nodesToVisit.pop();
-	        var spreads = this.getFragmentSpreads(_node);
-	        for (var i = 0; i < spreads.length; i++) {
-	          var fragName = spreads[i].name.value;
-	          if (collectedNames[fragName] !== true) {
-	            collectedNames[fragName] = true;
-	            var fragment = this.getFragment(fragName);
-	            if (fragment) {
-	              fragments.push(fragment);
-	              nodesToVisit.push(fragment.selectionSet);
-	            }
-	          }
-	        }
-	      }
-	      this._recursivelyReferencedFragments.set(operation, fragments);
-	    }
-	    return fragments;
-	  };
-
-	  ValidationContext.prototype.getVariableUsages = function getVariableUsages(node) {
-	    var _this = this;
-
-	    var usages = this._variableUsages.get(node);
-	    if (!usages) {
-	      (function () {
-	        var newUsages = [];
-	        var typeInfo = new _TypeInfo.TypeInfo(_this._schema);
-	        (0, _visitor.visit)(node, (0, _visitor.visitWithTypeInfo)(typeInfo, {
-	          VariableDefinition: function VariableDefinition() {
-	            return false;
-	          },
-	          Variable: function Variable(variable) {
-	            newUsages.push({ node: variable, type: typeInfo.getInputType() });
-	          }
-	        }));
-	        usages = newUsages;
-	        _this._variableUsages.set(node, usages);
-	      })();
-	    }
-	    return usages;
-	  };
-
-	  ValidationContext.prototype.getRecursiveVariableUsages = function getRecursiveVariableUsages(operation) {
-	    var usages = this._recursiveVariableUsages.get(operation);
-	    if (!usages) {
-	      usages = this.getVariableUsages(operation);
-	      var fragments = this.getRecursivelyReferencedFragments(operation);
-	      for (var i = 0; i < fragments.length; i++) {
-	        Array.prototype.push.apply(usages, this.getVariableUsages(fragments[i]));
-	      }
-	      this._recursiveVariableUsages.set(operation, usages);
-	    }
-	    return usages;
-	  };
-
-	  ValidationContext.prototype.getType = function getType() {
-	    return this._typeInfo.getType();
-	  };
-
-	  ValidationContext.prototype.getParentType = function getParentType() {
-	    return this._typeInfo.getParentType();
-	  };
-
-	  ValidationContext.prototype.getInputType = function getInputType() {
-	    return this._typeInfo.getInputType();
-	  };
-
-	  ValidationContext.prototype.getFieldDef = function getFieldDef() {
-	    return this._typeInfo.getFieldDef();
-	  };
-
-	  ValidationContext.prototype.getDirective = function getDirective() {
-	    return this._typeInfo.getDirective();
-	  };
-
-	  ValidationContext.prototype.getArgument = function getArgument() {
-	    return this._typeInfo.getArgument();
-	  };
-
-	  return ValidationContext;
-	}();
-
-/***/ },
-/* 202 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.GraphQLSchema = undefined;
-
-	var _definition = __webpack_require__(203);
-
-	var _directives = __webpack_require__(206);
-
-	var _introspection = __webpack_require__(208);
-
-	var _find = __webpack_require__(211);
-
-	var _find2 = _interopRequireDefault(_find);
-
-	var _invariant = __webpack_require__(200);
-
-	var _invariant2 = _interopRequireDefault(_invariant);
-
-	var _typeComparators = __webpack_require__(212);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	/**
-	 * Schema Definition
-	 *
-	 * A Schema is created by supplying the root types of each type of operation,
-	 * query and mutation (optional). A schema definition is then supplied to the
-	 * validator and executor.
-	 *
-	 * Example:
-	 *
-	 *     const MyAppSchema = new GraphQLSchema({
-	 *       query: MyAppQueryRootType,
-	 *       mutation: MyAppMutationRootType,
-	 *     })
-	 *
-	 * Note: If an array of `directives` are provided to GraphQLSchema, that will be
-	 * the exact list of directives represented and allowed. If `directives` is not
-	 * provided then a default set of the specified directives (e.g. @include and
-	 * @skip) will be used. If you wish to provide *additional* directives to these
-	 * specified directives, you must explicitly declare them. Example:
-	 *
-	 *     const MyAppSchema = new GraphQLSchema({
-	 *       ...
-	 *       directives: specifiedDirectives.concat([ myCustomDirective ]),
-	 *     })
-	 *
-	 */
-	var GraphQLSchema = exports.GraphQLSchema = function () {
-	  function GraphQLSchema(config) {
-	    var _this = this;
-
-	    _classCallCheck(this, GraphQLSchema);
-
-	    (0, _invariant2.default)(typeof config === 'object', 'Must provide configuration object.');
-
-	    (0, _invariant2.default)(config.query instanceof _definition.GraphQLObjectType, 'Schema query must be Object Type but got: ' + String(config.query) + '.');
-	    this._queryType = config.query;
-
-	    (0, _invariant2.default)(!config.mutation || config.mutation instanceof _definition.GraphQLObjectType, 'Schema mutation must be Object Type if provided but got: ' + String(config.mutation) + '.');
-	    this._mutationType = config.mutation;
-
-	    (0, _invariant2.default)(!config.subscription || config.subscription instanceof _definition.GraphQLObjectType, 'Schema subscription must be Object Type if provided but got: ' + String(config.subscription) + '.');
-	    this._subscriptionType = config.subscription;
-
-	    (0, _invariant2.default)(!config.types || Array.isArray(config.types), 'Schema types must be Array if provided but got: ' + String(config.types) + '.');
-
-	    (0, _invariant2.default)(!config.directives || Array.isArray(config.directives) && config.directives.every(function (directive) {
-	      return directive instanceof _directives.GraphQLDirective;
-	    }), 'Schema directives must be Array<GraphQLDirective> if provided but got: ' + String(config.directives) + '.');
-	    // Provide specified directives (e.g. @include and @skip) by default.
-	    this._directives = config.directives || _directives.specifiedDirectives;
-
-	    // Build type map now to detect any errors within this schema.
-	    var initialTypes = [this.getQueryType(), this.getMutationType(), this.getSubscriptionType(), _introspection.__Schema];
-
-	    var types = config.types;
-	    if (types) {
-	      initialTypes = initialTypes.concat(types);
-	    }
-
-	    this._typeMap = initialTypes.reduce(typeMapReducer, Object.create(null));
-
-	    // Keep track of all implementations by interface name.
-	    this._implementations = Object.create(null);
-	    Object.keys(this._typeMap).forEach(function (typeName) {
-	      var type = _this._typeMap[typeName];
-	      if (type instanceof _definition.GraphQLObjectType) {
-	        type.getInterfaces().forEach(function (iface) {
-	          var impls = _this._implementations[iface.name];
-	          if (impls) {
-	            impls.push(type);
-	          } else {
-	            _this._implementations[iface.name] = [type];
-	          }
-	        });
-	      }
-	    });
-
-	    // Enforce correct interface implementations.
-	    Object.keys(this._typeMap).forEach(function (typeName) {
-	      var type = _this._typeMap[typeName];
-	      if (type instanceof _definition.GraphQLObjectType) {
-	        type.getInterfaces().forEach(function (iface) {
-	          return assertObjectImplementsInterface(_this, type, iface);
-	        });
-	      }
-	    });
-	  }
-
-	  GraphQLSchema.prototype.getQueryType = function getQueryType() {
-	    return this._queryType;
-	  };
-
-	  GraphQLSchema.prototype.getMutationType = function getMutationType() {
-	    return this._mutationType;
-	  };
-
-	  GraphQLSchema.prototype.getSubscriptionType = function getSubscriptionType() {
-	    return this._subscriptionType;
-	  };
-
-	  GraphQLSchema.prototype.getTypeMap = function getTypeMap() {
-	    return this._typeMap;
-	  };
-
-	  GraphQLSchema.prototype.getType = function getType(name) {
-	    return this.getTypeMap()[name];
-	  };
-
-	  GraphQLSchema.prototype.getPossibleTypes = function getPossibleTypes(abstractType) {
-	    if (abstractType instanceof _definition.GraphQLUnionType) {
-	      return abstractType.getTypes();
-	    }
-	    (0, _invariant2.default)(abstractType instanceof _definition.GraphQLInterfaceType);
-	    return this._implementations[abstractType.name];
-	  };
-
-	  GraphQLSchema.prototype.isPossibleType = function isPossibleType(abstractType, possibleType) {
-	    var possibleTypeMap = this._possibleTypeMap;
-	    if (!possibleTypeMap) {
-	      this._possibleTypeMap = possibleTypeMap = Object.create(null);
-	    }
-
-	    if (!possibleTypeMap[abstractType.name]) {
-	      var possibleTypes = this.getPossibleTypes(abstractType);
-	      (0, _invariant2.default)(Array.isArray(possibleTypes), 'Could not find possible implementing types for ' + abstractType.name + ' ' + 'in schema. Check that schema.types is defined and is an array of ' + 'all possible types in the schema.');
-	      possibleTypeMap[abstractType.name] = possibleTypes.reduce(function (map, type) {
-	        return map[type.name] = true, map;
-	      }, Object.create(null));
-	    }
-
-	    return Boolean(possibleTypeMap[abstractType.name][possibleType.name]);
-	  };
-
-	  GraphQLSchema.prototype.getDirectives = function getDirectives() {
-	    return this._directives;
-	  };
-
-	  GraphQLSchema.prototype.getDirective = function getDirective(name) {
-	    return (0, _find2.default)(this.getDirectives(), function (directive) {
-	      return directive.name === name;
-	    });
-	  };
-
-	  return GraphQLSchema;
-	}();
-
-	function typeMapReducer(map, type) {
-	  if (!type) {
-	    return map;
-	  }
-	  if (type instanceof _definition.GraphQLList || type instanceof _definition.GraphQLNonNull) {
-	    return typeMapReducer(map, type.ofType);
-	  }
-	  if (map[type.name]) {
-	    (0, _invariant2.default)(map[type.name] === type, 'Schema must contain unique named types but contains multiple ' + ('types named "' + type.name + '".'));
-	    return map;
-	  }
-	  map[type.name] = type;
-
-	  var reducedMap = map;
-
-	  if (type instanceof _definition.GraphQLUnionType) {
-	    reducedMap = type.getTypes().reduce(typeMapReducer, reducedMap);
-	  }
-
-	  if (type instanceof _definition.GraphQLObjectType) {
-	    reducedMap = type.getInterfaces().reduce(typeMapReducer, reducedMap);
-	  }
-
-	  if (type instanceof _definition.GraphQLObjectType || type instanceof _definition.GraphQLInterfaceType) {
-	    (function () {
-	      var fieldMap = type.getFields();
-	      Object.keys(fieldMap).forEach(function (fieldName) {
-	        var field = fieldMap[fieldName];
-
-	        if (field.args) {
-	          var fieldArgTypes = field.args.map(function (arg) {
-	            return arg.type;
-	          });
-	          reducedMap = fieldArgTypes.reduce(typeMapReducer, reducedMap);
-	        }
-	        reducedMap = typeMapReducer(reducedMap, field.type);
-	      });
-	    })();
-	  }
-
-	  if (type instanceof _definition.GraphQLInputObjectType) {
-	    (function () {
-	      var fieldMap = type.getFields();
-	      Object.keys(fieldMap).forEach(function (fieldName) {
-	        var field = fieldMap[fieldName];
-	        reducedMap = typeMapReducer(reducedMap, field.type);
-	      });
-	    })();
-	  }
-
-	  return reducedMap;
-	}
-
-	function assertObjectImplementsInterface(schema, object, iface) {
-	  var objectFieldMap = object.getFields();
-	  var ifaceFieldMap = iface.getFields();
-
-	  // Assert each interface field is implemented.
-	  Object.keys(ifaceFieldMap).forEach(function (fieldName) {
-	    var objectField = objectFieldMap[fieldName];
-	    var ifaceField = ifaceFieldMap[fieldName];
-
-	    // Assert interface field exists on object.
-	    (0, _invariant2.default)(objectField, '"' + iface.name + '" expects field "' + fieldName + '" but "' + object.name + '" ' + 'does not provide it.');
-
-	    // Assert interface field type is satisfied by object field type, by being
-	    // a valid subtype. (covariant)
-	    (0, _invariant2.default)((0, _typeComparators.isTypeSubTypeOf)(schema, objectField.type, ifaceField.type), iface.name + '.' + fieldName + ' expects type "' + String(ifaceField.type) + '" ' + 'but ' + (object.name + '.' + fieldName + ' provides type "' + String(objectField.type) + '".'));
-
-	    // Assert each interface field arg is implemented.
-	    ifaceField.args.forEach(function (ifaceArg) {
-	      var argName = ifaceArg.name;
-	      var objectArg = (0, _find2.default)(objectField.args, function (arg) {
-	        return arg.name === argName;
-	      });
-
-	      // Assert interface field arg exists on object field.
-	      (0, _invariant2.default)(objectArg, iface.name + '.' + fieldName + ' expects argument "' + argName + '" but ' + (object.name + '.' + fieldName + ' does not provide it.'));
-
-	      // Assert interface field arg type matches object field arg type.
-	      // (invariant)
-	      (0, _invariant2.default)((0, _typeComparators.isEqualType)(ifaceArg.type, objectArg.type), iface.name + '.' + fieldName + '(' + argName + ':) expects type ' + ('"' + String(ifaceArg.type) + '" but ') + (object.name + '.' + fieldName + '(' + argName + ':) provides type ') + ('"' + String(objectArg.type) + '".'));
-	    });
-
-	    // Assert additional arguments must not be required.
-	    objectField.args.forEach(function (objectArg) {
-	      var argName = objectArg.name;
-	      var ifaceArg = (0, _find2.default)(ifaceField.args, function (arg) {
-	        return arg.name === argName;
-	      });
-	      if (!ifaceArg) {
-	        (0, _invariant2.default)(!(objectArg.type instanceof _definition.GraphQLNonNull), object.name + '.' + fieldName + '(' + argName + ':) is of required type ' + ('"' + String(objectArg.type) + '" but is not also provided by the ') + ('interface ' + iface.name + '.' + fieldName + '.'));
-	      }
-	    });
-	  });
-	}
-
-/***/ },
-/* 203 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.GraphQLNonNull = exports.GraphQLList = exports.GraphQLInputObjectType = exports.GraphQLEnumType = exports.GraphQLUnionType = exports.GraphQLInterfaceType = exports.GraphQLObjectType = exports.GraphQLScalarType = undefined;
-
-	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
-
-	exports.isType = isType;
-	exports.isInputType = isInputType;
-	exports.isOutputType = isOutputType;
-	exports.isLeafType = isLeafType;
-	exports.isCompositeType = isCompositeType;
-	exports.isAbstractType = isAbstractType;
-	exports.getNullableType = getNullableType;
-	exports.getNamedType = getNamedType;
-
-	var _invariant = __webpack_require__(200);
-
-	var _invariant2 = _interopRequireDefault(_invariant);
-
-	var _isNullish = __webpack_require__(204);
-
-	var _isNullish2 = _interopRequireDefault(_isNullish);
-
-	var _kinds = __webpack_require__(196);
-
-	var _assertValidName = __webpack_require__(205);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	// Predicates
-
-	/**
-	 * These are all of the possible kinds of types.
-	 */
-	function isType(type) {
-	  return type instanceof GraphQLScalarType || type instanceof GraphQLObjectType || type instanceof GraphQLInterfaceType || type instanceof GraphQLUnionType || type instanceof GraphQLEnumType || type instanceof GraphQLInputObjectType || type instanceof GraphQLList || type instanceof GraphQLNonNull;
-	}
-
-	/**
-	 * These types may be used as input types for arguments and directives.
-	 */
-	function isInputType(type) {
-	  var namedType = getNamedType(type);
-	  return namedType instanceof GraphQLScalarType || namedType instanceof GraphQLEnumType || namedType instanceof GraphQLInputObjectType;
-	}
-
-	/**
-	 * These types may be used as output types as the result of fields.
-	 */
-	function isOutputType(type) {
-	  var namedType = getNamedType(type);
-	  return namedType instanceof GraphQLScalarType || namedType instanceof GraphQLObjectType || namedType instanceof GraphQLInterfaceType || namedType instanceof GraphQLUnionType || namedType instanceof GraphQLEnumType;
-	}
-
-	/**
-	 * These types may describe types which may be leaf values.
-	 */
-	function isLeafType(type) {
-	  var namedType = getNamedType(type);
-	  return namedType instanceof GraphQLScalarType || namedType instanceof GraphQLEnumType;
-	}
-
-	/**
-	 * These types may describe the parent context of a selection set.
-	 */
-	function isCompositeType(type) {
-	  return type instanceof GraphQLObjectType || type instanceof GraphQLInterfaceType || type instanceof GraphQLUnionType;
-	}
-
-	/**
-	 * These types may describe the parent context of a selection set.
-	 */
-	function isAbstractType(type) {
-	  return type instanceof GraphQLInterfaceType || type instanceof GraphQLUnionType;
-	}
-
-	/**
-	 * These types can all accept null as a value.
-	 */
-	function getNullableType(type) {
-	  return type instanceof GraphQLNonNull ? type.ofType : type;
-	}
-
-	/**
-	 * These named types do not include modifiers like List or NonNull.
-	 */
-	function getNamedType(type) {
-	  var unmodifiedType = type;
-	  while (unmodifiedType instanceof GraphQLList || unmodifiedType instanceof GraphQLNonNull) {
-	    unmodifiedType = unmodifiedType.ofType;
-	  }
-	  return unmodifiedType;
-	}
-
-	/**
-	 * Used while defining GraphQL types to allow for circular references in
-	 * otherwise immutable type definitions.
-	 */
-
-
-	function resolveThunk(thunk) {
-	  return typeof thunk === 'function' ? thunk() : thunk;
-	}
-
-	/**
-	 * Scalar Type Definition
-	 *
-	 * The leaf values of any request and input values to arguments are
-	 * Scalars (or Enums) and are defined with a name and a series of functions
-	 * used to parse input from ast or variables and to ensure validity.
-	 *
-	 * Example:
-	 *
-	 *     const OddType = new GraphQLScalarType({
-	 *       name: 'Odd',
-	 *       serialize(value) {
-	 *         return value % 2 === 1 ? value : null;
-	 *       }
-	 *     });
-	 *
-	 */
-
-	var GraphQLScalarType = exports.GraphQLScalarType = function () {
-	  function GraphQLScalarType(config) {
-	    _classCallCheck(this, GraphQLScalarType);
-
-	    (0, _invariant2.default)(config.name, 'Type must be named.');
-	    (0, _assertValidName.assertValidName)(config.name);
-	    this.name = config.name;
-	    this.description = config.description;
-	    (0, _invariant2.default)(typeof config.serialize === 'function', this.name + ' must provide "serialize" function. If this custom Scalar ' + 'is also used as an input type, ensure "parseValue" and "parseLiteral" ' + 'functions are also provided.');
-	    if (config.parseValue || config.parseLiteral) {
-	      (0, _invariant2.default)(typeof config.parseValue === 'function' && typeof config.parseLiteral === 'function', this.name + ' must provide both "parseValue" and "parseLiteral" ' + 'functions.');
-	    }
-	    this._scalarConfig = config;
-	  }
-
-	  // Serializes an internal value to include in a response.
-
-
-	  GraphQLScalarType.prototype.serialize = function serialize(value) {
-	    var serializer = this._scalarConfig.serialize;
-	    return serializer(value);
-	  };
-
-	  // Parses an externally provided value to use as an input.
-
-
-	  GraphQLScalarType.prototype.parseValue = function parseValue(value) {
-	    var parser = this._scalarConfig.parseValue;
-	    return parser ? parser(value) : null;
-	  };
-
-	  // Parses an externally provided literal value to use as an input.
-
-
-	  GraphQLScalarType.prototype.parseLiteral = function parseLiteral(valueAST) {
-	    var parser = this._scalarConfig.parseLiteral;
-	    return parser ? parser(valueAST) : null;
-	  };
-
-	  GraphQLScalarType.prototype.toString = function toString() {
-	    return this.name;
-	  };
-
-	  return GraphQLScalarType;
-	}();
-
-	/**
-	 * Object Type Definition
-	 *
-	 * Almost all of the GraphQL types you define will be object types. Object types
-	 * have a name, but most importantly describe their fields.
-	 *
-	 * Example:
-	 *
-	 *     const AddressType = new GraphQLObjectType({
-	 *       name: 'Address',
-	 *       fields: {
-	 *         street: { type: GraphQLString },
-	 *         number: { type: GraphQLInt },
-	 *         formatted: {
-	 *           type: GraphQLString,
-	 *           resolve(obj) {
-	 *             return obj.number + ' ' + obj.street
-	 *           }
-	 *         }
-	 *       }
-	 *     });
-	 *
-	 * When two types need to refer to each other, or a type needs to refer to
-	 * itself in a field, you can use a function expression (aka a closure or a
-	 * thunk) to supply the fields lazily.
-	 *
-	 * Example:
-	 *
-	 *     const PersonType = new GraphQLObjectType({
-	 *       name: 'Person',
-	 *       fields: () => ({
-	 *         name: { type: GraphQLString },
-	 *         bestFriend: { type: PersonType },
-	 *       })
-	 *     });
-	 *
-	 */
-	var GraphQLObjectType = exports.GraphQLObjectType = function () {
-	  function GraphQLObjectType(config) {
-	    _classCallCheck(this, GraphQLObjectType);
-
-	    (0, _invariant2.default)(config.name, 'Type must be named.');
-	    (0, _assertValidName.assertValidName)(config.name);
-	    this.name = config.name;
-	    this.description = config.description;
-	    if (config.isTypeOf) {
-	      (0, _invariant2.default)(typeof config.isTypeOf === 'function', this.name + ' must provide "isTypeOf" as a function.');
-	    }
-	    this.isTypeOf = config.isTypeOf;
-	    this._typeConfig = config;
-	  }
-
-	  GraphQLObjectType.prototype.getFields = function getFields() {
-	    return this._fields || (this._fields = defineFieldMap(this, this._typeConfig.fields));
-	  };
-
-	  GraphQLObjectType.prototype.getInterfaces = function getInterfaces() {
-	    return this._interfaces || (this._interfaces = defineInterfaces(this, this._typeConfig.interfaces));
-	  };
-
-	  GraphQLObjectType.prototype.toString = function toString() {
-	    return this.name;
-	  };
-
-	  return GraphQLObjectType;
-	}();
-
-	function defineInterfaces(type, interfacesThunk) {
-	  var interfaces = resolveThunk(interfacesThunk);
-	  if (!interfaces) {
-	    return [];
-	  }
-	  (0, _invariant2.default)(Array.isArray(interfaces), type.name + ' interfaces must be an Array or a function which returns ' + 'an Array.');
-	  interfaces.forEach(function (iface) {
-	    (0, _invariant2.default)(iface instanceof GraphQLInterfaceType, type.name + ' may only implement Interface types, it cannot ' + ('implement: ' + String(iface) + '.'));
-	    if (typeof iface.resolveType !== 'function') {
-	      (0, _invariant2.default)(typeof type.isTypeOf === 'function', 'Interface Type ' + iface.name + ' does not provide a "resolveType" ' + ('function and implementing Type ' + type.name + ' does not provide a ') + '"isTypeOf" function. There is no way to resolve this implementing ' + 'type during execution.');
-	    }
-	  });
-	  return interfaces;
-	}
-
-	function defineFieldMap(type, fieldsThunk) {
-	  var fieldMap = resolveThunk(fieldsThunk);
-	  (0, _invariant2.default)(isPlainObj(fieldMap), type.name + ' fields must be an object with field names as keys or a ' + 'function which returns such an object.');
-
-	  var fieldNames = Object.keys(fieldMap);
-	  (0, _invariant2.default)(fieldNames.length > 0, type.name + ' fields must be an object with field names as keys or a ' + 'function which returns such an object.');
-
-	  var resultFieldMap = {};
-	  fieldNames.forEach(function (fieldName) {
-	    (0, _assertValidName.assertValidName)(fieldName);
-	    var fieldConfig = fieldMap[fieldName];
-	    (0, _invariant2.default)(!fieldConfig.hasOwnProperty('isDeprecated'), type.name + '.' + fieldName + ' should provide "deprecationReason" instead ' + 'of "isDeprecated".');
-	    var field = _extends({}, fieldConfig, {
-	      isDeprecated: Boolean(fieldConfig.deprecationReason),
-	      name: fieldName
-	    });
-	    (0, _invariant2.default)(isOutputType(field.type), type.name + '.' + fieldName + ' field type must be Output Type but ' + ('got: ' + String(field.type) + '.'));
-	    var argsConfig = fieldConfig.args;
-	    if (!argsConfig) {
-	      field.args = [];
-	    } else {
-	      (0, _invariant2.default)(isPlainObj(argsConfig), type.name + '.' + fieldName + ' args must be an object with argument ' + 'names as keys.');
-	      field.args = Object.keys(argsConfig).map(function (argName) {
-	        (0, _assertValidName.assertValidName)(argName);
-	        var arg = argsConfig[argName];
-	        (0, _invariant2.default)(isInputType(arg.type), type.name + '.' + fieldName + '(' + argName + ':) argument type must be ' + ('Input Type but got: ' + String(arg.type) + '.'));
-	        return {
-	          name: argName,
-	          description: arg.description === undefined ? null : arg.description,
-	          type: arg.type,
-	          defaultValue: arg.defaultValue === undefined ? null : arg.defaultValue
-	        };
-	      });
-	    }
-	    resultFieldMap[fieldName] = field;
-	  });
-	  return resultFieldMap;
-	}
-
-	function isPlainObj(obj) {
-	  return obj && typeof obj === 'object' && !Array.isArray(obj);
-	}
-
-	/**
-	 * Interface Type Definition
-	 *
-	 * When a field can return one of a heterogeneous set of types, a Interface type
-	 * is used to describe what types are possible, what fields are in common across
-	 * all types, as well as a function to determine which type is actually used
-	 * when the field is resolved.
-	 *
-	 * Example:
-	 *
-	 *     const EntityType = new GraphQLInterfaceType({
-	 *       name: 'Entity',
-	 *       fields: {
-	 *         name: { type: GraphQLString }
-	 *       }
-	 *     });
-	 *
-	 */
-	var GraphQLInterfaceType = exports.GraphQLInterfaceType = function () {
-	  function GraphQLInterfaceType(config) {
-	    _classCallCheck(this, GraphQLInterfaceType);
-
-	    (0, _invariant2.default)(config.name, 'Type must be named.');
-	    (0, _assertValidName.assertValidName)(config.name);
-	    this.name = config.name;
-	    this.description = config.description;
-	    if (config.resolveType) {
-	      (0, _invariant2.default)(typeof config.resolveType === 'function', this.name + ' must provide "resolveType" as a function.');
-	    }
-	    this.resolveType = config.resolveType;
-	    this._typeConfig = config;
-	  }
-
-	  GraphQLInterfaceType.prototype.getFields = function getFields() {
-	    return this._fields || (this._fields = defineFieldMap(this, this._typeConfig.fields));
-	  };
-
-	  GraphQLInterfaceType.prototype.toString = function toString() {
-	    return this.name;
-	  };
-
-	  return GraphQLInterfaceType;
-	}();
-
-	/**
-	 * Union Type Definition
-	 *
-	 * When a field can return one of a heterogeneous set of types, a Union type
-	 * is used to describe what types are possible as well as providing a function
-	 * to determine which type is actually used when the field is resolved.
-	 *
-	 * Example:
-	 *
-	 *     const PetType = new GraphQLUnionType({
-	 *       name: 'Pet',
-	 *       types: [ DogType, CatType ],
-	 *       resolveType(value) {
-	 *         if (value instanceof Dog) {
-	 *           return DogType;
-	 *         }
-	 *         if (value instanceof Cat) {
-	 *           return CatType;
-	 *         }
-	 *       }
-	 *     });
-	 *
-	 */
-	var GraphQLUnionType = exports.GraphQLUnionType = function () {
-	  function GraphQLUnionType(config) {
-	    _classCallCheck(this, GraphQLUnionType);
-
-	    (0, _invariant2.default)(config.name, 'Type must be named.');
-	    (0, _assertValidName.assertValidName)(config.name);
-	    this.name = config.name;
-	    this.description = config.description;
-	    if (config.resolveType) {
-	      (0, _invariant2.default)(typeof config.resolveType === 'function', this.name + ' must provide "resolveType" as a function.');
-	    }
-	    this.resolveType = config.resolveType;
-	    this._typeConfig = config;
-	  }
-
-	  GraphQLUnionType.prototype.getTypes = function getTypes() {
-	    return this._types || (this._types = defineTypes(this, this._typeConfig.types));
-	  };
-
-	  GraphQLUnionType.prototype.toString = function toString() {
-	    return this.name;
-	  };
-
-	  return GraphQLUnionType;
-	}();
-
-	function defineTypes(unionType, typesThunk) {
-	  var types = resolveThunk(typesThunk);
-
-	  (0, _invariant2.default)(Array.isArray(types) && types.length > 0, 'Must provide Array of types or a function which returns ' + ('such an array for Union ' + unionType.name + '.'));
-	  types.forEach(function (objType) {
-	    (0, _invariant2.default)(objType instanceof GraphQLObjectType, unionType.name + ' may only contain Object types, it cannot contain: ' + (String(objType) + '.'));
-	    if (typeof unionType.resolveType !== 'function') {
-	      (0, _invariant2.default)(typeof objType.isTypeOf === 'function', 'Union type "' + unionType.name + '" does not provide a "resolveType" ' + ('function and possible type "' + objType.name + '" does not provide an ') + '"isTypeOf" function. There is no way to resolve this possible type ' + 'during execution.');
-	    }
-	  });
-
-	  return types;
-	}
-
-	/**
-	 * Enum Type Definition
-	 *
-	 * Some leaf values of requests and input values are Enums. GraphQL serializes
-	 * Enum values as strings, however internally Enums can be represented by any
-	 * kind of type, often integers.
-	 *
-	 * Example:
-	 *
-	 *     const RGBType = new GraphQLEnumType({
-	 *       name: 'RGB',
-	 *       values: {
-	 *         RED: { value: 0 },
-	 *         GREEN: { value: 1 },
-	 *         BLUE: { value: 2 }
-	 *       }
-	 *     });
-	 *
-	 * Note: If a value is not provided in a definition, the name of the enum value
-	 * will be used as its internal value.
-	 */
-	var GraphQLEnumType /* <T> */ = exports.GraphQLEnumType = function () {
-	  function GraphQLEnumType(config /* <T> */) {
-	    _classCallCheck(this, GraphQLEnumType);
-
-	    this.name = config.name;
-	    (0, _assertValidName.assertValidName)(config.name);
-	    this.description = config.description;
-	    this._values = defineEnumValues(this, config.values);
-	    this._enumConfig = config;
-	  }
-
-	  GraphQLEnumType.prototype.getValues = function getValues() {
-	    return this._values;
-	  };
-
-	  GraphQLEnumType.prototype.serialize = function serialize(value /* T */) {
-	    var enumValue = this._getValueLookup().get(value);
-	    return enumValue ? enumValue.name : null;
-	  };
-
-	  GraphQLEnumType.prototype.parseValue = function parseValue(value) /* T */{
-	    if (typeof value === 'string') {
-	      var enumValue = this._getNameLookup()[value];
-	      if (enumValue) {
-	        return enumValue.value;
-	      }
-	    }
-	  };
-
-	  GraphQLEnumType.prototype.parseLiteral = function parseLiteral(valueAST) /* T */{
-	    if (valueAST.kind === _kinds.ENUM) {
-	      var enumValue = this._getNameLookup()[valueAST.value];
-	      if (enumValue) {
-	        return enumValue.value;
-	      }
-	    }
-	  };
-
-	  GraphQLEnumType.prototype._getValueLookup = function _getValueLookup() {
-	    var _this = this;
-
-	    if (!this._valueLookup) {
-	      (function () {
-	        var lookup = new Map();
-	        _this.getValues().forEach(function (value) {
-	          lookup.set(value.value, value);
-	        });
-	        _this._valueLookup = lookup;
-	      })();
-	    }
-	    return this._valueLookup;
-	  };
-
-	  GraphQLEnumType.prototype._getNameLookup = function _getNameLookup() {
-	    var _this2 = this;
-
-	    if (!this._nameLookup) {
-	      (function () {
-	        var lookup = Object.create(null);
-	        _this2.getValues().forEach(function (value) {
-	          lookup[value.name] = value;
-	        });
-	        _this2._nameLookup = lookup;
-	      })();
-	    }
-	    return this._nameLookup;
-	  };
-
-	  GraphQLEnumType.prototype.toString = function toString() {
-	    return this.name;
-	  };
-
-	  return GraphQLEnumType;
-	}();
-
-	function defineEnumValues(type, valueMap /* <T> */
-	) {
-	  (0, _invariant2.default)(isPlainObj(valueMap), type.name + ' values must be an object with value names as keys.');
-	  var valueNames = Object.keys(valueMap);
-	  (0, _invariant2.default)(valueNames.length > 0, type.name + ' values must be an object with value names as keys.');
-	  return valueNames.map(function (valueName) {
-	    (0, _assertValidName.assertValidName)(valueName);
-	    var value = valueMap[valueName];
-	    (0, _invariant2.default)(isPlainObj(value), type.name + '.' + valueName + ' must refer to an object with a "value" key ' + ('representing an internal value but got: ' + String(value) + '.'));
-	    (0, _invariant2.default)(!value.hasOwnProperty('isDeprecated'), type.name + '.' + valueName + ' should provide "deprecationReason" instead ' + 'of "isDeprecated".');
-	    return {
-	      name: valueName,
-	      description: value.description,
-	      isDeprecated: Boolean(value.deprecationReason),
-	      deprecationReason: value.deprecationReason,
-	      value: (0, _isNullish2.default)(value.value) ? valueName : value.value
-	    };
-	  });
-	} /* <T> */
-
-
-	/**
-	 * Input Object Type Definition
-	 *
-	 * An input object defines a structured collection of fields which may be
-	 * supplied to a field argument.
-	 *
-	 * Using `NonNull` will ensure that a value must be provided by the query
-	 *
-	 * Example:
-	 *
-	 *     const GeoPoint = new GraphQLInputObjectType({
-	 *       name: 'GeoPoint',
-	 *       fields: {
-	 *         lat: { type: new GraphQLNonNull(GraphQLFloat) },
-	 *         lon: { type: new GraphQLNonNull(GraphQLFloat) },
-	 *         alt: { type: GraphQLFloat, defaultValue: 0 },
-	 *       }
-	 *     });
-	 *
-	 */
-	var GraphQLInputObjectType = exports.GraphQLInputObjectType = function () {
-	  function GraphQLInputObjectType(config) {
-	    _classCallCheck(this, GraphQLInputObjectType);
-
-	    (0, _invariant2.default)(config.name, 'Type must be named.');
-	    (0, _assertValidName.assertValidName)(config.name);
-	    this.name = config.name;
-	    this.description = config.description;
-	    this._typeConfig = config;
-	  }
-
-	  GraphQLInputObjectType.prototype.getFields = function getFields() {
-	    return this._fields || (this._fields = this._defineFieldMap());
-	  };
-
-	  GraphQLInputObjectType.prototype._defineFieldMap = function _defineFieldMap() {
-	    var _this3 = this;
-
-	    var fieldMap = resolveThunk(this._typeConfig.fields);
-	    (0, _invariant2.default)(isPlainObj(fieldMap), this.name + ' fields must be an object with field names as keys or a ' + 'function which returns such an object.');
-	    var fieldNames = Object.keys(fieldMap);
-	    (0, _invariant2.default)(fieldNames.length > 0, this.name + ' fields must be an object with field names as keys or a ' + 'function which returns such an object.');
-	    var resultFieldMap = {};
-	    fieldNames.forEach(function (fieldName) {
-	      (0, _assertValidName.assertValidName)(fieldName);
-	      var field = _extends({}, fieldMap[fieldName], {
-	        name: fieldName
-	      });
-	      (0, _invariant2.default)(isInputType(field.type), _this3.name + '.' + fieldName + ' field type must be Input Type but ' + ('got: ' + String(field.type) + '.'));
-	      resultFieldMap[fieldName] = field;
-	    });
-	    return resultFieldMap;
-	  };
-
-	  GraphQLInputObjectType.prototype.toString = function toString() {
-	    return this.name;
-	  };
-
-	  return GraphQLInputObjectType;
-	}();
-
-	/**
-	 * List Modifier
-	 *
-	 * A list is a kind of type marker, a wrapping type which points to another
-	 * type. Lists are often created within the context of defining the fields of
-	 * an object type.
-	 *
-	 * Example:
-	 *
-	 *     const PersonType = new GraphQLObjectType({
-	 *       name: 'Person',
-	 *       fields: () => ({
-	 *         parents: { type: new GraphQLList(Person) },
-	 *         children: { type: new GraphQLList(Person) },
-	 *       })
-	 *     })
-	 *
-	 */
-	var GraphQLList = exports.GraphQLList = function () {
-	  function GraphQLList(type) {
-	    _classCallCheck(this, GraphQLList);
-
-	    (0, _invariant2.default)(isType(type), 'Can only create List of a GraphQLType but got: ' + String(type) + '.');
-	    this.ofType = type;
-	  }
-
-	  GraphQLList.prototype.toString = function toString() {
-	    return '[' + String(this.ofType) + ']';
-	  };
-
-	  return GraphQLList;
-	}();
-
-	/**
-	 * Non-Null Modifier
-	 *
-	 * A non-null is a kind of type marker, a wrapping type which points to another
-	 * type. Non-null types enforce that their values are never null and can ensure
-	 * an error is raised if this ever occurs during a request. It is useful for
-	 * fields which you can make a strong guarantee on non-nullability, for example
-	 * usually the id field of a database row will never be null.
-	 *
-	 * Example:
-	 *
-	 *     const RowType = new GraphQLObjectType({
-	 *       name: 'Row',
-	 *       fields: () => ({
-	 *         id: { type: new GraphQLNonNull(GraphQLString) },
-	 *       })
-	 *     })
-	 *
-	 * Note: the enforcement of non-nullability occurs within the executor.
-	 */
-
-
-	var GraphQLNonNull = exports.GraphQLNonNull = function () {
-	  function GraphQLNonNull(type) {
-	    _classCallCheck(this, GraphQLNonNull);
-
-	    (0, _invariant2.default)(isType(type) && !(type instanceof GraphQLNonNull), 'Can only create NonNull of a Nullable GraphQLType but got: ' + (String(type) + '.'));
-	    this.ofType = type;
-	  }
-
-	  GraphQLNonNull.prototype.toString = function toString() {
-	    return this.ofType.toString() + '!';
-	  };
-
-	  return GraphQLNonNull;
-	}();
-
-/***/ },
-/* 204 */
-/***/ function(module, exports) {
-
-	"use strict";
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.default = isNullish;
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	/**
-	 * Returns true if a value is null, undefined, or NaN.
-	 */
-	function isNullish(value) {
-	  return value === null || value === undefined || value !== value;
-	}
-
-/***/ },
-/* 205 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.assertValidName = assertValidName;
-
-	var _invariant = __webpack_require__(200);
-
-	var _invariant2 = _interopRequireDefault(_invariant);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	var NAME_RX = /^[_a-zA-Z][_a-zA-Z0-9]*$/;
-
-	// Helper to assert that provided names are valid.
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function assertValidName(name) {
-	  (0, _invariant2.default)(NAME_RX.test(name), 'Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ but "' + name + '" does not.');
-	}
-
-/***/ },
-/* 206 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.specifiedDirectives = exports.GraphQLDeprecatedDirective = exports.DEFAULT_DEPRECATION_REASON = exports.GraphQLSkipDirective = exports.GraphQLIncludeDirective = exports.GraphQLDirective = exports.DirectiveLocation = undefined;
-
-	var _definition = __webpack_require__(203);
-
-	var _scalars = __webpack_require__(207);
-
-	var _invariant = __webpack_require__(200);
-
-	var _invariant2 = _interopRequireDefault(_invariant);
-
-	var _assertValidName = __webpack_require__(205);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	var DirectiveLocation = exports.DirectiveLocation = {
-	  // Operations
-	  QUERY: 'QUERY',
-	  MUTATION: 'MUTATION',
-	  SUBSCRIPTION: 'SUBSCRIPTION',
-	  FIELD: 'FIELD',
-	  FRAGMENT_DEFINITION: 'FRAGMENT_DEFINITION',
-	  FRAGMENT_SPREAD: 'FRAGMENT_SPREAD',
-	  INLINE_FRAGMENT: 'INLINE_FRAGMENT',
-	  // Schema Definitions
-	  SCHEMA: 'SCHEMA',
-	  SCALAR: 'SCALAR',
-	  OBJECT: 'OBJECT',
-	  FIELD_DEFINITION: 'FIELD_DEFINITION',
-	  ARGUMENT_DEFINITION: 'ARGUMENT_DEFINITION',
-	  INTERFACE: 'INTERFACE',
-	  UNION: 'UNION',
-	  ENUM: 'ENUM',
-	  ENUM_VALUE: 'ENUM_VALUE',
-	  INPUT_OBJECT: 'INPUT_OBJECT',
-	  INPUT_FIELD_DEFINITION: 'INPUT_FIELD_DEFINITION'
-	};
-
-	// eslint-disable-line
-
-	/**
-	 * Directives are used by the GraphQL runtime as a way of modifying execution
-	 * behavior. Type system creators will usually not create these directly.
-	 */
-	var GraphQLDirective = exports.GraphQLDirective = function GraphQLDirective(config) {
-	  _classCallCheck(this, GraphQLDirective);
-
-	  (0, _invariant2.default)(config.name, 'Directive must be named.');
-	  (0, _assertValidName.assertValidName)(config.name);
-	  (0, _invariant2.default)(Array.isArray(config.locations), 'Must provide locations for directive.');
-	  this.name = config.name;
-	  this.description = config.description;
-	  this.locations = config.locations;
-
-	  var args = config.args;
-	  if (!args) {
-	    this.args = [];
-	  } else {
-	    (0, _invariant2.default)(!Array.isArray(args), '@' + config.name + ' args must be an object with argument names as keys.');
-	    this.args = Object.keys(args).map(function (argName) {
-	      (0, _assertValidName.assertValidName)(argName);
-	      var arg = args[argName];
-	      (0, _invariant2.default)((0, _definition.isInputType)(arg.type), '@' + config.name + '(' + argName + ':) argument type must be ' + ('Input Type but got: ' + String(arg.type) + '.'));
-	      return {
-	        name: argName,
-	        description: arg.description === undefined ? null : arg.description,
-	        type: arg.type,
-	        defaultValue: arg.defaultValue === undefined ? null : arg.defaultValue
-	      };
-	    });
-	  }
-	};
-
-	/**
-	 * Used to conditionally include fields or fragments.
-	 */
-	var GraphQLIncludeDirective = exports.GraphQLIncludeDirective = new GraphQLDirective({
-	  name: 'include',
-	  description: 'Directs the executor to include this field or fragment only when ' + 'the `if` argument is true.',
-	  locations: [DirectiveLocation.FIELD, DirectiveLocation.FRAGMENT_SPREAD, DirectiveLocation.INLINE_FRAGMENT],
-	  args: {
-	    if: {
-	      type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
-	      description: 'Included when true.'
-	    }
-	  }
-	});
-
-	/**
-	 * Used to conditionally skip (exclude) fields or fragments.
-	 */
-	var GraphQLSkipDirective = exports.GraphQLSkipDirective = new GraphQLDirective({
-	  name: 'skip',
-	  description: 'Directs the executor to skip this field or fragment when the `if` ' + 'argument is true.',
-	  locations: [DirectiveLocation.FIELD, DirectiveLocation.FRAGMENT_SPREAD, DirectiveLocation.INLINE_FRAGMENT],
-	  args: {
-	    if: {
-	      type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
-	      description: 'Skipped when true.'
-	    }
-	  }
-	});
-
-	/**
-	 * Constant string used for default reason for a deprecation.
-	 */
-	var DEFAULT_DEPRECATION_REASON = exports.DEFAULT_DEPRECATION_REASON = 'No longer supported';
-
-	/**
-	 * Used to declare element of a GraphQL schema as deprecated.
-	 */
-	var GraphQLDeprecatedDirective = exports.GraphQLDeprecatedDirective = new GraphQLDirective({
-	  name: 'deprecated',
-	  description: 'Marks an element of a GraphQL schema as no longer supported.',
-	  locations: [DirectiveLocation.FIELD_DEFINITION, DirectiveLocation.ENUM_VALUE],
-	  args: {
-	    reason: {
-	      type: _scalars.GraphQLString,
-	      description: 'Explains why this element was deprecated, usually also including a ' + 'suggestion for how to access supported similar data. Formatted ' + 'in [Markdown](https://daringfireball.net/projects/markdown/).',
-	      defaultValue: DEFAULT_DEPRECATION_REASON
-	    }
-	  }
-	});
-
-	/**
-	 * The full list of specified directives.
-	 */
-	var specifiedDirectives = exports.specifiedDirectives = [GraphQLIncludeDirective, GraphQLSkipDirective, GraphQLDeprecatedDirective];
-
-/***/ },
-/* 207 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.GraphQLID = exports.GraphQLBoolean = exports.GraphQLString = exports.GraphQLFloat = exports.GraphQLInt = undefined;
-
-	var _definition = __webpack_require__(203);
-
-	var _kinds = __webpack_require__(196);
-
-	var Kind = _interopRequireWildcard(_kinds);
-
-	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-	// As per the GraphQL Spec, Integers are only treated as valid when a valid
-	// 32-bit signed integer, providing the broadest support across platforms.
-	//
-	// n.b. JavaScript's integers are safe between -(2^53 - 1) and 2^53 - 1 because
-	// they are internally represented as IEEE 754 doubles.
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	var MAX_INT = 2147483647;
-	var MIN_INT = -2147483648;
-
-	function coerceInt(value) {
-	  if (value === '') {
-	    throw new TypeError('Int cannot represent non 32-bit signed integer value: (empty string)');
-	  }
-	  var num = Number(value);
-	  if (num === num && num <= MAX_INT && num >= MIN_INT) {
-	    return (num < 0 ? Math.ceil : Math.floor)(num);
-	  }
-	  throw new TypeError('Int cannot represent non 32-bit signed integer value: ' + value);
-	}
-
-	var GraphQLInt = exports.GraphQLInt = new _definition.GraphQLScalarType({
-	  name: 'Int',
-	  description: 'The `Int` scalar type represents non-fractional signed whole numeric ' + 'values. Int can represent values between -(2^31) and 2^31 - 1. ',
-	  serialize: coerceInt,
-	  parseValue: coerceInt,
-	  parseLiteral: function parseLiteral(ast) {
-	    if (ast.kind === Kind.INT) {
-	      var num = parseInt(ast.value, 10);
-	      if (num <= MAX_INT && num >= MIN_INT) {
-	        return num;
-	      }
-	    }
-	    return null;
-	  }
-	});
-
-	function coerceFloat(value) {
-	  if (value === '') {
-	    throw new TypeError('Float cannot represent non numeric value: (empty string)');
-	  }
-	  var num = Number(value);
-	  if (num === num) {
-	    return num;
-	  }
-	  throw new TypeError('Float cannot represent non numeric value: ' + value);
-	}
-
-	var GraphQLFloat = exports.GraphQLFloat = new _definition.GraphQLScalarType({
-	  name: 'Float',
-	  description: 'The `Float` scalar type represents signed double-precision fractional ' + 'values as specified by ' + '[IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point). ',
-	  serialize: coerceFloat,
-	  parseValue: coerceFloat,
-	  parseLiteral: function parseLiteral(ast) {
-	    return ast.kind === Kind.FLOAT || ast.kind === Kind.INT ? parseFloat(ast.value) : null;
-	  }
-	});
-
-	var GraphQLString = exports.GraphQLString = new _definition.GraphQLScalarType({
-	  name: 'String',
-	  description: 'The `String` scalar type represents textual data, represented as UTF-8 ' + 'character sequences. The String type is most often used by GraphQL to ' + 'represent free-form human-readable text.',
-	  serialize: String,
-	  parseValue: String,
-	  parseLiteral: function parseLiteral(ast) {
-	    return ast.kind === Kind.STRING ? ast.value : null;
-	  }
-	});
-
-	var GraphQLBoolean = exports.GraphQLBoolean = new _definition.GraphQLScalarType({
-	  name: 'Boolean',
-	  description: 'The `Boolean` scalar type represents `true` or `false`.',
-	  serialize: Boolean,
-	  parseValue: Boolean,
-	  parseLiteral: function parseLiteral(ast) {
-	    return ast.kind === Kind.BOOLEAN ? ast.value : null;
-	  }
-	});
-
-	var GraphQLID = exports.GraphQLID = new _definition.GraphQLScalarType({
-	  name: 'ID',
-	  description: 'The `ID` scalar type represents a unique identifier, often used to ' + 'refetch an object or as key for a cache. The ID type appears in a JSON ' + 'response as a String; however, it is not intended to be human-readable. ' + 'When expected as an input type, any string (such as `"4"`) or integer ' + '(such as `4`) input value will be accepted as an ID.',
-	  serialize: String,
-	  parseValue: String,
-	  parseLiteral: function parseLiteral(ast) {
-	    return ast.kind === Kind.STRING || ast.kind === Kind.INT ? ast.value : null;
-	  }
-	});
-
-/***/ },
-/* 208 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.TypeNameMetaFieldDef = exports.TypeMetaFieldDef = exports.SchemaMetaFieldDef = exports.__TypeKind = exports.TypeKind = exports.__EnumValue = exports.__InputValue = exports.__Field = exports.__Type = exports.__DirectiveLocation = exports.__Directive = exports.__Schema = undefined;
-
-	var _isNullish = __webpack_require__(204);
-
-	var _isNullish2 = _interopRequireDefault(_isNullish);
-
-	var _astFromValue = __webpack_require__(209);
-
-	var _printer = __webpack_require__(194);
-
-	var _definition = __webpack_require__(203);
-
-	var _scalars = __webpack_require__(207);
-
-	var _directives = __webpack_require__(206);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	var __Schema = exports.__Schema = new _definition.GraphQLObjectType({
-	  name: '__Schema',
-	  description: 'A GraphQL Schema defines the capabilities of a GraphQL server. It ' + 'exposes all available types and directives on the server, as well as ' + 'the entry points for query, mutation, and subscription operations.',
-	  fields: function fields() {
-	    return {
-	      types: {
-	        description: 'A list of all types supported by this server.',
-	        type: new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__Type))),
-	        resolve: function resolve(schema) {
-	          var typeMap = schema.getTypeMap();
-	          return Object.keys(typeMap).map(function (key) {
-	            return typeMap[key];
-	          });
-	        }
-	      },
-	      queryType: {
-	        description: 'The type that query operations will be rooted at.',
-	        type: new _definition.GraphQLNonNull(__Type),
-	        resolve: function resolve(schema) {
-	          return schema.getQueryType();
-	        }
-	      },
-	      mutationType: {
-	        description: 'If this server supports mutation, the type that ' + 'mutation operations will be rooted at.',
-	        type: __Type,
-	        resolve: function resolve(schema) {
-	          return schema.getMutationType();
-	        }
-	      },
-	      subscriptionType: {
-	        description: 'If this server support subscription, the type that ' + 'subscription operations will be rooted at.',
-	        type: __Type,
-	        resolve: function resolve(schema) {
-	          return schema.getSubscriptionType();
-	        }
-	      },
-	      directives: {
-	        description: 'A list of all directives supported by this server.',
-	        type: new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__Directive))),
-	        resolve: function resolve(schema) {
-	          return schema.getDirectives();
-	        }
-	      }
-	    };
-	  }
-	});
-
-	var __Directive = exports.__Directive = new _definition.GraphQLObjectType({
-	  name: '__Directive',
-	  description: 'A Directive provides a way to describe alternate runtime execution and ' + 'type validation behavior in a GraphQL document.' + '\n\nIn some cases, you need to provide options to alter GraphQL\'s ' + 'execution behavior in ways field arguments will not suffice, such as ' + 'conditionally including or skipping a field. Directives provide this by ' + 'describing additional information to the executor.',
-	  fields: function fields() {
-	    return {
-	      name: { type: new _definition.GraphQLNonNull(_scalars.GraphQLString) },
-	      description: { type: _scalars.GraphQLString },
-	      locations: {
-	        type: new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__DirectiveLocation)))
-	      },
-	      args: {
-	        type: new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__InputValue))),
-	        resolve: function resolve(directive) {
-	          return directive.args || [];
-	        }
-	      },
-	      // NOTE: the following three fields are deprecated and are no longer part
-	      // of the GraphQL specification.
-	      onOperation: {
-	        deprecationReason: 'Use `locations`.',
-	        type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
-	        resolve: function resolve(d) {
-	          return d.locations.indexOf(_directives.DirectiveLocation.QUERY) !== -1 || d.locations.indexOf(_directives.DirectiveLocation.MUTATION) !== -1 || d.locations.indexOf(_directives.DirectiveLocation.SUBSCRIPTION) !== -1;
-	        }
-	      },
-	      onFragment: {
-	        deprecationReason: 'Use `locations`.',
-	        type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
-	        resolve: function resolve(d) {
-	          return d.locations.indexOf(_directives.DirectiveLocation.FRAGMENT_SPREAD) !== -1 || d.locations.indexOf(_directives.DirectiveLocation.INLINE_FRAGMENT) !== -1 || d.locations.indexOf(_directives.DirectiveLocation.FRAGMENT_DEFINITION) !== -1;
-	        }
-	      },
-	      onField: {
-	        deprecationReason: 'Use `locations`.',
-	        type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean),
-	        resolve: function resolve(d) {
-	          return d.locations.indexOf(_directives.DirectiveLocation.FIELD) !== -1;
-	        }
-	      }
-	    };
-	  }
-	});
-
-	var __DirectiveLocation = exports.__DirectiveLocation = new _definition.GraphQLEnumType({
-	  name: '__DirectiveLocation',
-	  description: 'A Directive can be adjacent to many parts of the GraphQL language, a ' + '__DirectiveLocation describes one such possible adjacencies.',
-	  values: {
-	    QUERY: {
-	      value: _directives.DirectiveLocation.QUERY,
-	      description: 'Location adjacent to a query operation.'
-	    },
-	    MUTATION: {
-	      value: _directives.DirectiveLocation.MUTATION,
-	      description: 'Location adjacent to a mutation operation.'
-	    },
-	    SUBSCRIPTION: {
-	      value: _directives.DirectiveLocation.SUBSCRIPTION,
-	      description: 'Location adjacent to a subscription operation.'
-	    },
-	    FIELD: {
-	      value: _directives.DirectiveLocation.FIELD,
-	      description: 'Location adjacent to a field.'
-	    },
-	    FRAGMENT_DEFINITION: {
-	      value: _directives.DirectiveLocation.FRAGMENT_DEFINITION,
-	      description: 'Location adjacent to a fragment definition.'
-	    },
-	    FRAGMENT_SPREAD: {
-	      value: _directives.DirectiveLocation.FRAGMENT_SPREAD,
-	      description: 'Location adjacent to a fragment spread.'
-	    },
-	    INLINE_FRAGMENT: {
-	      value: _directives.DirectiveLocation.INLINE_FRAGMENT,
-	      description: 'Location adjacent to an inline fragment.'
-	    },
-	    SCHEMA: {
-	      value: _directives.DirectiveLocation.SCHEMA,
-	      description: 'Location adjacent to a schema definition.'
-	    },
-	    SCALAR: {
-	      value: _directives.DirectiveLocation.SCALAR,
-	      description: 'Location adjacent to a scalar definition.'
-	    },
-	    OBJECT: {
-	      value: _directives.DirectiveLocation.OBJECT,
-	      description: 'Location adjacent to an object type definition.'
-	    },
-	    FIELD_DEFINITION: {
-	      value: _directives.DirectiveLocation.FIELD_DEFINITION,
-	      description: 'Location adjacent to a field definition.'
-	    },
-	    ARGUMENT_DEFINITION: {
-	      value: _directives.DirectiveLocation.ARGUMENT_DEFINITION,
-	      description: 'Location adjacent to an argument definition.'
-	    },
-	    INTERFACE: {
-	      value: _directives.DirectiveLocation.INTERFACE,
-	      description: 'Location adjacent to an interface definition.'
-	    },
-	    UNION: {
-	      value: _directives.DirectiveLocation.UNION,
-	      description: 'Location adjacent to a union definition.'
-	    },
-	    ENUM: {
-	      value: _directives.DirectiveLocation.ENUM,
-	      description: 'Location adjacent to an enum definition.'
-	    },
-	    ENUM_VALUE: {
-	      value: _directives.DirectiveLocation.ENUM_VALUE,
-	      description: 'Location adjacent to an enum value definition.'
-	    },
-	    INPUT_OBJECT: {
-	      value: _directives.DirectiveLocation.INPUT_OBJECT,
-	      description: 'Location adjacent to an input object type definition.'
-	    },
-	    INPUT_FIELD_DEFINITION: {
-	      value: _directives.DirectiveLocation.INPUT_FIELD_DEFINITION,
-	      description: 'Location adjacent to an input object field definition.'
-	    }
-	  }
-	});
-
-	var __Type = exports.__Type = new _definition.GraphQLObjectType({
-	  name: '__Type',
-	  description: 'The fundamental unit of any GraphQL Schema is the type. There are ' + 'many kinds of types in GraphQL as represented by the `__TypeKind` enum.' + '\n\nDepending on the kind of a type, certain fields describe ' + 'information about that type. Scalar types provide no information ' + 'beyond a name and description, while Enum types provide their values. ' + 'Object and Interface types provide the fields they describe. Abstract ' + 'types, Union and Interface, provide the Object types possible ' + 'at runtime. List and NonNull types compose other types.',
-	  fields: function fields() {
-	    return {
-	      kind: {
-	        type: new _definition.GraphQLNonNull(__TypeKind),
-	        resolve: function resolve(type) {
-	          if (type instanceof _definition.GraphQLScalarType) {
-	            return TypeKind.SCALAR;
-	          } else if (type instanceof _definition.GraphQLObjectType) {
-	            return TypeKind.OBJECT;
-	          } else if (type instanceof _definition.GraphQLInterfaceType) {
-	            return TypeKind.INTERFACE;
-	          } else if (type instanceof _definition.GraphQLUnionType) {
-	            return TypeKind.UNION;
-	          } else if (type instanceof _definition.GraphQLEnumType) {
-	            return TypeKind.ENUM;
-	          } else if (type instanceof _definition.GraphQLInputObjectType) {
-	            return TypeKind.INPUT_OBJECT;
-	          } else if (type instanceof _definition.GraphQLList) {
-	            return TypeKind.LIST;
-	          } else if (type instanceof _definition.GraphQLNonNull) {
-	            return TypeKind.NON_NULL;
-	          }
-	          throw new Error('Unknown kind of type: ' + type);
-	        }
-	      },
-	      name: { type: _scalars.GraphQLString },
-	      description: { type: _scalars.GraphQLString },
-	      fields: {
-	        type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__Field)),
-	        args: {
-	          includeDeprecated: { type: _scalars.GraphQLBoolean, defaultValue: false }
-	        },
-	        resolve: function resolve(type, _ref) {
-	          var includeDeprecated = _ref.includeDeprecated;
-
-	          if (type instanceof _definition.GraphQLObjectType || type instanceof _definition.GraphQLInterfaceType) {
-	            var _ret = function () {
-	              var fieldMap = type.getFields();
-	              var fields = Object.keys(fieldMap).map(function (fieldName) {
-	                return fieldMap[fieldName];
-	              });
-	              if (!includeDeprecated) {
-	                fields = fields.filter(function (field) {
-	                  return !field.deprecationReason;
-	                });
-	              }
-	              return {
-	                v: fields
-	              };
-	            }();
-
-	            if (typeof _ret === "object") return _ret.v;
-	          }
-	          return null;
-	        }
-	      },
-	      interfaces: {
-	        type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__Type)),
-	        resolve: function resolve(type) {
-	          if (type instanceof _definition.GraphQLObjectType) {
-	            return type.getInterfaces();
-	          }
-	        }
-	      },
-	      possibleTypes: {
-	        type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__Type)),
-	        resolve: function resolve(type, args, context, _ref2) {
-	          var schema = _ref2.schema;
-
-	          if (type instanceof _definition.GraphQLInterfaceType || type instanceof _definition.GraphQLUnionType) {
-	            return schema.getPossibleTypes(type);
-	          }
-	        }
-	      },
-	      enumValues: {
-	        type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__EnumValue)),
-	        args: {
-	          includeDeprecated: { type: _scalars.GraphQLBoolean, defaultValue: false }
-	        },
-	        resolve: function resolve(type, _ref3) {
-	          var includeDeprecated = _ref3.includeDeprecated;
-
-	          if (type instanceof _definition.GraphQLEnumType) {
-	            var values = type.getValues();
-	            if (!includeDeprecated) {
-	              values = values.filter(function (value) {
-	                return !value.deprecationReason;
-	              });
-	            }
-	            return values;
-	          }
-	        }
-	      },
-	      inputFields: {
-	        type: new _definition.GraphQLList(new _definition.GraphQLNonNull(__InputValue)),
-	        resolve: function resolve(type) {
-	          if (type instanceof _definition.GraphQLInputObjectType) {
-	            var _ret2 = function () {
-	              var fieldMap = type.getFields();
-	              return {
-	                v: Object.keys(fieldMap).map(function (fieldName) {
-	                  return fieldMap[fieldName];
-	                })
-	              };
-	            }();
-
-	            if (typeof _ret2 === "object") return _ret2.v;
-	          }
-	        }
-	      },
-	      ofType: { type: __Type }
-	    };
-	  }
-	});
-
-	var __Field = exports.__Field = new _definition.GraphQLObjectType({
-	  name: '__Field',
-	  description: 'Object and Interface types are described by a list of Fields, each of ' + 'which has a name, potentially a list of arguments, and a return type.',
-	  fields: function fields() {
-	    return {
-	      name: { type: new _definition.GraphQLNonNull(_scalars.GraphQLString) },
-	      description: { type: _scalars.GraphQLString },
-	      args: {
-	        type: new _definition.GraphQLNonNull(new _definition.GraphQLList(new _definition.GraphQLNonNull(__InputValue))),
-	        resolve: function resolve(field) {
-	          return field.args || [];
-	        }
-	      },
-	      type: { type: new _definition.GraphQLNonNull(__Type) },
-	      isDeprecated: { type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean) },
-	      deprecationReason: {
-	        type: _scalars.GraphQLString
-	      }
-	    };
-	  }
-	});
-
-	var __InputValue = exports.__InputValue = new _definition.GraphQLObjectType({
-	  name: '__InputValue',
-	  description: 'Arguments provided to Fields or Directives and the input fields of an ' + 'InputObject are represented as Input Values which describe their type ' + 'and optionally a default value.',
-	  fields: function fields() {
-	    return {
-	      name: { type: new _definition.GraphQLNonNull(_scalars.GraphQLString) },
-	      description: { type: _scalars.GraphQLString },
-	      type: { type: new _definition.GraphQLNonNull(__Type) },
-	      defaultValue: {
-	        type: _scalars.GraphQLString,
-	        description: 'A GraphQL-formatted string representing the default value for this ' + 'input value.',
-	        resolve: function resolve(inputVal) {
-	          return (0, _isNullish2.default)(inputVal.defaultValue) ? null : (0, _printer.print)((0, _astFromValue.astFromValue)(inputVal.defaultValue, inputVal.type));
-	        }
-	      }
-	    };
-	  }
-	});
-
-	var __EnumValue = exports.__EnumValue = new _definition.GraphQLObjectType({
-	  name: '__EnumValue',
-	  description: 'One possible value for a given Enum. Enum values are unique values, not ' + 'a placeholder for a string or numeric value. However an Enum value is ' + 'returned in a JSON response as a string.',
-	  fields: function fields() {
-	    return {
-	      name: { type: new _definition.GraphQLNonNull(_scalars.GraphQLString) },
-	      description: { type: _scalars.GraphQLString },
-	      isDeprecated: { type: new _definition.GraphQLNonNull(_scalars.GraphQLBoolean) },
-	      deprecationReason: {
-	        type: _scalars.GraphQLString
-	      }
-	    };
-	  }
-	});
-
-	var TypeKind = exports.TypeKind = {
-	  SCALAR: 'SCALAR',
-	  OBJECT: 'OBJECT',
-	  INTERFACE: 'INTERFACE',
-	  UNION: 'UNION',
-	  ENUM: 'ENUM',
-	  INPUT_OBJECT: 'INPUT_OBJECT',
-	  LIST: 'LIST',
-	  NON_NULL: 'NON_NULL'
-	};
-
-	var __TypeKind = exports.__TypeKind = new _definition.GraphQLEnumType({
-	  name: '__TypeKind',
-	  description: 'An enum describing what kind of type a given `__Type` is.',
-	  values: {
-	    SCALAR: {
-	      value: TypeKind.SCALAR,
-	      description: 'Indicates this type is a scalar.'
-	    },
-	    OBJECT: {
-	      value: TypeKind.OBJECT,
-	      description: 'Indicates this type is an object. ' + '`fields` and `interfaces` are valid fields.'
-	    },
-	    INTERFACE: {
-	      value: TypeKind.INTERFACE,
-	      description: 'Indicates this type is an interface. ' + '`fields` and `possibleTypes` are valid fields.'
-	    },
-	    UNION: {
-	      value: TypeKind.UNION,
-	      description: 'Indicates this type is a union. ' + '`possibleTypes` is a valid field.'
-	    },
-	    ENUM: {
-	      value: TypeKind.ENUM,
-	      description: 'Indicates this type is an enum. ' + '`enumValues` is a valid field.'
-	    },
-	    INPUT_OBJECT: {
-	      value: TypeKind.INPUT_OBJECT,
-	      description: 'Indicates this type is an input object. ' + '`inputFields` is a valid field.'
-	    },
-	    LIST: {
-	      value: TypeKind.LIST,
-	      description: 'Indicates this type is a list. ' + '`ofType` is a valid field.'
-	    },
-	    NON_NULL: {
-	      value: TypeKind.NON_NULL,
-	      description: 'Indicates this type is a non-null. ' + '`ofType` is a valid field.'
-	    }
-	  }
-	});
-
-	/**
-	 * Note that these are GraphQLFieldDefinition and not GraphQLFieldConfig,
-	 * so the format for args is different.
-	 */
-
-	var SchemaMetaFieldDef = exports.SchemaMetaFieldDef = {
-	  name: '__schema',
-	  type: new _definition.GraphQLNonNull(__Schema),
-	  description: 'Access the current type schema of this server.',
-	  args: [],
-	  resolve: function resolve(source, args, context, _ref4) {
-	    var schema = _ref4.schema;
-	    return schema;
-	  }
-	};
-
-	var TypeMetaFieldDef = exports.TypeMetaFieldDef = {
-	  name: '__type',
-	  type: __Type,
-	  description: 'Request the type information of a single type.',
-	  args: [{ name: 'name', type: new _definition.GraphQLNonNull(_scalars.GraphQLString) }],
-	  resolve: function resolve(source, _ref5, context, _ref6) {
-	    var name = _ref5.name;
-	    var schema = _ref6.schema;
-	    return schema.getType(name);
-	  }
-	};
-
-	var TypeNameMetaFieldDef = exports.TypeNameMetaFieldDef = {
-	  name: '__typename',
-	  type: new _definition.GraphQLNonNull(_scalars.GraphQLString),
-	  description: 'The name of the current Object type at runtime.',
-	  args: [],
-	  resolve: function resolve(source, args, context, _ref7) {
-	    var parentType = _ref7.parentType;
-	    return parentType.name;
-	  }
-	};
-
-/***/ },
-/* 209 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.astFromValue = astFromValue;
-
-	var _iterall = __webpack_require__(210);
-
-	var _invariant = __webpack_require__(200);
-
-	var _invariant2 = _interopRequireDefault(_invariant);
-
-	var _isNullish = __webpack_require__(204);
-
-	var _isNullish2 = _interopRequireDefault(_isNullish);
-
-	var _kinds = __webpack_require__(196);
-
-	var _definition = __webpack_require__(203);
-
-	var _scalars = __webpack_require__(207);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 * Produces a GraphQL Value AST given a JavaScript value.
-	 *
-	 * A GraphQL type must be provided, which will be used to interpret different
-	 * JavaScript values.
-	 *
-	 * | JSON Value    | GraphQL Value        |
-	 * | ------------- | -------------------- |
-	 * | Object        | Input Object         |
-	 * | Array         | List                 |
-	 * | Boolean       | Boolean              |
-	 * | String        | String / Enum Value  |
-	 * | Number        | Int / Float          |
-	 * | Mixed         | Enum Value           |
-	 *
-	 */
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function astFromValue(value, type) {
-	  // Ensure flow knows that we treat function params as const.
-	  var _value = value;
-
-	  if (type instanceof _definition.GraphQLNonNull) {
-	    // Note: we're not checking that the result is non-null.
-	    // This function is not responsible for validating the input value.
-	    return astFromValue(_value, type.ofType);
-	  }
-
-	  if ((0, _isNullish2.default)(_value)) {
-	    return null;
-	  }
-
-	  // Convert JavaScript array to GraphQL list. If the GraphQLType is a list, but
-	  // the value is not an array, convert the value using the list's item type.
-	  if (type instanceof _definition.GraphQLList) {
-	    var _ret = function () {
-	      var itemType = type.ofType;
-	      if ((0, _iterall.isCollection)(_value)) {
-	        var _ret2 = function () {
-	          var valuesASTs = [];
-	          (0, _iterall.forEach)(_value, function (item) {
-	            var itemAST = astFromValue(item, itemType);
-	            if (itemAST) {
-	              valuesASTs.push(itemAST);
-	            }
-	          });
-	          return {
-	            v: {
-	              v: { kind: _kinds.LIST, values: valuesASTs }
-	            }
-	          };
-	        }();
-
-	        if (typeof _ret2 === "object") return _ret2.v;
-	      }
-	      return {
-	        v: astFromValue(_value, itemType)
-	      };
-	    }();
-
-	    if (typeof _ret === "object") return _ret.v;
-	  }
-
-	  // Populate the fields of the input object by creating ASTs from each value
-	  // in the JavaScript object according to the fields in the input type.
-	  if (type instanceof _definition.GraphQLInputObjectType) {
-	    var _ret3 = function () {
-	      if (_value === null || typeof _value !== 'object') {
-	        return {
-	          v: null
-	        };
-	      }
-	      var fields = type.getFields();
-	      var fieldASTs = [];
-	      Object.keys(fields).forEach(function (fieldName) {
-	        var fieldType = fields[fieldName].type;
-	        var fieldValue = astFromValue(_value[fieldName], fieldType);
-	        if (fieldValue) {
-	          fieldASTs.push({
-	            kind: _kinds.OBJECT_FIELD,
-	            name: { kind: _kinds.NAME, value: fieldName },
-	            value: fieldValue
-	          });
-	        }
-	      });
-	      return {
-	        v: { kind: _kinds.OBJECT, fields: fieldASTs }
-	      };
-	    }();
-
-	    if (typeof _ret3 === "object") return _ret3.v;
-	  }
-
-	  (0, _invariant2.default)(type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType, 'Must provide Input Type, cannot use: ' + String(type));
-
-	  // Since value is an internally represented value, it must be serialized
-	  // to an externally represented value before converting into an AST.
-	  var serialized = type.serialize(_value);
-	  if ((0, _isNullish2.default)(serialized)) {
-	    return null;
-	  }
-
-	  // Others serialize based on their corresponding JavaScript scalar types.
-	  if (typeof serialized === 'boolean') {
-	    return { kind: _kinds.BOOLEAN, value: serialized };
-	  }
-
-	  // JavaScript numbers can be Int or Float values.
-	  if (typeof serialized === 'number') {
-	    var stringNum = String(serialized);
-	    return (/^[0-9]+$/.test(stringNum) ? { kind: _kinds.INT, value: stringNum } : { kind: _kinds.FLOAT, value: stringNum }
-	    );
-	  }
-
-	  if (typeof serialized === 'string') {
-	    // Enum types use Enum literals.
-	    if (type instanceof _definition.GraphQLEnumType) {
-	      return { kind: _kinds.ENUM, value: serialized };
-	    }
-
-	    // ID types can use Int literals.
-	    if (type === _scalars.GraphQLID && /^[0-9]+$/.test(serialized)) {
-	      return { kind: _kinds.INT, value: serialized };
-	    }
-
-	    // Use JSON stringify, which uses the same string encoding as GraphQL,
-	    // then remove the quotes.
-	    return {
-	      kind: _kinds.STRING,
-	      value: JSON.stringify(serialized).slice(1, -1)
-	    };
-	  }
-
-	  throw new TypeError('Cannot convert value to AST: ' + String(serialized));
-	}
-
-/***/ },
-/* 210 */
-/***/ function(module, exports) {
-
-	/**
-	 * Copyright (c) 2016, Lee Byron
-	 * All rights reserved.
-	 *
-	 * This source code is licensed under the MIT license found in the
-	 * LICENSE file in the root directory of this source tree.
-	 *
-	 * @ignore
-	 */
-
-	/**
-	 * [Iterator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterator)
-	 * is a *protocol* which describes a standard way to produce a sequence of
-	 * values, typically the values of the Iterable represented by this Iterator.
-	 *
-	 * While described by the [ES2015 version of JavaScript](http://www.ecma-international.org/ecma-262/6.0/#sec-iterator-interface)
-	 * it can be utilized by any version of JavaScript.
-	 *
-	 * @typedef {Object} Iterator
-	 * @template T The type of each iterated value
-	 * @property {function (): { value: T, done: boolean }} next
-	 *   A method which produces either the next value in a sequence or a result
-	 *   where the `done` property is `true` indicating the end of the Iterator.
-	 */
-
-	/**
-	 * [Iterable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterable)
-	 * is a *protocol* which when implemented allows a JavaScript object to define
-	 * their iteration behavior, such as what values are looped over in a `for..of`
-	 * loop or `iterall`'s `forEach` function. Many [built-in types](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#Builtin_iterables)
-	 * implement the Iterable protocol, including `Array` and `Map`.
-	 *
-	 * While described by the [ES2015 version of JavaScript](http://www.ecma-international.org/ecma-262/6.0/#sec-iterable-interface)
-	 * it can be utilized by any version of JavaScript.
-	 *
-	 * @typedef {Object} Iterable
-	 * @template T The type of each iterated value
-	 * @property {function (): Iterator<T>} Symbol.iterator
-	 *   A method which produces an Iterator for this Iterable.
-	 */
-
-	// In ES2015 (or a polyfilled) environment, this will be Symbol.iterator
-	var SYMBOL_ITERATOR = typeof Symbol === 'function' && Symbol.iterator
-
-	/**
-	 * A property name to be used as the name of an Iterable's method responsible
-	 * for producing an Iterator, referred to as `@@iterator`. Typically represents
-	 * the value `Symbol.iterator` but falls back to the string `"@@iterator"` when
-	 * `Symbol.iterator` is not defined.
-	 *
-	 * Use `$$iterator` for defining new Iterables instead of `Symbol.iterator`,
-	 * but do not use it for accessing existing Iterables, instead use
-	 * `getIterator()` or `isIterable()`.
-	 *
-	 * @example
-	 *
-	 * var $$iterator = require('iterall').$$iterator
-	 *
-	 * function Counter (to) {
-	 *   this.to = to
-	 * }
-	 *
-	 * Counter.prototype[$$iterator] = function () {
-	 *   return {
-	 *     to: this.to,
-	 *     num: 0,
-	 *     next () {
-	 *       if (this.num >= this.to) {
-	 *         return { value: undefined, done: true }
-	 *       }
-	 *       return { value: this.num++, done: false }
-	 *     }
-	 *   }
-	 * }
-	 *
-	 * var counter = new Counter(3)
-	 * for (var number of counter) {
-	 *   console.log(number) // 0 ... 1 ... 2
-	 * }
-	 *
-	 * @type {Symbol|string}
-	 */
-	var $$iterator = SYMBOL_ITERATOR || '@@iterator'
-	exports.$$iterator = $$iterator
-
-	/**
-	 * Returns true if the provided object implements the Iterator protocol via
-	 * either implementing a `Symbol.iterator` or `"@@iterator"` method.
-	 *
-	 * @example
-	 *
-	 * var isIterable = require('iterall').isIterable
-	 * isIterable([ 1, 2, 3 ]) // true
-	 * isIterable('ABC') // true
-	 * isIterable({ length: 1, 0: 'Alpha' }) // false
-	 * isIterable({ key: 'value' }) // false
-	 * isIterable(new Map()) // true
-	 *
-	 * @param obj
-	 *   A value which might implement the Iterable protocol.
-	 * @return {boolean} true if Iterable.
-	 */
-	function isIterable (obj) {
-	  return !!getIteratorMethod(obj)
-	}
-	exports.isIterable = isIterable
-
-	/**
-	 * Returns true if the provided object implements the Array-like protocol via
-	 * defining a positive-integer `length` property.
-	 *
-	 * @example
-	 *
-	 * var isArrayLike = require('iterall').isArrayLike
-	 * isArrayLike([ 1, 2, 3 ]) // true
-	 * isArrayLike('ABC') // true
-	 * isArrayLike({ length: 1, 0: 'Alpha' }) // true
-	 * isArrayLike({ key: 'value' }) // false
-	 * isArrayLike(new Map()) // false
-	 *
-	 * @param obj
-	 *   A value which might implement the Array-like protocol.
-	 * @return {boolean} true if Array-like.
-	 */
-	function isArrayLike (obj) {
-	  var length = obj != null && obj.length
-	  return typeof length === 'number' && length >= 0 && length % 1 === 0
-	}
-	exports.isArrayLike = isArrayLike
-
-	/**
-	 * Returns true if the provided object is an Object (i.e. not a string literal)
-	 * and is either Iterable or Array-like.
-	 *
-	 * This may be used in place of [Array.isArray()][isArray] to determine if an
-	 * object should be iterated-over. It always excludes string literals and
-	 * includes Arrays (regardless of if it is Iterable). It also includes other
-	 * Array-like objects such as NodeList, TypedArray, and Buffer.
-	 *
-	 * @example
-	 *
-	 * var isCollection = require('iterall').isCollection
-	 * isCollection([ 1, 2, 3 ]) // true
-	 * isCollection('ABC') // false
-	 * isCollection({ length: 1, 0: 'Alpha' }) // true
-	 * isCollection({ key: 'value' }) // false
-	 * isCollection(new Map()) // true
-	 *
-	 * @example
-	 *
-	 * var forEach = require('iterall').forEach
-	 * if (isCollection(obj)) {
-	 *   forEach(obj, function (value) {
-	 *     console.log(value)
-	 *   })
-	 * }
-	 *
-	 * @param obj
-	 *   An Object value which might implement the Iterable or Array-like protocols.
-	 * @return {boolean} true if Iterable or Array-like Object.
-	 */
-	function isCollection (obj) {
-	  return Object(obj) === obj && (isArrayLike(obj) || isIterable(obj))
-	}
-	exports.isCollection = isCollection
-
-	/**
-	 * If the provided object implements the Iterator protocol, its Iterator object
-	 * is returned. Otherwise returns undefined.
-	 *
-	 * @example
-	 *
-	 * var getIterator = require('iterall').getIterator
-	 * var iterator = getIterator([ 1, 2, 3 ])
-	 * iterator.next() // { value: 1, done: false }
-	 * iterator.next() // { value: 2, done: false }
-	 * iterator.next() // { value: 3, done: false }
-	 * iterator.next() // { value: undefined, done: true }
-	 *
-	 * @template T the type of each iterated value
-	 * @param {Iterable<T>} iterable
-	 *   An Iterable object which is the source of an Iterator.
-	 * @return {Iterator<T>} new Iterator instance.
-	 */
-	function getIterator (iterable) {
-	  var method = getIteratorMethod(iterable)
-	  if (method) {
-	    return method.call(iterable)
-	  }
-	}
-	exports.getIterator = getIterator
-
-	/**
-	 * If the provided object implements the Iterator protocol, the method
-	 * responsible for producing its Iterator object is returned.
-	 *
-	 * This is used in rare cases for performance tuning. This method must be called
-	 * with obj as the contextual this-argument.
-	 *
-	 * @example
-	 *
-	 * var getIteratorMethod = require('iterall').getIteratorMethod
-	 * var myArray = [ 1, 2, 3 ]
-	 * var method = getIteratorMethod(myArray)
-	 * if (method) {
-	 *   var iterator = method.call(myArray)
-	 * }
-	 *
-	 * @template T the type of each iterated value
-	 * @param {Iterable<T>} iterable
-	 *   An Iterable object which defines an `@@iterator` method.
-	 * @return {function(): Iterator<T>} `@@iterator` method.
-	 */
-	function getIteratorMethod (iterable) {
-	  if (iterable != null) {
-	    var method = SYMBOL_ITERATOR && iterable[SYMBOL_ITERATOR] || iterable['@@iterator']
-	    if (typeof method === 'function') {
-	      return method
-	    }
-	  }
-	}
-	exports.getIteratorMethod = getIteratorMethod
-
-	/**
-	 * Given an object which either implements the Iterable protocol or is
-	 * Array-like, iterate over it, calling the `callback` at each iteration.
-	 *
-	 * Use `forEach` where you would expect to use a `for ... of` loop in ES6.
-	 * However `forEach` adheres to the behavior of [Array#forEach][] described in
-	 * the ECMAScript specification, skipping over "holes" in Array-likes. It will
-	 * also delegate to a `forEach` method on `collection` if one is defined,
-	 * ensuring native performance for `Arrays`.
-	 *
-	 * Similar to [Array#forEach][], the `callback` function accepts three
-	 * arguments, and is provided with `thisArg` as the calling context.
-	 *
-	 * Note: providing an infinite Iterator to forEach will produce an error.
-	 *
-	 * [Array#forEach]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach
-	 *
-	 * @example
-	 *
-	 * var forEach = require('iterall').forEach
-	 *
-	 * forEach(myIterable, function (value, index, iterable) {
-	 *   console.log(value, index, iterable === myIterable)
-	 * })
-	 *
-	 * @example
-	 *
-	 * // ES6:
-	 * for (let value of myIterable) {
-	 *   console.log(value)
-	 * }
-	 *
-	 * // Any JavaScript environment:
-	 * forEach(myIterable, function (value) {
-	 *   console.log(value)
-	 * })
-	 *
-	 * @template T the type of each iterated value
-	 * @param {Iterable<T>|{ length: number }} collection
-	 *   The Iterable or array to iterate over.
-	 * @param {function(T, number, object)} callback
-	 *   Function to execute for each iteration, taking up to three arguments
-	 * @param [thisArg]
-	 *   Optional. Value to use as `this` when executing `callback`.
-	 */
-	function forEach (collection, callback, thisArg) {
-	  if (collection != null) {
-	    if (typeof collection.forEach === 'function') {
-	      return collection.forEach(callback, thisArg)
-	    }
-	    var i = 0
-	    var iterator = getIterator(collection)
-	    if (iterator) {
-	      var step
-	      while (!(step = iterator.next()).done) {
-	        callback.call(thisArg, step.value, i++, collection)
-	        // Infinite Iterators could cause forEach to run forever.
-	        // After a very large number of iterations, produce an error.
-	        /* istanbul ignore if */
-	        if (i > 9999999) {
-	          throw new TypeError('Near-infinite iteration.')
-	        }
-	      }
-	    } else if (isArrayLike(collection)) {
-	      for (; i < collection.length; i++) {
-	        if (collection.hasOwnProperty(i)) {
-	          callback.call(thisArg, collection[i], i, collection)
-	        }
-	      }
-	    }
-	  }
-	}
-	exports.forEach = forEach
-
-	/**
-	 * Similar to `getIterator()`, this method returns a new Iterator given an
-	 * Iterable. However it will also create an Iterator for a non-Iterable
-	 * Array-like collection, such as Array in a non-ES2015 environment.
-	 *
-	 * `createIterator` is complimentary to `forEach`, but allows a "pull"-based
-	 * iteration as opposed to `forEach`'s "push"-based iteration.
-	 *
-	 * `createIterator` produces an Iterator for Array-likes with the same behavior
-	 * as ArrayIteratorPrototype described in the ECMAScript specification, and
-	 * does *not* skip over "holes".
-	 *
-	 * @example
-	 *
-	 * var createIterator = require('iterall').createIterator
-	 *
-	 * var myArraylike = { length: 3, 0: 'Alpha', 1: 'Bravo', 2: 'Charlie' }
-	 * var iterator = createIterator(myArraylike)
-	 * iterator.next() // { value: 'Alpha', done: false }
-	 * iterator.next() // { value: 'Bravo', done: false }
-	 * iterator.next() // { value: 'Charlie', done: false }
-	 * iterator.next() // { value: undefined, done: true }
-	 *
-	 * @template T the type of each iterated value
-	 * @param {Iterable<T>|{ length: number }} collection
-	 *   An Iterable or Array-like object to produce an Iterator.
-	 * @return {Iterator<T>} new Iterator instance.
-	 */
-	function createIterator (collection) {
-	  if (collection != null) {
-	    var iterator = getIterator(collection)
-	    if (iterator) {
-	      return iterator
-	    }
-	    if (isArrayLike(collection)) {
-	      return new ArrayLikeIterator(collection)
-	    }
-	  }
-	}
-	exports.createIterator = createIterator
-
-	// When the object provided to `createIterator` is not Iterable but is
-	// Array-like, this simple Iterator is created.
-	function ArrayLikeIterator (obj) {
-	  this._o = obj
-	  this._i = 0
-	}
-
-	// Note: all Iterators are themselves Iterable.
-	ArrayLikeIterator.prototype[$$iterator] = function () {
-	  return this
-	}
-
-	// A simple state-machine determines the IteratorResult returned, yielding
-	// each value in the Array-like object in order of their indicies.
-	ArrayLikeIterator.prototype.next = function () {
-	  if (this._o === void 0 || this._i >= this._o.length) {
-	    this._o = void 0
-	    return { value: void 0, done: true }
-	  }
-	  return { value: this._o[this._i++], done: false }
-	}
-
-
-/***/ },
-/* 211 */
-/***/ function(module, exports) {
-
-	"use strict";
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.default = find;
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function find(list, predicate) {
-	  for (var i = 0; i < list.length; i++) {
-	    if (predicate(list[i])) {
-	      return list[i];
-	    }
-	  }
-	}
-
-/***/ },
-/* 212 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.isEqualType = isEqualType;
-	exports.isTypeSubTypeOf = isTypeSubTypeOf;
-	exports.doTypesOverlap = doTypesOverlap;
-
-	var _definition = __webpack_require__(203);
-
-	/**
-	 * Provided two types, return true if the types are equal (invariant).
-	 */
-	function isEqualType(typeA, typeB) {
-	  // Equivalent types are equal.
-	  if (typeA === typeB) {
-	    return true;
-	  }
-
-	  // If either type is non-null, the other must also be non-null.
-	  if (typeA instanceof _definition.GraphQLNonNull && typeB instanceof _definition.GraphQLNonNull) {
-	    return isEqualType(typeA.ofType, typeB.ofType);
-	  }
-
-	  // If either type is a list, the other must also be a list.
-	  if (typeA instanceof _definition.GraphQLList && typeB instanceof _definition.GraphQLList) {
-	    return isEqualType(typeA.ofType, typeB.ofType);
-	  }
-
-	  // Otherwise the types are not equal.
-	  return false;
-	}
-
-	/**
-	 * Provided a type and a super type, return true if the first type is either
-	 * equal or a subset of the second super type (covariant).
-	 */
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function isTypeSubTypeOf(schema, maybeSubType, superType) {
-	  // Equivalent type is a valid subtype
-	  if (maybeSubType === superType) {
-	    return true;
-	  }
-
-	  // If superType is non-null, maybeSubType must also be non-null.
-	  if (superType instanceof _definition.GraphQLNonNull) {
-	    if (maybeSubType instanceof _definition.GraphQLNonNull) {
-	      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
-	    }
-	    return false;
-	  } else if (maybeSubType instanceof _definition.GraphQLNonNull) {
-	    // If superType is nullable, maybeSubType may be non-null or nullable.
-	    return isTypeSubTypeOf(schema, maybeSubType.ofType, superType);
-	  }
-
-	  // If superType type is a list, maybeSubType type must also be a list.
-	  if (superType instanceof _definition.GraphQLList) {
-	    if (maybeSubType instanceof _definition.GraphQLList) {
-	      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
-	    }
-	    return false;
-	  } else if (maybeSubType instanceof _definition.GraphQLList) {
-	    // If superType is not a list, maybeSubType must also be not a list.
-	    return false;
-	  }
-
-	  // If superType type is an abstract type, maybeSubType type may be a currently
-	  // possible object type.
-	  if ((0, _definition.isAbstractType)(superType) && maybeSubType instanceof _definition.GraphQLObjectType && schema.isPossibleType(superType, maybeSubType)) {
-	    return true;
-	  }
-
-	  // Otherwise, the child type is not a valid subtype of the parent type.
-	  return false;
-	}
-
-	/**
-	 * Provided two composite types, determine if they "overlap". Two composite
-	 * types overlap when the Sets of possible concrete types for each intersect.
-	 *
-	 * This is often used to determine if a fragment of a given type could possibly
-	 * be visited in a context of another type.
-	 *
-	 * This function is commutative.
-	 */
-	function doTypesOverlap(schema, typeA, typeB) {
-	  // So flow is aware this is constant
-	  var _typeB = typeB;
-
-	  // Equivalent types overlap
-	  if (typeA === _typeB) {
-	    return true;
-	  }
-
-	  if (typeA instanceof _definition.GraphQLInterfaceType || typeA instanceof _definition.GraphQLUnionType) {
-	    if (_typeB instanceof _definition.GraphQLInterfaceType || _typeB instanceof _definition.GraphQLUnionType) {
-	      // If both types are abstract, then determine if there is any intersection
-	      // between possible concrete types of each.
-	      return schema.getPossibleTypes(typeA).some(function (type) {
-	        return schema.isPossibleType(_typeB, type);
-	      });
-	    }
-	    // Determine if the latter type is a possible concrete type of the former.
-	    return schema.isPossibleType(typeA, _typeB);
-	  }
-
-	  if (_typeB instanceof _definition.GraphQLInterfaceType || _typeB instanceof _definition.GraphQLUnionType) {
-	    // Determine if the former type is a possible concrete type of the latter.
-	    return schema.isPossibleType(_typeB, typeA);
-	  }
-
-	  // Otherwise the types do not overlap.
-	  return false;
-	}
-
-/***/ },
-/* 213 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.TypeInfo = undefined;
-
-	var _kinds = __webpack_require__(196);
-
-	var Kind = _interopRequireWildcard(_kinds);
-
-	var _definition = __webpack_require__(203);
-
-	var _introspection = __webpack_require__(208);
-
-	var _typeFromAST = __webpack_require__(214);
-
-	var _find = __webpack_require__(211);
-
-	var _find2 = _interopRequireDefault(_find);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	/**
-	 * TypeInfo is a utility class which, given a GraphQL schema, can keep track
-	 * of the current field and type definitions at any point in a GraphQL document
-	 * AST during a recursive descent by calling `enter(node)` and `leave(node)`.
-	 */
-	var TypeInfo = exports.TypeInfo = function () {
-	  function TypeInfo(schema,
-	  // NOTE: this experimental optional second parameter is only needed in order
-	  // to support non-spec-compliant codebases. You should never need to use it.
-	  getFieldDefFn) {
-	    _classCallCheck(this, TypeInfo);
-
-	    this._schema = schema;
-	    this._typeStack = [];
-	    this._parentTypeStack = [];
-	    this._inputTypeStack = [];
-	    this._fieldDefStack = [];
-	    this._directive = null;
-	    this._argument = null;
-	    this._getFieldDef = getFieldDefFn || getFieldDef;
-	  }
-
-	  TypeInfo.prototype.getType = function getType() {
-	    if (this._typeStack.length > 0) {
-	      return this._typeStack[this._typeStack.length - 1];
-	    }
-	  };
-
-	  TypeInfo.prototype.getParentType = function getParentType() {
-	    if (this._parentTypeStack.length > 0) {
-	      return this._parentTypeStack[this._parentTypeStack.length - 1];
-	    }
-	  };
-
-	  TypeInfo.prototype.getInputType = function getInputType() {
-	    if (this._inputTypeStack.length > 0) {
-	      return this._inputTypeStack[this._inputTypeStack.length - 1];
-	    }
-	  };
-
-	  TypeInfo.prototype.getFieldDef = function getFieldDef() {
-	    if (this._fieldDefStack.length > 0) {
-	      return this._fieldDefStack[this._fieldDefStack.length - 1];
-	    }
-	  };
-
-	  TypeInfo.prototype.getDirective = function getDirective() {
-	    return this._directive;
-	  };
-
-	  TypeInfo.prototype.getArgument = function getArgument() {
-	    return this._argument;
-	  };
-
-	  // Flow does not yet handle this case.
-
-
-	  TypeInfo.prototype.enter = function enter(node /* Node */) {
-	    var schema = this._schema;
-	    switch (node.kind) {
-	      case Kind.SELECTION_SET:
-	        var namedType = (0, _definition.getNamedType)(this.getType());
-	        var compositeType = void 0;
-	        if ((0, _definition.isCompositeType)(namedType)) {
-	          // isCompositeType is a type refining predicate, so this is safe.
-	          compositeType = namedType;
-	        }
-	        this._parentTypeStack.push(compositeType);
-	        break;
-	      case Kind.FIELD:
-	        var parentType = this.getParentType();
-	        var fieldDef = void 0;
-	        if (parentType) {
-	          fieldDef = this._getFieldDef(schema, parentType, node);
-	        }
-	        this._fieldDefStack.push(fieldDef);
-	        this._typeStack.push(fieldDef && fieldDef.type);
-	        break;
-	      case Kind.DIRECTIVE:
-	        this._directive = schema.getDirective(node.name.value);
-	        break;
-	      case Kind.OPERATION_DEFINITION:
-	        var type = void 0;
-	        if (node.operation === 'query') {
-	          type = schema.getQueryType();
-	        } else if (node.operation === 'mutation') {
-	          type = schema.getMutationType();
-	        } else if (node.operation === 'subscription') {
-	          type = schema.getSubscriptionType();
-	        }
-	        this._typeStack.push(type);
-	        break;
-	      case Kind.INLINE_FRAGMENT:
-	      case Kind.FRAGMENT_DEFINITION:
-	        var typeConditionAST = node.typeCondition;
-	        var outputType = typeConditionAST ? (0, _typeFromAST.typeFromAST)(schema, typeConditionAST) : this.getType();
-	        this._typeStack.push(outputType);
-	        break;
-	      case Kind.VARIABLE_DEFINITION:
-	        var inputType = (0, _typeFromAST.typeFromAST)(schema, node.type);
-	        this._inputTypeStack.push(inputType);
-	        break;
-	      case Kind.ARGUMENT:
-	        var argDef = void 0;
-	        var argType = void 0;
-	        var fieldOrDirective = this.getDirective() || this.getFieldDef();
-	        if (fieldOrDirective) {
-	          argDef = (0, _find2.default)(fieldOrDirective.args, function (arg) {
-	            return arg.name === node.name.value;
-	          });
-	          if (argDef) {
-	            argType = argDef.type;
-	          }
-	        }
-	        this._argument = argDef;
-	        this._inputTypeStack.push(argType);
-	        break;
-	      case Kind.LIST:
-	        var listType = (0, _definition.getNullableType)(this.getInputType());
-	        this._inputTypeStack.push(listType instanceof _definition.GraphQLList ? listType.ofType : undefined);
-	        break;
-	      case Kind.OBJECT_FIELD:
-	        var objectType = (0, _definition.getNamedType)(this.getInputType());
-	        var fieldType = void 0;
-	        if (objectType instanceof _definition.GraphQLInputObjectType) {
-	          var inputField = objectType.getFields()[node.name.value];
-	          fieldType = inputField ? inputField.type : undefined;
-	        }
-	        this._inputTypeStack.push(fieldType);
-	        break;
-	    }
-	  };
-
-	  TypeInfo.prototype.leave = function leave(node) {
-	    switch (node.kind) {
-	      case Kind.SELECTION_SET:
-	        this._parentTypeStack.pop();
-	        break;
-	      case Kind.FIELD:
-	        this._fieldDefStack.pop();
-	        this._typeStack.pop();
-	        break;
-	      case Kind.DIRECTIVE:
-	        this._directive = null;
-	        break;
-	      case Kind.OPERATION_DEFINITION:
-	      case Kind.INLINE_FRAGMENT:
-	      case Kind.FRAGMENT_DEFINITION:
-	        this._typeStack.pop();
-	        break;
-	      case Kind.VARIABLE_DEFINITION:
-	        this._inputTypeStack.pop();
-	        break;
-	      case Kind.ARGUMENT:
-	        this._argument = null;
-	        this._inputTypeStack.pop();
-	        break;
-	      case Kind.LIST:
-	      case Kind.OBJECT_FIELD:
-	        this._inputTypeStack.pop();
-	        break;
-	    }
-	  };
-
-	  return TypeInfo;
-	}();
-
-	/**
-	 * Not exactly the same as the executor's definition of getFieldDef, in this
-	 * statically evaluated environment we do not always have an Object type,
-	 * and need to handle Interface and Union types.
-	 */
-
-
-	function getFieldDef(schema, parentType, fieldAST) {
-	  var name = fieldAST.name.value;
-	  if (name === _introspection.SchemaMetaFieldDef.name && schema.getQueryType() === parentType) {
-	    return _introspection.SchemaMetaFieldDef;
-	  }
-	  if (name === _introspection.TypeMetaFieldDef.name && schema.getQueryType() === parentType) {
-	    return _introspection.TypeMetaFieldDef;
-	  }
-	  if (name === _introspection.TypeNameMetaFieldDef.name && (parentType instanceof _definition.GraphQLObjectType || parentType instanceof _definition.GraphQLInterfaceType || parentType instanceof _definition.GraphQLUnionType)) {
-	    return _introspection.TypeNameMetaFieldDef;
-	  }
-	  if (parentType instanceof _definition.GraphQLObjectType || parentType instanceof _definition.GraphQLInterfaceType) {
-	    return parentType.getFields()[name];
-	  }
-	}
-
-/***/ },
-/* 214 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.typeFromAST = typeFromAST;
-
-	var _invariant = __webpack_require__(200);
-
-	var _invariant2 = _interopRequireDefault(_invariant);
-
-	var _kinds = __webpack_require__(196);
-
-	var _definition = __webpack_require__(203);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function typeFromAST(schema, inputTypeAST) {
-	  var innerType = void 0;
-	  if (inputTypeAST.kind === _kinds.LIST_TYPE) {
-	    innerType = typeFromAST(schema, inputTypeAST.type);
-	    return innerType && new _definition.GraphQLList(innerType);
-	  }
-	  if (inputTypeAST.kind === _kinds.NON_NULL_TYPE) {
-	    innerType = typeFromAST(schema, inputTypeAST.type);
-	    return innerType && new _definition.GraphQLNonNull(innerType);
-	  }
-	  (0, _invariant2.default)(inputTypeAST.kind === _kinds.NAMED_TYPE, 'Must be a named type.');
-	  return schema.getType(inputTypeAST.name.value);
-	}
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-/***/ },
-/* 215 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.specifiedRules = undefined;
-
-	var _UniqueOperationNames = __webpack_require__(216);
-
-	var _LoneAnonymousOperation = __webpack_require__(217);
-
-	var _KnownTypeNames = __webpack_require__(218);
-
-	var _FragmentsOnCompositeTypes = __webpack_require__(221);
-
-	var _VariablesAreInputTypes = __webpack_require__(222);
-
-	var _ScalarLeafs = __webpack_require__(223);
-
-	var _FieldsOnCorrectType = __webpack_require__(224);
-
-	var _UniqueFragmentNames = __webpack_require__(225);
-
-	var _KnownFragmentNames = __webpack_require__(226);
-
-	var _NoUnusedFragments = __webpack_require__(227);
-
-	var _PossibleFragmentSpreads = __webpack_require__(228);
-
-	var _NoFragmentCycles = __webpack_require__(229);
-
-	var _UniqueVariableNames = __webpack_require__(230);
-
-	var _NoUndefinedVariables = __webpack_require__(231);
-
-	var _NoUnusedVariables = __webpack_require__(232);
-
-	var _KnownDirectives = __webpack_require__(233);
-
-	var _KnownArgumentNames = __webpack_require__(234);
-
-	var _UniqueArgumentNames = __webpack_require__(235);
-
-	var _ArgumentsOfCorrectType = __webpack_require__(236);
-
-	var _ProvidedNonNullArguments = __webpack_require__(239);
-
-	var _DefaultValuesOfCorrectType = __webpack_require__(240);
-
-	var _VariablesInAllowedPosition = __webpack_require__(241);
-
-	var _OverlappingFieldsCanBeMerged = __webpack_require__(242);
-
-	var _UniqueInputFieldNames = __webpack_require__(243);
-
-	/**
-	 * This set includes all validation rules defined by the GraphQL spec.
-	 */
-
-
-	// Spec Section: "Field Selection Merging"
-
-
-	// Spec Section: "Variable Default Values Are Correctly Typed"
-
-
-	// Spec Section: "Argument Values Type Correctness"
-
-
-	// Spec Section: "Argument Names"
-
-
-	// Spec Section: "All Variables Used"
-
-
-	// Spec Section: "Variable Uniqueness"
-
-
-	// Spec Section: "Fragment spread is possible"
-
-
-	// Spec Section: "Fragment spread target defined"
-
-
-	// Spec Section: "Field Selections on Objects, Interfaces, and Unions Types"
-
-
-	// Spec Section: "Variables are Input Types"
-
-
-	// Spec Section: "Fragment Spread Type Existence"
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	// Spec Section: "Operation Name Uniqueness"
-	var specifiedRules = exports.specifiedRules = [_UniqueOperationNames.UniqueOperationNames, _LoneAnonymousOperation.LoneAnonymousOperation, _KnownTypeNames.KnownTypeNames, _FragmentsOnCompositeTypes.FragmentsOnCompositeTypes, _VariablesAreInputTypes.VariablesAreInputTypes, _ScalarLeafs.ScalarLeafs, _FieldsOnCorrectType.FieldsOnCorrectType, _UniqueFragmentNames.UniqueFragmentNames, _KnownFragmentNames.KnownFragmentNames, _NoUnusedFragments.NoUnusedFragments, _PossibleFragmentSpreads.PossibleFragmentSpreads, _NoFragmentCycles.NoFragmentCycles, _UniqueVariableNames.UniqueVariableNames, _NoUndefinedVariables.NoUndefinedVariables, _NoUnusedVariables.NoUnusedVariables, _KnownDirectives.KnownDirectives, _KnownArgumentNames.KnownArgumentNames, _UniqueArgumentNames.UniqueArgumentNames, _ArgumentsOfCorrectType.ArgumentsOfCorrectType, _ProvidedNonNullArguments.ProvidedNonNullArguments, _DefaultValuesOfCorrectType.DefaultValuesOfCorrectType, _VariablesInAllowedPosition.VariablesInAllowedPosition, _OverlappingFieldsCanBeMerged.OverlappingFieldsCanBeMerged, _UniqueInputFieldNames.UniqueInputFieldNames];
-
-	// Spec Section: "Input Object Field Uniqueness"
-
-
-	// Spec Section: "All Variable Usages Are Allowed"
-
-
-	// Spec Section: "Argument Optionality"
-
-
-	// Spec Section: "Argument Uniqueness"
-
-
-	// Spec Section: "Directives Are Defined"
-
-
-	// Spec Section: "All Variable Used Defined"
-
-
-	// Spec Section: "Fragments must not form cycles"
-
-
-	// Spec Section: "Fragments must be used"
-
-
-	// Spec Section: "Fragment Name Uniqueness"
-
-
-	// Spec Section: "Leaf Field Selections"
-
-
-	// Spec Section: "Fragments on Composite Types"
-
-
-	// Spec Section: "Lone Anonymous Operation"
-
-/***/ },
-/* 216 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.duplicateOperationNameMessage = duplicateOperationNameMessage;
-	exports.UniqueOperationNames = UniqueOperationNames;
-
-	var _error = __webpack_require__(189);
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function duplicateOperationNameMessage(operationName) {
-	  return 'There can only be one operation named "' + operationName + '".';
-	}
-
-	/**
-	 * Unique operation names
-	 *
-	 * A GraphQL document is only valid if all defined operations have unique names.
-	 */
-	function UniqueOperationNames(context) {
-	  var knownOperationNames = Object.create(null);
-	  return {
-	    OperationDefinition: function OperationDefinition(node) {
-	      var operationName = node.name;
-	      if (operationName) {
-	        if (knownOperationNames[operationName.value]) {
-	          context.reportError(new _error.GraphQLError(duplicateOperationNameMessage(operationName.value), [knownOperationNames[operationName.value], operationName]));
-	        } else {
-	          knownOperationNames[operationName.value] = operationName;
-	        }
-	      }
-	      return false;
-	    },
-
-	    FragmentDefinition: function FragmentDefinition() {
-	      return false;
-	    }
-	  };
-	}
-
-/***/ },
-/* 217 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.anonOperationNotAloneMessage = anonOperationNotAloneMessage;
-	exports.LoneAnonymousOperation = LoneAnonymousOperation;
-
-	var _error = __webpack_require__(189);
-
-	var _kinds = __webpack_require__(196);
-
-	function anonOperationNotAloneMessage() {
-	  return 'This anonymous operation must be the only defined operation.';
-	}
-
-	/**
-	 * Lone anonymous operation
-	 *
-	 * A GraphQL document is only valid if when it contains an anonymous operation
-	 * (the query short-hand) that it contains only that one operation definition.
-	 */
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function LoneAnonymousOperation(context) {
-	  var operationCount = 0;
-	  return {
-	    Document: function Document(node) {
-	      operationCount = node.definitions.filter(function (definition) {
-	        return definition.kind === _kinds.OPERATION_DEFINITION;
-	      }).length;
-	    },
-	    OperationDefinition: function OperationDefinition(node) {
-	      if (!node.name && operationCount > 1) {
-	        context.reportError(new _error.GraphQLError(anonOperationNotAloneMessage(), [node]));
-	      }
-	    }
-	  };
-	}
-
-/***/ },
-/* 218 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.unknownTypeMessage = unknownTypeMessage;
-	exports.KnownTypeNames = KnownTypeNames;
-
-	var _error = __webpack_require__(189);
-
-	var _suggestionList = __webpack_require__(219);
-
-	var _suggestionList2 = _interopRequireDefault(_suggestionList);
-
-	var _quotedOrList = __webpack_require__(220);
-
-	var _quotedOrList2 = _interopRequireDefault(_quotedOrList);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function unknownTypeMessage(type, suggestedTypes) {
-	  var message = 'Unknown type "' + String(type) + '".';
-	  if (suggestedTypes.length) {
-	    message += ' Did you mean ' + (0, _quotedOrList2.default)(suggestedTypes) + '?';
-	  }
-	  return message;
-	}
-
-	/**
-	 * Known type names
-	 *
-	 * A GraphQL document is only valid if referenced types (specifically
-	 * variable definitions and fragment conditions) are defined by the type schema.
-	 */
-	function KnownTypeNames(context) {
-	  return {
-	    // TODO: when validating IDL, re-enable these. Experimental version does not
-	    // add unreferenced types, resulting in false-positive errors. Squelched
-	    // errors for now.
-	    ObjectTypeDefinition: function ObjectTypeDefinition() {
-	      return false;
-	    },
-	    InterfaceTypeDefinition: function InterfaceTypeDefinition() {
-	      return false;
-	    },
-	    UnionTypeDefinition: function UnionTypeDefinition() {
-	      return false;
-	    },
-	    InputObjectTypeDefinition: function InputObjectTypeDefinition() {
-	      return false;
-	    },
-	    NamedType: function NamedType(node) {
-	      var schema = context.getSchema();
-	      var typeName = node.name.value;
-	      var type = schema.getType(typeName);
-	      if (!type) {
-	        context.reportError(new _error.GraphQLError(unknownTypeMessage(typeName, (0, _suggestionList2.default)(typeName, Object.keys(schema.getTypeMap()))), [node]));
-	      }
-	    }
-	  };
-	}
-
-/***/ },
-/* 219 */
-/***/ function(module, exports) {
-
-	"use strict";
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.default = suggestionList;
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	/**
-	 * Given an invalid input string and a list of valid options, returns a filtered
-	 * list of valid options sorted based on their similarity with the input.
-	 */
-	function suggestionList(input, options) {
-	  var optionsByDistance = Object.create(null);
-	  var oLength = options.length;
-	  var inputThreshold = input.length / 2;
-	  for (var i = 0; i < oLength; i++) {
-	    var distance = lexicalDistance(input, options[i]);
-	    var threshold = Math.max(inputThreshold, options[i].length / 2, 1);
-	    if (distance <= threshold) {
-	      optionsByDistance[options[i]] = distance;
-	    }
-	  }
-	  return Object.keys(optionsByDistance).sort(function (a, b) {
-	    return optionsByDistance[a] - optionsByDistance[b];
-	  });
-	}
-
-	/**
-	 * Computes the lexical distance between strings A and B.
-	 *
-	 * The "distance" between two strings is given by counting the minimum number
-	 * of edits needed to transform string A into string B. An edit can be an
-	 * insertion, deletion, or substitution of a single character, or a swap of two
-	 * adjacent characters.
-	 *
-	 * This distance can be useful for detecting typos in input or sorting
-	 *
-	 * @param {string} a
-	 * @param {string} b
-	 * @return {int} distance in number of edits
-	 */
-	function lexicalDistance(a, b) {
-	  var i = void 0;
-	  var j = void 0;
-	  var d = [];
-	  var aLength = a.length;
-	  var bLength = b.length;
-
-	  for (i = 0; i <= aLength; i++) {
-	    d[i] = [i];
-	  }
-
-	  for (j = 1; j <= bLength; j++) {
-	    d[0][j] = j;
-	  }
-
-	  for (i = 1; i <= aLength; i++) {
-	    for (j = 1; j <= bLength; j++) {
-	      var cost = a[i - 1] === b[j - 1] ? 0 : 1;
-
-	      d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
-
-	      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
-	        d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + cost);
-	      }
-	    }
-	  }
-
-	  return d[aLength][bLength];
-	}
-
-/***/ },
-/* 220 */
-/***/ function(module, exports) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.default = quotedOrList;
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	var MAX_LENGTH = 5;
-
-	/**
-	 * Given [ A, B, C ] return '"A", "B", or "C"'.
-	 */
-	function quotedOrList(items) {
-	  var selected = items.slice(0, MAX_LENGTH);
-	  return selected.map(function (item) {
-	    return '"' + item + '"';
-	  }).reduce(function (list, quoted, index) {
-	    return list + (selected.length > 2 ? ', ' : ' ') + (index === selected.length - 1 ? 'or ' : '') + quoted;
-	  });
-	}
-
-/***/ },
-/* 221 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.inlineFragmentOnNonCompositeErrorMessage = inlineFragmentOnNonCompositeErrorMessage;
-	exports.fragmentOnNonCompositeErrorMessage = fragmentOnNonCompositeErrorMessage;
-	exports.FragmentsOnCompositeTypes = FragmentsOnCompositeTypes;
-
-	var _error = __webpack_require__(189);
-
-	var _printer = __webpack_require__(194);
-
-	var _definition = __webpack_require__(203);
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function inlineFragmentOnNonCompositeErrorMessage(type) {
-	  return 'Fragment cannot condition on non composite type "' + String(type) + '".';
-	}
-
-	function fragmentOnNonCompositeErrorMessage(fragName, type) {
-	  return 'Fragment "' + fragName + '" cannot condition on non composite ' + ('type "' + String(type) + '".');
-	}
-
-	/**
-	 * Fragments on composite type
-	 *
-	 * Fragments use a type condition to determine if they apply, since fragments
-	 * can only be spread into a composite type (object, interface, or union), the
-	 * type condition must also be a composite type.
-	 */
-	function FragmentsOnCompositeTypes(context) {
-	  return {
-	    InlineFragment: function InlineFragment(node) {
-	      var type = context.getType();
-	      if (node.typeCondition && type && !(0, _definition.isCompositeType)(type)) {
-	        context.reportError(new _error.GraphQLError(inlineFragmentOnNonCompositeErrorMessage((0, _printer.print)(node.typeCondition)), [node.typeCondition]));
-	      }
-	    },
-	    FragmentDefinition: function FragmentDefinition(node) {
-	      var type = context.getType();
-	      if (type && !(0, _definition.isCompositeType)(type)) {
-	        context.reportError(new _error.GraphQLError(fragmentOnNonCompositeErrorMessage(node.name.value, (0, _printer.print)(node.typeCondition)), [node.typeCondition]));
-	      }
-	    }
-	  };
-	}
-
-/***/ },
-/* 222 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.nonInputTypeOnVarMessage = nonInputTypeOnVarMessage;
-	exports.VariablesAreInputTypes = VariablesAreInputTypes;
-
-	var _error = __webpack_require__(189);
-
-	var _printer = __webpack_require__(194);
-
-	var _definition = __webpack_require__(203);
-
-	var _typeFromAST = __webpack_require__(214);
-
-	function nonInputTypeOnVarMessage(variableName, typeName) {
-	  return 'Variable "$' + variableName + '" cannot be non-input type "' + typeName + '".';
-	}
-
-	/**
-	 * Variables are input types
-	 *
-	 * A GraphQL operation is only valid if all the variables it defines are of
-	 * input types (scalar, enum, or input object).
-	 */
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function VariablesAreInputTypes(context) {
-	  return {
-	    VariableDefinition: function VariableDefinition(node) {
-	      var type = (0, _typeFromAST.typeFromAST)(context.getSchema(), node.type);
-
-	      // If the variable type is not an input type, return an error.
-	      if (type && !(0, _definition.isInputType)(type)) {
-	        var variableName = node.variable.name.value;
-	        context.reportError(new _error.GraphQLError(nonInputTypeOnVarMessage(variableName, (0, _printer.print)(node.type)), [node.type]));
-	      }
-	    }
-	  };
-	}
-
-/***/ },
-/* 223 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.noSubselectionAllowedMessage = noSubselectionAllowedMessage;
-	exports.requiredSubselectionMessage = requiredSubselectionMessage;
-	exports.ScalarLeafs = ScalarLeafs;
-
-	var _error = __webpack_require__(189);
-
-	var _definition = __webpack_require__(203);
-
-	function noSubselectionAllowedMessage(fieldName, type) {
-	  return 'Field "' + fieldName + '" must not have a selection since ' + ('type "' + String(type) + '" has no subfields.');
-	}
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function requiredSubselectionMessage(fieldName, type) {
-	  return 'Field "' + fieldName + '" of type "' + String(type) + '" must have a ' + ('selection of subfields. Did you mean "' + fieldName + ' { ... }"?');
-	}
-
-	/**
-	 * Scalar leafs
-	 *
-	 * A GraphQL document is valid only if all leaf fields (fields without
-	 * sub selections) are of scalar or enum types.
-	 */
-	function ScalarLeafs(context) {
-	  return {
-	    Field: function Field(node) {
-	      var type = context.getType();
-	      if (type) {
-	        if ((0, _definition.isLeafType)(type)) {
-	          if (node.selectionSet) {
-	            context.reportError(new _error.GraphQLError(noSubselectionAllowedMessage(node.name.value, type), [node.selectionSet]));
-	          }
-	        } else if (!node.selectionSet) {
-	          context.reportError(new _error.GraphQLError(requiredSubselectionMessage(node.name.value, type), [node]));
-	        }
-	      }
-	    }
-	  };
-	}
-
-/***/ },
-/* 224 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.undefinedFieldMessage = undefinedFieldMessage;
-	exports.FieldsOnCorrectType = FieldsOnCorrectType;
-
-	var _error = __webpack_require__(189);
-
-	var _suggestionList = __webpack_require__(219);
-
-	var _suggestionList2 = _interopRequireDefault(_suggestionList);
-
-	var _quotedOrList = __webpack_require__(220);
-
-	var _quotedOrList2 = _interopRequireDefault(_quotedOrList);
-
-	var _definition = __webpack_require__(203);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function undefinedFieldMessage(fieldName, type, suggestedTypeNames, suggestedFieldNames) {
-	  var message = 'Cannot query field "' + fieldName + '" on type "' + type + '".';
-	  if (suggestedTypeNames.length !== 0) {
-	    var suggestions = (0, _quotedOrList2.default)(suggestedTypeNames);
-	    message += ' Did you mean to use an inline fragment on ' + suggestions + '?';
-	  } else if (suggestedFieldNames.length !== 0) {
-	    message += ' Did you mean ' + (0, _quotedOrList2.default)(suggestedFieldNames) + '?';
-	  }
-	  return message;
-	}
-
-	/**
-	 * Fields on correct type
-	 *
-	 * A GraphQL document is only valid if all fields selected are defined by the
-	 * parent type, or are an allowed meta field such as __typename.
-	 */
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function FieldsOnCorrectType(context) {
-	  return {
-	    Field: function Field(node) {
-	      var type = context.getParentType();
-	      if (type) {
-	        var fieldDef = context.getFieldDef();
-	        if (!fieldDef) {
-	          // This field doesn't exist, lets look for suggestions.
-	          var schema = context.getSchema();
-	          var fieldName = node.name.value;
-	          // First determine if there are any suggested types to condition on.
-	          var suggestedTypeNames = getSuggestedTypeNames(schema, type, fieldName);
-	          // If there are no suggested types, then perhaps this was a typo?
-	          var suggestedFieldNames = suggestedTypeNames.length !== 0 ? [] : getSuggestedFieldNames(schema, type, fieldName);
-
-	          // Report an error, including helpful suggestions.
-	          context.reportError(new _error.GraphQLError(undefinedFieldMessage(fieldName, type.name, suggestedTypeNames, suggestedFieldNames), [node]));
-	        }
-	      }
-	    }
-	  };
-	}
-
-	/**
-	 * Go through all of the implementations of type, as well as the interfaces
-	 * that they implement. If any of those types include the provided field,
-	 * suggest them, sorted by how often the type is referenced,  starting
-	 * with Interfaces.
-	 */
-	function getSuggestedTypeNames(schema, type, fieldName) {
-	  if (type instanceof _definition.GraphQLInterfaceType || type instanceof _definition.GraphQLUnionType) {
-	    var _ret = function () {
-	      var suggestedObjectTypes = [];
-	      var interfaceUsageCount = Object.create(null);
-	      schema.getPossibleTypes(type).forEach(function (possibleType) {
-	        if (!possibleType.getFields()[fieldName]) {
-	          return;
-	        }
-	        // This object type defines this field.
-	        suggestedObjectTypes.push(possibleType.name);
-	        possibleType.getInterfaces().forEach(function (possibleInterface) {
-	          if (!possibleInterface.getFields()[fieldName]) {
-	            return;
-	          }
-	          // This interface type defines this field.
-	          interfaceUsageCount[possibleInterface.name] = (interfaceUsageCount[possibleInterface.name] || 0) + 1;
-	        });
-	      });
-
-	      // Suggest interface types based on how common they are.
-	      var suggestedInterfaceTypes = Object.keys(interfaceUsageCount).sort(function (a, b) {
-	        return interfaceUsageCount[b] - interfaceUsageCount[a];
-	      });
-
-	      // Suggest both interface and object types.
-	      return {
-	        v: suggestedInterfaceTypes.concat(suggestedObjectTypes)
-	      };
-	    }();
-
-	    if (typeof _ret === "object") return _ret.v;
-	  }
-
-	  // Otherwise, must be an Object type, which does not have possible fields.
-	  return [];
-	}
-
-	/**
-	 * For the field name provided, determine if there are any similar field names
-	 * that may be the result of a typo.
-	 */
-	function getSuggestedFieldNames(schema, type, fieldName) {
-	  if (type instanceof _definition.GraphQLObjectType || type instanceof _definition.GraphQLInterfaceType) {
-	    var possibleFieldNames = Object.keys(type.getFields());
-	    return (0, _suggestionList2.default)(fieldName, possibleFieldNames);
-	  }
-	  // Otherwise, must be a Union type, which does not define fields.
-	  return [];
-	}
-
-/***/ },
-/* 225 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.duplicateFragmentNameMessage = duplicateFragmentNameMessage;
-	exports.UniqueFragmentNames = UniqueFragmentNames;
-
-	var _error = __webpack_require__(189);
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function duplicateFragmentNameMessage(fragName) {
-	  return 'There can only be one fragment named "' + fragName + '".';
-	}
-
-	/**
-	 * Unique fragment names
-	 *
-	 * A GraphQL document is only valid if all defined fragments have unique names.
-	 */
-	function UniqueFragmentNames(context) {
-	  var knownFragmentNames = Object.create(null);
-	  return {
-	    OperationDefinition: function OperationDefinition() {
-	      return false;
-	    },
-	    FragmentDefinition: function FragmentDefinition(node) {
-	      var fragmentName = node.name.value;
-	      if (knownFragmentNames[fragmentName]) {
-	        context.reportError(new _error.GraphQLError(duplicateFragmentNameMessage(fragmentName), [knownFragmentNames[fragmentName], node.name]));
-	      } else {
-	        knownFragmentNames[fragmentName] = node.name;
-	      }
-	      return false;
-	    }
-	  };
-	}
-
-/***/ },
-/* 226 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.unknownFragmentMessage = unknownFragmentMessage;
-	exports.KnownFragmentNames = KnownFragmentNames;
-
-	var _error = __webpack_require__(189);
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function unknownFragmentMessage(fragName) {
-	  return 'Unknown fragment "' + fragName + '".';
-	}
-
-	/**
-	 * Known fragment names
-	 *
-	 * A GraphQL document is only valid if all `...Fragment` fragment spreads refer
-	 * to fragments defined in the same document.
-	 */
-	function KnownFragmentNames(context) {
-	  return {
-	    FragmentSpread: function FragmentSpread(node) {
-	      var fragmentName = node.name.value;
-	      var fragment = context.getFragment(fragmentName);
-	      if (!fragment) {
-	        context.reportError(new _error.GraphQLError(unknownFragmentMessage(fragmentName), [node.name]));
-	      }
-	    }
-	  };
-	}
-
-/***/ },
-/* 227 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.unusedFragMessage = unusedFragMessage;
-	exports.NoUnusedFragments = NoUnusedFragments;
-
-	var _error = __webpack_require__(189);
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function unusedFragMessage(fragName) {
-	  return 'Fragment "' + fragName + '" is never used.';
-	}
-
-	/**
-	 * No unused fragments
-	 *
-	 * A GraphQL document is only valid if all fragment definitions are spread
-	 * within operations, or spread within other fragments spread within operations.
-	 */
-	function NoUnusedFragments(context) {
-	  var operationDefs = [];
-	  var fragmentDefs = [];
-
-	  return {
-	    OperationDefinition: function OperationDefinition(node) {
-	      operationDefs.push(node);
-	      return false;
-	    },
-	    FragmentDefinition: function FragmentDefinition(node) {
-	      fragmentDefs.push(node);
-	      return false;
-	    },
-
-	    Document: {
-	      leave: function leave() {
-	        var fragmentNameUsed = Object.create(null);
-	        operationDefs.forEach(function (operation) {
-	          context.getRecursivelyReferencedFragments(operation).forEach(function (fragment) {
-	            fragmentNameUsed[fragment.name.value] = true;
-	          });
-	        });
-
-	        fragmentDefs.forEach(function (fragmentDef) {
-	          var fragName = fragmentDef.name.value;
-	          if (fragmentNameUsed[fragName] !== true) {
-	            context.reportError(new _error.GraphQLError(unusedFragMessage(fragName), [fragmentDef]));
-	          }
-	        });
-	      }
-	    }
-	  };
-	}
-
-/***/ },
-/* 228 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.typeIncompatibleSpreadMessage = typeIncompatibleSpreadMessage;
-	exports.typeIncompatibleAnonSpreadMessage = typeIncompatibleAnonSpreadMessage;
-	exports.PossibleFragmentSpreads = PossibleFragmentSpreads;
-
-	var _error = __webpack_require__(189);
-
-	var _typeComparators = __webpack_require__(212);
-
-	var _typeFromAST = __webpack_require__(214);
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function typeIncompatibleSpreadMessage(fragName, parentType, fragType) {
-	  return 'Fragment "' + fragName + '" cannot be spread here as objects of ' + ('type "' + String(parentType) + '" can never be of type "' + String(fragType) + '".');
-	}
-
-	function typeIncompatibleAnonSpreadMessage(parentType, fragType) {
-	  return 'Fragment cannot be spread here as objects of ' + ('type "' + String(parentType) + '" can never be of type "' + String(fragType) + '".');
-	}
-
-	/**
-	 * Possible fragment spread
-	 *
-	 * A fragment spread is only valid if the type condition could ever possibly
-	 * be true: if there is a non-empty intersection of the possible parent types,
-	 * and possible types which pass the type condition.
-	 */
-	function PossibleFragmentSpreads(context) {
-	  return {
-	    InlineFragment: function InlineFragment(node) {
-	      var fragType = context.getType();
-	      var parentType = context.getParentType();
-	      if (fragType && parentType && !(0, _typeComparators.doTypesOverlap)(context.getSchema(), fragType, parentType)) {
-	        context.reportError(new _error.GraphQLError(typeIncompatibleAnonSpreadMessage(parentType, fragType), [node]));
-	      }
-	    },
-	    FragmentSpread: function FragmentSpread(node) {
-	      var fragName = node.name.value;
-	      var fragType = getFragmentType(context, fragName);
-	      var parentType = context.getParentType();
-	      if (fragType && parentType && !(0, _typeComparators.doTypesOverlap)(context.getSchema(), fragType, parentType)) {
-	        context.reportError(new _error.GraphQLError(typeIncompatibleSpreadMessage(fragName, parentType, fragType), [node]));
-	      }
-	    }
-	  };
-	}
-
-	function getFragmentType(context, name) {
-	  var frag = context.getFragment(name);
-	  return frag && (0, _typeFromAST.typeFromAST)(context.getSchema(), frag.typeCondition);
-	}
-
-/***/ },
-/* 229 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.cycleErrorMessage = cycleErrorMessage;
-	exports.NoFragmentCycles = NoFragmentCycles;
-
-	var _error = __webpack_require__(189);
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function cycleErrorMessage(fragName, spreadNames) {
-	  var via = spreadNames.length ? ' via ' + spreadNames.join(', ') : '';
-	  return 'Cannot spread fragment "' + fragName + '" within itself' + via + '.';
-	}
-
-	function NoFragmentCycles(context) {
-	  // Tracks already visited fragments to maintain O(N) and to ensure that cycles
-	  // are not redundantly reported.
-	  var visitedFrags = Object.create(null);
-
-	  // Array of AST nodes used to produce meaningful errors
-	  var spreadPath = [];
-
-	  // Position in the spread path
-	  var spreadPathIndexByName = Object.create(null);
-
-	  return {
-	    OperationDefinition: function OperationDefinition() {
-	      return false;
-	    },
-	    FragmentDefinition: function FragmentDefinition(node) {
-	      if (!visitedFrags[node.name.value]) {
-	        detectCycleRecursive(node);
-	      }
-	      return false;
-	    }
-	  };
-
-	  // This does a straight-forward DFS to find cycles.
-	  // It does not terminate when a cycle was found but continues to explore
-	  // the graph to find all possible cycles.
-	  function detectCycleRecursive(fragment) {
-	    var fragmentName = fragment.name.value;
-	    visitedFrags[fragmentName] = true;
-
-	    var spreadNodes = context.getFragmentSpreads(fragment.selectionSet);
-	    if (spreadNodes.length === 0) {
-	      return;
-	    }
-
-	    spreadPathIndexByName[fragmentName] = spreadPath.length;
-
-	    for (var i = 0; i < spreadNodes.length; i++) {
-	      var spreadNode = spreadNodes[i];
-	      var spreadName = spreadNode.name.value;
-	      var cycleIndex = spreadPathIndexByName[spreadName];
-
-	      if (cycleIndex === undefined) {
-	        spreadPath.push(spreadNode);
-	        if (!visitedFrags[spreadName]) {
-	          var spreadFragment = context.getFragment(spreadName);
-	          if (spreadFragment) {
-	            detectCycleRecursive(spreadFragment);
-	          }
-	        }
-	        spreadPath.pop();
-	      } else {
-	        var cyclePath = spreadPath.slice(cycleIndex);
-	        context.reportError(new _error.GraphQLError(cycleErrorMessage(spreadName, cyclePath.map(function (s) {
-	          return s.name.value;
-	        })), cyclePath.concat(spreadNode)));
-	      }
-	    }
-
-	    spreadPathIndexByName[fragmentName] = undefined;
-	  }
-	}
-
-/***/ },
-/* 230 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.duplicateVariableMessage = duplicateVariableMessage;
-	exports.UniqueVariableNames = UniqueVariableNames;
-
-	var _error = __webpack_require__(189);
-
-	function duplicateVariableMessage(variableName) {
-	  return 'There can be only one variable named "' + variableName + '".';
-	}
-
-	/**
-	 * Unique variable names
-	 *
-	 * A GraphQL operation is only valid if all its variables are uniquely named.
-	 */
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function UniqueVariableNames(context) {
-	  var knownVariableNames = Object.create(null);
-	  return {
-	    OperationDefinition: function OperationDefinition() {
-	      knownVariableNames = Object.create(null);
-	    },
-	    VariableDefinition: function VariableDefinition(node) {
-	      var variableName = node.variable.name.value;
-	      if (knownVariableNames[variableName]) {
-	        context.reportError(new _error.GraphQLError(duplicateVariableMessage(variableName), [knownVariableNames[variableName], node.variable.name]));
-	      } else {
-	        knownVariableNames[variableName] = node.variable.name;
-	      }
-	    }
-	  };
-	}
-
-/***/ },
-/* 231 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.undefinedVarMessage = undefinedVarMessage;
-	exports.NoUndefinedVariables = NoUndefinedVariables;
-
-	var _error = __webpack_require__(189);
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function undefinedVarMessage(varName, opName) {
-	  return opName ? 'Variable "$' + varName + '" is not defined by operation "' + opName + '".' : 'Variable "$' + varName + '" is not defined.';
-	}
-
-	/**
-	 * No undefined variables
-	 *
-	 * A GraphQL operation is only valid if all variables encountered, both directly
-	 * and via fragment spreads, are defined by that operation.
-	 */
-	function NoUndefinedVariables(context) {
-	  var variableNameDefined = Object.create(null);
-
-	  return {
-	    OperationDefinition: {
-	      enter: function enter() {
-	        variableNameDefined = Object.create(null);
-	      },
-	      leave: function leave(operation) {
-	        var usages = context.getRecursiveVariableUsages(operation);
-
-	        usages.forEach(function (_ref) {
-	          var node = _ref.node;
-
-	          var varName = node.name.value;
-	          if (variableNameDefined[varName] !== true) {
-	            context.reportError(new _error.GraphQLError(undefinedVarMessage(varName, operation.name && operation.name.value), [node, operation]));
-	          }
-	        });
-	      }
-	    },
-	    VariableDefinition: function VariableDefinition(varDefAST) {
-	      variableNameDefined[varDefAST.variable.name.value] = true;
-	    }
-	  };
-	}
-
-/***/ },
-/* 232 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.unusedVariableMessage = unusedVariableMessage;
-	exports.NoUnusedVariables = NoUnusedVariables;
-
-	var _error = __webpack_require__(189);
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function unusedVariableMessage(varName, opName) {
-	  return opName ? 'Variable "$' + varName + '" is never used in operation "' + opName + '".' : 'Variable "$' + varName + '" is never used.';
-	}
-
-	/**
-	 * No unused variables
-	 *
-	 * A GraphQL operation is only valid if all variables defined by an operation
-	 * are used, either directly or within a spread fragment.
-	 */
-	function NoUnusedVariables(context) {
-	  var variableDefs = [];
-
-	  return {
-	    OperationDefinition: {
-	      enter: function enter() {
-	        variableDefs = [];
-	      },
-	      leave: function leave(operation) {
-	        var variableNameUsed = Object.create(null);
-	        var usages = context.getRecursiveVariableUsages(operation);
-	        var opName = operation.name ? operation.name.value : null;
-
-	        usages.forEach(function (_ref) {
-	          var node = _ref.node;
-
-	          variableNameUsed[node.name.value] = true;
-	        });
-
-	        variableDefs.forEach(function (variableDef) {
-	          var variableName = variableDef.variable.name.value;
-	          if (variableNameUsed[variableName] !== true) {
-	            context.reportError(new _error.GraphQLError(unusedVariableMessage(variableName, opName), [variableDef]));
-	          }
-	        });
-	      }
-	    },
-	    VariableDefinition: function VariableDefinition(def) {
-	      variableDefs.push(def);
-	    }
-	  };
-	}
-
-/***/ },
-/* 233 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.unknownDirectiveMessage = unknownDirectiveMessage;
-	exports.misplacedDirectiveMessage = misplacedDirectiveMessage;
-	exports.KnownDirectives = KnownDirectives;
-
-	var _error = __webpack_require__(189);
-
-	var _find = __webpack_require__(211);
-
-	var _find2 = _interopRequireDefault(_find);
-
-	var _kinds = __webpack_require__(196);
-
-	var _directives = __webpack_require__(206);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function unknownDirectiveMessage(directiveName) {
-	  return 'Unknown directive "' + directiveName + '".';
-	}
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function misplacedDirectiveMessage(directiveName, location) {
-	  return 'Directive "' + directiveName + '" may not be used on ' + location + '.';
-	}
-
-	/**
-	 * Known directives
-	 *
-	 * A GraphQL document is only valid if all `@directives` are known by the
-	 * schema and legally positioned.
-	 */
-	function KnownDirectives(context) {
-	  return {
-	    Directive: function Directive(node, key, parent, path, ancestors) {
-	      var directiveDef = (0, _find2.default)(context.getSchema().getDirectives(), function (def) {
-	        return def.name === node.name.value;
-	      });
-	      if (!directiveDef) {
-	        context.reportError(new _error.GraphQLError(unknownDirectiveMessage(node.name.value), [node]));
-	        return;
-	      }
-	      var candidateLocation = getDirectiveLocationForASTPath(ancestors);
-	      if (!candidateLocation) {
-	        context.reportError(new _error.GraphQLError(misplacedDirectiveMessage(node.name.value, node.type), [node]));
-	      } else if (directiveDef.locations.indexOf(candidateLocation) === -1) {
-	        context.reportError(new _error.GraphQLError(misplacedDirectiveMessage(node.name.value, candidateLocation), [node]));
-	      }
-	    }
-	  };
-	}
-
-	function getDirectiveLocationForASTPath(ancestors) {
-	  var appliedTo = ancestors[ancestors.length - 1];
-	  switch (appliedTo.kind) {
-	    case _kinds.OPERATION_DEFINITION:
-	      switch (appliedTo.operation) {
-	        case 'query':
-	          return _directives.DirectiveLocation.QUERY;
-	        case 'mutation':
-	          return _directives.DirectiveLocation.MUTATION;
-	        case 'subscription':
-	          return _directives.DirectiveLocation.SUBSCRIPTION;
-	      }
-	      break;
-	    case _kinds.FIELD:
-	      return _directives.DirectiveLocation.FIELD;
-	    case _kinds.FRAGMENT_SPREAD:
-	      return _directives.DirectiveLocation.FRAGMENT_SPREAD;
-	    case _kinds.INLINE_FRAGMENT:
-	      return _directives.DirectiveLocation.INLINE_FRAGMENT;
-	    case _kinds.FRAGMENT_DEFINITION:
-	      return _directives.DirectiveLocation.FRAGMENT_DEFINITION;
-	    case _kinds.SCHEMA_DEFINITION:
-	      return _directives.DirectiveLocation.SCHEMA;
-	    case _kinds.SCALAR_TYPE_DEFINITION:
-	      return _directives.DirectiveLocation.SCALAR;
-	    case _kinds.OBJECT_TYPE_DEFINITION:
-	      return _directives.DirectiveLocation.OBJECT;
-	    case _kinds.FIELD_DEFINITION:
-	      return _directives.DirectiveLocation.FIELD_DEFINITION;
-	    case _kinds.INTERFACE_TYPE_DEFINITION:
-	      return _directives.DirectiveLocation.INTERFACE;
-	    case _kinds.UNION_TYPE_DEFINITION:
-	      return _directives.DirectiveLocation.UNION;
-	    case _kinds.ENUM_TYPE_DEFINITION:
-	      return _directives.DirectiveLocation.ENUM;
-	    case _kinds.ENUM_VALUE_DEFINITION:
-	      return _directives.DirectiveLocation.ENUM_VALUE;
-	    case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
-	      return _directives.DirectiveLocation.INPUT_OBJECT;
-	    case _kinds.INPUT_VALUE_DEFINITION:
-	      var parentNode = ancestors[ancestors.length - 3];
-	      return parentNode.kind === _kinds.INPUT_OBJECT_TYPE_DEFINITION ? _directives.DirectiveLocation.INPUT_FIELD_DEFINITION : _directives.DirectiveLocation.ARGUMENT_DEFINITION;
-	  }
-	}
-
-/***/ },
-/* 234 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.unknownArgMessage = unknownArgMessage;
-	exports.unknownDirectiveArgMessage = unknownDirectiveArgMessage;
-	exports.KnownArgumentNames = KnownArgumentNames;
-
-	var _error = __webpack_require__(189);
-
-	var _find = __webpack_require__(211);
-
-	var _find2 = _interopRequireDefault(_find);
-
-	var _invariant = __webpack_require__(200);
-
-	var _invariant2 = _interopRequireDefault(_invariant);
-
-	var _suggestionList = __webpack_require__(219);
-
-	var _suggestionList2 = _interopRequireDefault(_suggestionList);
-
-	var _quotedOrList = __webpack_require__(220);
-
-	var _quotedOrList2 = _interopRequireDefault(_quotedOrList);
-
-	var _kinds = __webpack_require__(196);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function unknownArgMessage(argName, fieldName, type, suggestedArgs) {
-	  var message = 'Unknown argument "' + argName + '" on field "' + fieldName + '" of ' + ('type "' + String(type) + '".');
-	  if (suggestedArgs.length) {
-	    message += ' Did you mean ' + (0, _quotedOrList2.default)(suggestedArgs) + '?';
-	  }
-	  return message;
-	}
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function unknownDirectiveArgMessage(argName, directiveName, suggestedArgs) {
-	  var message = 'Unknown argument "' + argName + '" on directive "@' + directiveName + '".';
-	  if (suggestedArgs.length) {
-	    message += ' Did you mean ' + (0, _quotedOrList2.default)(suggestedArgs) + '?';
-	  }
-	  return message;
-	}
-
-	/**
-	 * Known argument names
-	 *
-	 * A GraphQL field is only valid if all supplied arguments are defined by
-	 * that field.
-	 */
-	function KnownArgumentNames(context) {
-	  return {
-	    Argument: function Argument(node, key, parent, path, ancestors) {
-	      var argumentOf = ancestors[ancestors.length - 1];
-	      if (argumentOf.kind === _kinds.FIELD) {
-	        var fieldDef = context.getFieldDef();
-	        if (fieldDef) {
-	          var fieldArgDef = (0, _find2.default)(fieldDef.args, function (arg) {
-	            return arg.name === node.name.value;
-	          });
-	          if (!fieldArgDef) {
-	            var parentType = context.getParentType();
-	            (0, _invariant2.default)(parentType);
-	            context.reportError(new _error.GraphQLError(unknownArgMessage(node.name.value, fieldDef.name, parentType.name, (0, _suggestionList2.default)(node.name.value, fieldDef.args.map(function (arg) {
-	              return arg.name;
-	            }))), [node]));
-	          }
-	        }
-	      } else if (argumentOf.kind === _kinds.DIRECTIVE) {
-	        var directive = context.getDirective();
-	        if (directive) {
-	          var directiveArgDef = (0, _find2.default)(directive.args, function (arg) {
-	            return arg.name === node.name.value;
-	          });
-	          if (!directiveArgDef) {
-	            context.reportError(new _error.GraphQLError(unknownDirectiveArgMessage(node.name.value, directive.name, (0, _suggestionList2.default)(node.name.value, directive.args.map(function (arg) {
-	              return arg.name;
-	            }))), [node]));
-	          }
-	        }
-	      }
-	    }
-	  };
-	}
-
-/***/ },
-/* 235 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.duplicateArgMessage = duplicateArgMessage;
-	exports.UniqueArgumentNames = UniqueArgumentNames;
-
-	var _error = __webpack_require__(189);
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function duplicateArgMessage(argName) {
-	  return 'There can be only one argument named "' + argName + '".';
-	}
-
-	/**
-	 * Unique argument names
-	 *
-	 * A GraphQL field or directive is only valid if all supplied arguments are
-	 * uniquely named.
-	 */
-	function UniqueArgumentNames(context) {
-	  var knownArgNames = Object.create(null);
-	  return {
-	    Field: function Field() {
-	      knownArgNames = Object.create(null);
-	    },
-	    Directive: function Directive() {
-	      knownArgNames = Object.create(null);
-	    },
-	    Argument: function Argument(node) {
-	      var argName = node.name.value;
-	      if (knownArgNames[argName]) {
-	        context.reportError(new _error.GraphQLError(duplicateArgMessage(argName), [knownArgNames[argName], node.name]));
-	      } else {
-	        knownArgNames[argName] = node.name;
-	      }
-	      return false;
-	    }
-	  };
-	}
-
-/***/ },
-/* 236 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.badValueMessage = badValueMessage;
-	exports.ArgumentsOfCorrectType = ArgumentsOfCorrectType;
-
-	var _error = __webpack_require__(189);
-
-	var _printer = __webpack_require__(194);
-
-	var _isValidLiteralValue = __webpack_require__(237);
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function badValueMessage(argName, type, value, verboseErrors) {
-	  var message = verboseErrors ? '\n' + verboseErrors.join('\n') : '';
-	  return 'Argument "' + argName + '" has invalid value ' + value + '.' + message;
-	}
-
-	/**
-	 * Argument values of correct type
-	 *
-	 * A GraphQL document is only valid if all field argument literal values are
-	 * of the type expected by their position.
-	 */
-	function ArgumentsOfCorrectType(context) {
-	  return {
-	    Argument: function Argument(argAST) {
-	      var argDef = context.getArgument();
-	      if (argDef) {
-	        var errors = (0, _isValidLiteralValue.isValidLiteralValue)(argDef.type, argAST.value);
-	        if (errors && errors.length > 0) {
-	          context.reportError(new _error.GraphQLError(badValueMessage(argAST.name.value, argDef.type, (0, _printer.print)(argAST.value), errors), [argAST.value]));
-	        }
-	      }
-	      return false;
-	    }
-	  };
-	}
-
-/***/ },
-/* 237 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.isValidLiteralValue = isValidLiteralValue;
-
-	var _printer = __webpack_require__(194);
-
-	var _kinds = __webpack_require__(196);
-
-	var _definition = __webpack_require__(203);
-
-	var _invariant = __webpack_require__(200);
-
-	var _invariant2 = _interopRequireDefault(_invariant);
-
-	var _keyMap = __webpack_require__(238);
-
-	var _keyMap2 = _interopRequireDefault(_keyMap);
-
-	var _isNullish = __webpack_require__(204);
-
-	var _isNullish2 = _interopRequireDefault(_isNullish);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 * Utility for validators which determines if a value literal AST is valid given
-	 * an input type.
-	 *
-	 * Note that this only validates literal values, variables are assumed to
-	 * provide values of the correct type.
-	 */
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function isValidLiteralValue(type, valueAST) {
-	  // A value must be provided if the type is non-null.
-	  if (type instanceof _definition.GraphQLNonNull) {
-	    if (!valueAST) {
-	      if (type.ofType.name) {
-	        return ['Expected "' + String(type.ofType.name) + '!", found null.'];
-	      }
-	      return ['Expected non-null value, found null.'];
-	    }
-	    return isValidLiteralValue(type.ofType, valueAST);
-	  }
-
-	  if (!valueAST) {
-	    return [];
-	  }
-
-	  // This function only tests literals, and assumes variables will provide
-	  // values of the correct type.
-	  if (valueAST.kind === _kinds.VARIABLE) {
-	    return [];
-	  }
-
-	  // Lists accept a non-list value as a list of one.
-	  if (type instanceof _definition.GraphQLList) {
-	    var _ret = function () {
-	      var itemType = type.ofType;
-	      if (valueAST.kind === _kinds.LIST) {
-	        return {
-	          v: valueAST.values.reduce(function (acc, itemAST, index) {
-	            var errors = isValidLiteralValue(itemType, itemAST);
-	            return acc.concat(errors.map(function (error) {
-	              return 'In element #' + index + ': ' + error;
-	            }));
-	          }, [])
-	        };
-	      }
-	      return {
-	        v: isValidLiteralValue(itemType, valueAST)
-	      };
-	    }();
-
-	    if (typeof _ret === "object") return _ret.v;
-	  }
-
-	  // Input objects check each defined field and look for undefined fields.
-	  if (type instanceof _definition.GraphQLInputObjectType) {
-	    var _ret2 = function () {
-	      if (valueAST.kind !== _kinds.OBJECT) {
-	        return {
-	          v: ['Expected "' + type.name + '", found not an object.']
-	        };
-	      }
-	      var fields = type.getFields();
-
-	      var errors = [];
-
-	      // Ensure every provided field is defined.
-	      var fieldASTs = valueAST.fields;
-	      fieldASTs.forEach(function (providedFieldAST) {
-	        if (!fields[providedFieldAST.name.value]) {
-	          errors.push('In field "' + providedFieldAST.name.value + '": Unknown field.');
-	        }
-	      });
-
-	      // Ensure every defined field is valid.
-	      var fieldASTMap = (0, _keyMap2.default)(fieldASTs, function (fieldAST) {
-	        return fieldAST.name.value;
-	      });
-	      Object.keys(fields).forEach(function (fieldName) {
-	        var result = isValidLiteralValue(fields[fieldName].type, fieldASTMap[fieldName] && fieldASTMap[fieldName].value);
-	        errors.push.apply(errors, result.map(function (error) {
-	          return 'In field "' + fieldName + '": ' + error;
-	        }));
-	      });
-
-	      return {
-	        v: errors
-	      };
-	    }();
-
-	    if (typeof _ret2 === "object") return _ret2.v;
-	  }
-
-	  (0, _invariant2.default)(type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType, 'Must be input type');
-
-	  // Scalar/Enum input checks to ensure the type can parse the value to
-	  // a non-null value.
-	  var parseResult = type.parseLiteral(valueAST);
-	  if ((0, _isNullish2.default)(parseResult)) {
-	    return ['Expected type "' + type.name + '", found ' + (0, _printer.print)(valueAST) + '.'];
-	  }
-
-	  return [];
-	}
-
-/***/ },
-/* 238 */
-/***/ function(module, exports) {
-
-	"use strict";
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.default = keyMap;
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	/**
-	 * Creates a keyed JS object from an array, given a function to produce the keys
-	 * for each value in the array.
-	 *
-	 * This provides a convenient lookup for the array items if the key function
-	 * produces unique results.
-	 *
-	 *     const phoneBook = [
-	 *       { name: 'Jon', num: '555-1234' },
-	 *       { name: 'Jenny', num: '867-5309' }
-	 *     ]
-	 *
-	 *     // { Jon: { name: 'Jon', num: '555-1234' },
-	 *     //   Jenny: { name: 'Jenny', num: '867-5309' } }
-	 *     const entriesByName = keyMap(
-	 *       phoneBook,
-	 *       entry => entry.name
-	 *     )
-	 *
-	 *     // { name: 'Jenny', num: '857-6309' }
-	 *     const jennyEntry = entriesByName['Jenny']
-	 *
-	 */
-	function keyMap(list, keyFn) {
-	  return list.reduce(function (map, item) {
-	    return map[keyFn(item)] = item, map;
-	  }, {});
-	}
-
-/***/ },
-/* 239 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.missingFieldArgMessage = missingFieldArgMessage;
-	exports.missingDirectiveArgMessage = missingDirectiveArgMessage;
-	exports.ProvidedNonNullArguments = ProvidedNonNullArguments;
-
-	var _error = __webpack_require__(189);
-
-	var _keyMap = __webpack_require__(238);
-
-	var _keyMap2 = _interopRequireDefault(_keyMap);
-
-	var _definition = __webpack_require__(203);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function missingFieldArgMessage(fieldName, argName, type) {
-	  return 'Field "' + fieldName + '" argument "' + argName + '" of type ' + ('"' + String(type) + '" is required but not provided.');
-	}
-
-	function missingDirectiveArgMessage(directiveName, argName, type) {
-	  return 'Directive "@' + directiveName + '" argument "' + argName + '" of type ' + ('"' + String(type) + '" is required but not provided.');
-	}
-
-	/**
-	 * Provided required arguments
-	 *
-	 * A field or directive is only valid if all required (non-null) field arguments
-	 * have been provided.
-	 */
-	function ProvidedNonNullArguments(context) {
-	  return {
-	    Field: {
-	      // Validate on leave to allow for deeper errors to appear first.
-	      leave: function leave(fieldAST) {
-	        var fieldDef = context.getFieldDef();
-	        if (!fieldDef) {
-	          return false;
-	        }
-	        var argASTs = fieldAST.arguments || [];
-
-	        var argASTMap = (0, _keyMap2.default)(argASTs, function (arg) {
-	          return arg.name.value;
-	        });
-	        fieldDef.args.forEach(function (argDef) {
-	          var argAST = argASTMap[argDef.name];
-	          if (!argAST && argDef.type instanceof _definition.GraphQLNonNull) {
-	            context.reportError(new _error.GraphQLError(missingFieldArgMessage(fieldAST.name.value, argDef.name, argDef.type), [fieldAST]));
-	          }
-	        });
-	      }
-	    },
-
-	    Directive: {
-	      // Validate on leave to allow for deeper errors to appear first.
-	      leave: function leave(directiveAST) {
-	        var directiveDef = context.getDirective();
-	        if (!directiveDef) {
-	          return false;
-	        }
-	        var argASTs = directiveAST.arguments || [];
-
-	        var argASTMap = (0, _keyMap2.default)(argASTs, function (arg) {
-	          return arg.name.value;
-	        });
-	        directiveDef.args.forEach(function (argDef) {
-	          var argAST = argASTMap[argDef.name];
-	          if (!argAST && argDef.type instanceof _definition.GraphQLNonNull) {
-	            context.reportError(new _error.GraphQLError(missingDirectiveArgMessage(directiveAST.name.value, argDef.name, argDef.type), [directiveAST]));
-	          }
-	        });
-	      }
-	    }
-	  };
-	}
-
-/***/ },
-/* 240 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.defaultForNonNullArgMessage = defaultForNonNullArgMessage;
-	exports.badValueForDefaultArgMessage = badValueForDefaultArgMessage;
-	exports.DefaultValuesOfCorrectType = DefaultValuesOfCorrectType;
-
-	var _error = __webpack_require__(189);
-
-	var _printer = __webpack_require__(194);
-
-	var _definition = __webpack_require__(203);
-
-	var _isValidLiteralValue = __webpack_require__(237);
-
-	function defaultForNonNullArgMessage(varName, type, guessType) {
-	  return 'Variable "$' + varName + '" of type "' + String(type) + '" is required and ' + 'will not use the default value. ' + ('Perhaps you meant to use type "' + String(guessType) + '".');
-	}
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function badValueForDefaultArgMessage(varName, type, value, verboseErrors) {
-	  var message = verboseErrors ? '\n' + verboseErrors.join('\n') : '';
-	  return 'Variable "$' + varName + '" of type "' + String(type) + '" has invalid ' + ('default value ' + value + '.' + message);
-	}
-
-	/**
-	 * Variable default values of correct type
-	 *
-	 * A GraphQL document is only valid if all variable default values are of the
-	 * type expected by their definition.
-	 */
-	function DefaultValuesOfCorrectType(context) {
-	  return {
-	    VariableDefinition: function VariableDefinition(varDefAST) {
-	      var name = varDefAST.variable.name.value;
-	      var defaultValue = varDefAST.defaultValue;
-	      var type = context.getInputType();
-	      if (type instanceof _definition.GraphQLNonNull && defaultValue) {
-	        context.reportError(new _error.GraphQLError(defaultForNonNullArgMessage(name, type, type.ofType), [defaultValue]));
-	      }
-	      if (type && defaultValue) {
-	        var errors = (0, _isValidLiteralValue.isValidLiteralValue)(type, defaultValue);
-	        if (errors && errors.length > 0) {
-	          context.reportError(new _error.GraphQLError(badValueForDefaultArgMessage(name, type, (0, _printer.print)(defaultValue), errors), [defaultValue]));
-	        }
-	      }
-	      return false;
-	    },
-
-	    SelectionSet: function SelectionSet() {
-	      return false;
-	    },
-	    FragmentDefinition: function FragmentDefinition() {
-	      return false;
-	    }
-	  };
-	}
-
-/***/ },
-/* 241 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.badVarPosMessage = badVarPosMessage;
-	exports.VariablesInAllowedPosition = VariablesInAllowedPosition;
-
-	var _error = __webpack_require__(189);
-
-	var _definition = __webpack_require__(203);
-
-	var _typeComparators = __webpack_require__(212);
-
-	var _typeFromAST = __webpack_require__(214);
-
-	function badVarPosMessage(varName, varType, expectedType) {
-	  return 'Variable "$' + varName + '" of type "' + String(varType) + '" used in ' + ('position expecting type "' + String(expectedType) + '".');
-	}
-
-	/**
-	 * Variables passed to field arguments conform to type
-	 */
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function VariablesInAllowedPosition(context) {
-	  var varDefMap = Object.create(null);
-
-	  return {
-	    OperationDefinition: {
-	      enter: function enter() {
-	        varDefMap = Object.create(null);
-	      },
-	      leave: function leave(operation) {
-	        var usages = context.getRecursiveVariableUsages(operation);
-
-	        usages.forEach(function (_ref) {
-	          var node = _ref.node;
-	          var type = _ref.type;
-
-	          var varName = node.name.value;
-	          var varDef = varDefMap[varName];
-	          if (varDef && type) {
-	            // A var type is allowed if it is the same or more strict (e.g. is
-	            // a subtype of) than the expected type. It can be more strict if
-	            // the variable type is non-null when the expected type is nullable.
-	            // If both are list types, the variable item type can be more strict
-	            // than the expected item type (contravariant).
-	            var schema = context.getSchema();
-	            var varType = (0, _typeFromAST.typeFromAST)(schema, varDef.type);
-	            if (varType && !(0, _typeComparators.isTypeSubTypeOf)(schema, effectiveType(varType, varDef), type)) {
-	              context.reportError(new _error.GraphQLError(badVarPosMessage(varName, varType, type), [varDef, node]));
-	            }
-	          }
-	        });
-	      }
-	    },
-	    VariableDefinition: function VariableDefinition(varDefAST) {
-	      varDefMap[varDefAST.variable.name.value] = varDefAST;
-	    }
-	  };
-	}
-
-	// If a variable definition has a default value, it's effectively non-null.
-	function effectiveType(varType, varDef) {
-	  return !varDef.defaultValue || varType instanceof _definition.GraphQLNonNull ? varType : new _definition.GraphQLNonNull(varType);
-	}
-
-/***/ },
-/* 242 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.fieldsConflictMessage = fieldsConflictMessage;
-	exports.OverlappingFieldsCanBeMerged = OverlappingFieldsCanBeMerged;
-
-	var _error = __webpack_require__(189);
-
-	var _find = __webpack_require__(211);
-
-	var _find2 = _interopRequireDefault(_find);
-
-	var _kinds = __webpack_require__(196);
-
-	var _printer = __webpack_require__(194);
-
-	var _definition = __webpack_require__(203);
-
-	var _typeFromAST = __webpack_require__(214);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function fieldsConflictMessage(responseName, reason) {
-	  return 'Fields "' + responseName + '" conflict because ' + reasonMessage(reason) + '. Use different aliases on the fields to fetch both if this was ' + 'intentional.';
-	}
-
-	function reasonMessage(reason) {
-	  if (Array.isArray(reason)) {
-	    return reason.map(function (_ref) {
-	      var responseName = _ref[0];
-	      var subreason = _ref[1];
-	      return 'subfields "' + responseName + '" conflict because ' + reasonMessage(subreason);
-	    }).join(' and ');
-	  }
-	  return reason;
-	}
-
-	/**
-	 * Overlapping fields can be merged
-	 *
-	 * A selection set is only valid if all fields (including spreading any
-	 * fragments) either correspond to distinct response names or can be merged
-	 * without ambiguity.
-	 */
-	function OverlappingFieldsCanBeMerged(context) {
-	  // A memoization for when two fragments are compared "between" each other for
-	  // conflicts. Two fragments may be compared many times, so memoizing this can
-	  // dramatically improve the performance of this validator.
-	  var comparedFragments = new PairSet();
-
-	  // A cache for the "field map" and list of fragment names found in any given
-	  // selection set. Selection sets may be asked for this information multiple
-	  // times, so this improves the performance of this validator.
-	  var cachedFieldsAndFragmentNames = new Map();
-
-	  return {
-	    SelectionSet: function SelectionSet(selectionSet) {
-	      var conflicts = findConflictsWithinSelectionSet(context, cachedFieldsAndFragmentNames, comparedFragments, context.getParentType(), selectionSet);
-	      conflicts.forEach(function (_ref2) {
-	        var _ref2$ = _ref2[0];
-	        var responseName = _ref2$[0];
-	        var reason = _ref2$[1];
-	        var fields1 = _ref2[1];
-	        var fields2 = _ref2[2];
-	        return context.reportError(new _error.GraphQLError(fieldsConflictMessage(responseName, reason), fields1.concat(fields2)));
-	      });
-	    }
-	  };
-	}
-	// Field name and reason.
-
-	// Reason is a string, or a nested list of conflicts.
-
-	// Tuple defining an AST in a context
-
-	// Map of array of those.
-
-
-	/**
-	 * Algorithm:
-	 *
-	 * Conflicts occur when two fields exist in a query which will produce the same
-	 * response name, but represent differing values, thus creating a conflict.
-	 * The algorithm below finds all conflicts via making a series of comparisons
-	 * between fields. In order to compare as few fields as possible, this makes
-	 * a series of comparisons "within" sets of fields and "between" sets of fields.
-	 *
-	 * Given any selection set, a collection produces both a set of fields by
-	 * also including all inline fragments, as well as a list of fragments
-	 * referenced by fragment spreads.
-	 *
-	 * A) Each selection set represented in the document first compares "within" its
-	 * collected set of fields, finding any conflicts between every pair of
-	 * overlapping fields.
-	 * Note: This is the *only time* that a the fields "within" a set are compared
-	 * to each other. After this only fields "between" sets are compared.
-	 *
-	 * B) Also, if any fragment is referenced in a selection set, then a
-	 * comparison is made "between" the original set of fields and the
-	 * referenced fragment.
-	 *
-	 * C) Also, if multiple fragments are referenced, then comparisons
-	 * are made "between" each referenced fragment.
-	 *
-	 * D) When comparing "between" a set of fields and a referenced fragment, first
-	 * a comparison is made between each field in the original set of fields and
-	 * each field in the the referenced set of fields.
-	 *
-	 * E) Also, if any fragment is referenced in the referenced selection set,
-	 * then a comparison is made "between" the original set of fields and the
-	 * referenced fragment (recursively referring to step D).
-	 *
-	 * F) When comparing "between" two fragments, first a comparison is made between
-	 * each field in the first referenced set of fields and each field in the the
-	 * second referenced set of fields.
-	 *
-	 * G) Also, any fragments referenced by the first must be compared to the
-	 * second, and any fragments referenced by the second must be compared to the
-	 * first (recursively referring to step F).
-	 *
-	 * H) When comparing two fields, if both have selection sets, then a comparison
-	 * is made "between" both selection sets, first comparing the set of fields in
-	 * the first selection set with the set of fields in the second.
-	 *
-	 * I) Also, if any fragment is referenced in either selection set, then a
-	 * comparison is made "between" the other set of fields and the
-	 * referenced fragment.
-	 *
-	 * J) Also, if two fragments are referenced in both selection sets, then a
-	 * comparison is made "between" the two fragments.
-	 *
-	 */
-
-	// Find all conflicts found "within" a selection set, including those found
-	// via spreading in fragments. Called when visiting each SelectionSet in the
-	// GraphQL Document.
-	function findConflictsWithinSelectionSet(context, cachedFieldsAndFragmentNames, comparedFragments, parentType, selectionSet) {
-	  var conflicts = [];
-
-	  var _getFieldsAndFragment = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType, selectionSet);
-
-	  var fieldMap = _getFieldsAndFragment[0];
-	  var fragmentNames = _getFieldsAndFragment[1];
-
-	  // (A) Find find all conflicts "within" the fields of this selection set.
-	  // Note: this is the *only place* `collectConflictsWithin` is called.
-
-	  collectConflictsWithin(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, fieldMap);
-
-	  // (B) Then collect conflicts between these fields and those represented by
-	  // each spread fragment name found.
-	  for (var i = 0; i < fragmentNames.length; i++) {
-	    collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, false, fieldMap, fragmentNames[i]);
-	    // (C) Then compare this fragment with all other fragments found in this
-	    // selection set to collect conflicts between fragments spread together.
-	    // This compares each item in the list of fragment names to every other item
-	    // in that same list (except for itself).
-	    for (var j = i + 1; j < fragmentNames.length; j++) {
-	      collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, false, fragmentNames[i], fragmentNames[j]);
-	    }
-	  }
-	  return conflicts;
-	}
-
-	// Collect all conflicts found between a set of fields and a fragment reference
-	// including via spreading in any nested fragments.
-	function collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap, fragmentName) {
-	  var fragment = context.getFragment(fragmentName);
-	  if (!fragment) {
-	    return;
-	  }
-
-	  var _getReferencedFieldsA = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment);
-
-	  var fieldMap2 = _getReferencedFieldsA[0];
-	  var fragmentNames2 = _getReferencedFieldsA[1];
-
-	  // (D) First collect any conflicts between the provided collection of fields
-	  // and the collection of fields represented by the given fragment.
-
-	  collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap, fieldMap2);
-
-	  // (E) Then collect any conflicts between the provided collection of fields
-	  // and any fragment names found in the given fragment.
-	  for (var i = 0; i < fragmentNames2.length; i++) {
-	    collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap, fragmentNames2[i]);
-	  }
-	}
-
-	// Collect all conflicts found between two fragments, including via spreading in
-	// any nested fragments.
-	function collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fragmentName1, fragmentName2) {
-	  var fragment1 = context.getFragment(fragmentName1);
-	  var fragment2 = context.getFragment(fragmentName2);
-	  if (!fragment1 || !fragment2) {
-	    return;
-	  }
-
-	  // No need to compare a fragment to itself.
-	  if (fragment1 === fragment2) {
-	    return;
-	  }
-
-	  // Memoize so two fragments are not compared for conflicts more than once.
-	  if (comparedFragments.has(fragmentName1, fragmentName2, areMutuallyExclusive)) {
-	    return;
-	  }
-	  comparedFragments.add(fragmentName1, fragmentName2, areMutuallyExclusive);
-
-	  var _getReferencedFieldsA2 = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment1);
-
-	  var fieldMap1 = _getReferencedFieldsA2[0];
-	  var fragmentNames1 = _getReferencedFieldsA2[1];
-
-	  var _getReferencedFieldsA3 = getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment2);
-
-	  var fieldMap2 = _getReferencedFieldsA3[0];
-	  var fragmentNames2 = _getReferencedFieldsA3[1];
-
-	  // (F) First, collect all conflicts between these two collections of fields
-	  // (not including any nested fragments).
-
-	  collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap1, fieldMap2);
-
-	  // (G) Then collect conflicts between the first fragment and any nested
-	  // fragments spread in the second fragment.
-	  for (var j = 0; j < fragmentNames2.length; j++) {
-	    collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fragmentName1, fragmentNames2[j]);
-	  }
-
-	  // (G) Then collect conflicts between the second fragment and any nested
-	  // fragments spread in the first fragment.
-	  for (var i = 0; i < fragmentNames1.length; i++) {
-	    collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fragmentNames1[i], fragmentName2);
-	  }
-	}
-
-	// Find all conflicts found between two selection sets, including those found
-	// via spreading in fragments. Called when determining if conflicts exist
-	// between the sub-fields of two overlapping fields.
-	function findConflictsBetweenSubSelectionSets(context, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, parentType1, selectionSet1, parentType2, selectionSet2) {
-	  var conflicts = [];
-
-	  var _getFieldsAndFragment2 = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType1, selectionSet1);
-
-	  var fieldMap1 = _getFieldsAndFragment2[0];
-	  var fragmentNames1 = _getFieldsAndFragment2[1];
-
-	  var _getFieldsAndFragment3 = getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType2, selectionSet2);
-
-	  var fieldMap2 = _getFieldsAndFragment3[0];
-	  var fragmentNames2 = _getFieldsAndFragment3[1];
-
-	  // (H) First, collect all conflicts between these two collections of field.
-
-	  collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap1, fieldMap2);
-
-	  // (I) Then collect conflicts between the first collection of fields and
-	  // those referenced by each fragment name associated with the second.
-	  for (var j = 0; j < fragmentNames2.length; j++) {
-	    collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap1, fragmentNames2[j]);
-	  }
-
-	  // (I) Then collect conflicts between the second collection of fields and
-	  // those referenced by each fragment name associated with the first.
-	  for (var i = 0; i < fragmentNames1.length; i++) {
-	    collectConflictsBetweenFieldsAndFragment(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fieldMap2, fragmentNames1[i]);
-	  }
-
-	  // (J) Also collect conflicts between any fragment names by the first and
-	  // fragment names by the second. This compares each item in the first set of
-	  // names to each item in the second set of names.
-	  for (var _i = 0; _i < fragmentNames1.length; _i++) {
-	    for (var _j = 0; _j < fragmentNames2.length; _j++) {
-	      collectConflictsBetweenFragments(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, fragmentNames1[_i], fragmentNames2[_j]);
-	    }
-	  }
-	  return conflicts;
-	}
-
-	// Collect all Conflicts "within" one collection of fields.
-	function collectConflictsWithin(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, fieldMap) {
-	  // A field map is a keyed collection, where each key represents a response
-	  // name and the value at that key is a list of all fields which provide that
-	  // response name. For every response name, if there are multiple fields, they
-	  // must be compared to find a potential conflict.
-	  Object.keys(fieldMap).forEach(function (responseName) {
-	    var fields = fieldMap[responseName];
-	    // This compares every field in the list to every other field in this list
-	    // (except to itself). If the list only has one item, nothing needs to
-	    // be compared.
-	    if (fields.length > 1) {
-	      for (var i = 0; i < fields.length; i++) {
-	        for (var j = i + 1; j < fields.length; j++) {
-	          var conflict = findConflict(context, cachedFieldsAndFragmentNames, comparedFragments, false, // within one collection is never mutually exclusive
-	          responseName, fields[i], fields[j]);
-	          if (conflict) {
-	            conflicts.push(conflict);
-	          }
-	        }
-	      }
-	    }
-	  });
-	}
-
-	// Collect all Conflicts between two collections of fields. This is similar to,
-	// but different from the `collectConflictsWithin` function above. This check
-	// assumes that `collectConflictsWithin` has already been called on each
-	// provided collection of fields. This is true because this validator traverses
-	// each individual selection set.
-	function collectConflictsBetween(context, conflicts, cachedFieldsAndFragmentNames, comparedFragments, parentFieldsAreMutuallyExclusive, fieldMap1, fieldMap2) {
-	  // A field map is a keyed collection, where each key represents a response
-	  // name and the value at that key is a list of all fields which provide that
-	  // response name. For any response name which appears in both provided field
-	  // maps, each field from the first field map must be compared to every field
-	  // in the second field map to find potential conflicts.
-	  Object.keys(fieldMap1).forEach(function (responseName) {
-	    var fields2 = fieldMap2[responseName];
-	    if (fields2) {
-	      var fields1 = fieldMap1[responseName];
-	      for (var i = 0; i < fields1.length; i++) {
-	        for (var j = 0; j < fields2.length; j++) {
-	          var conflict = findConflict(context, cachedFieldsAndFragmentNames, comparedFragments, parentFieldsAreMutuallyExclusive, responseName, fields1[i], fields2[j]);
-	          if (conflict) {
-	            conflicts.push(conflict);
-	          }
-	        }
-	      }
-	    }
-	  });
-	}
-
-	// Determines if there is a conflict between two particular fields, including
-	// comparing their sub-fields.
-	function findConflict(context, cachedFieldsAndFragmentNames, comparedFragments, parentFieldsAreMutuallyExclusive, responseName, field1, field2) {
-	  var parentType1 = field1[0];
-	  var ast1 = field1[1];
-	  var def1 = field1[2];
-	  var parentType2 = field2[0];
-	  var ast2 = field2[1];
-	  var def2 = field2[2];
-
-	  // If it is known that two fields could not possibly apply at the same
-	  // time, due to the parent types, then it is safe to permit them to diverge
-	  // in aliased field or arguments used as they will not present any ambiguity
-	  // by differing.
-	  // It is known that two parent types could never overlap if they are
-	  // different Object types. Interface or Union types might overlap - if not
-	  // in the current state of the schema, then perhaps in some future version,
-	  // thus may not safely diverge.
-
-	  var areMutuallyExclusive = parentFieldsAreMutuallyExclusive || parentType1 !== parentType2 && parentType1 instanceof _definition.GraphQLObjectType && parentType2 instanceof _definition.GraphQLObjectType;
-
-	  // The return type for each field.
-	  var type1 = def1 && def1.type;
-	  var type2 = def2 && def2.type;
-
-	  if (!areMutuallyExclusive) {
-	    // Two aliases must refer to the same field.
-	    var name1 = ast1.name.value;
-	    var name2 = ast2.name.value;
-	    if (name1 !== name2) {
-	      return [[responseName, name1 + ' and ' + name2 + ' are different fields'], [ast1], [ast2]];
-	    }
-
-	    // Two field calls must have the same arguments.
-	    if (!sameArguments(ast1.arguments || [], ast2.arguments || [])) {
-	      return [[responseName, 'they have differing arguments'], [ast1], [ast2]];
-	    }
-	  }
-
-	  if (type1 && type2 && doTypesConflict(type1, type2)) {
-	    return [[responseName, 'they return conflicting types ' + String(type1) + ' and ' + String(type2)], [ast1], [ast2]];
-	  }
-
-	  // Collect and compare sub-fields. Use the same "visited fragment names" list
-	  // for both collections so fields in a fragment reference are never
-	  // compared to themselves.
-	  var selectionSet1 = ast1.selectionSet;
-	  var selectionSet2 = ast2.selectionSet;
-	  if (selectionSet1 && selectionSet2) {
-	    var conflicts = findConflictsBetweenSubSelectionSets(context, cachedFieldsAndFragmentNames, comparedFragments, areMutuallyExclusive, (0, _definition.getNamedType)(type1), selectionSet1, (0, _definition.getNamedType)(type2), selectionSet2);
-	    return subfieldConflicts(conflicts, responseName, ast1, ast2);
-	  }
-	}
-
-	function sameArguments(arguments1, arguments2) {
-	  if (arguments1.length !== arguments2.length) {
-	    return false;
-	  }
-	  return arguments1.every(function (argument1) {
-	    var argument2 = (0, _find2.default)(arguments2, function (argument) {
-	      return argument.name.value === argument1.name.value;
-	    });
-	    if (!argument2) {
-	      return false;
-	    }
-	    return sameValue(argument1.value, argument2.value);
-	  });
-	}
-
-	function sameValue(value1, value2) {
-	  return !value1 && !value2 || (0, _printer.print)(value1) === (0, _printer.print)(value2);
-	}
-
-	// Two types conflict if both types could not apply to a value simultaneously.
-	// Composite types are ignored as their individual field types will be compared
-	// later recursively. However List and Non-Null types must match.
-	function doTypesConflict(type1, type2) {
-	  if (type1 instanceof _definition.GraphQLList) {
-	    return type2 instanceof _definition.GraphQLList ? doTypesConflict(type1.ofType, type2.ofType) : true;
-	  }
-	  if (type2 instanceof _definition.GraphQLList) {
-	    return type1 instanceof _definition.GraphQLList ? doTypesConflict(type1.ofType, type2.ofType) : true;
-	  }
-	  if (type1 instanceof _definition.GraphQLNonNull) {
-	    return type2 instanceof _definition.GraphQLNonNull ? doTypesConflict(type1.ofType, type2.ofType) : true;
-	  }
-	  if (type2 instanceof _definition.GraphQLNonNull) {
-	    return type1 instanceof _definition.GraphQLNonNull ? doTypesConflict(type1.ofType, type2.ofType) : true;
-	  }
-	  if ((0, _definition.isLeafType)(type1) || (0, _definition.isLeafType)(type2)) {
-	    return type1 !== type2;
-	  }
-	  return false;
-	}
-
-	// Given a selection set, return the collection of fields (a mapping of response
-	// name to field ASTs and definitions) as well as a list of fragment names
-	// referenced via fragment spreads.
-	function getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, parentType, selectionSet) {
-	  var cached = cachedFieldsAndFragmentNames.get(selectionSet);
-	  if (!cached) {
-	    var astAndDefs = {};
-	    var fragmentNames = {};
-	    _collectFieldsAndFragmentNames(context, parentType, selectionSet, astAndDefs, fragmentNames);
-	    cached = [astAndDefs, Object.keys(fragmentNames)];
-	    cachedFieldsAndFragmentNames.set(selectionSet, cached);
-	  }
-	  return cached;
-	}
-
-	// Given a reference to a fragment, return the represented collection of fields
-	// as well as a list of nested fragment names referenced via fragment spreads.
-	function getReferencedFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragment) {
-	  // Short-circuit building a type from the AST if possible.
-	  var cached = cachedFieldsAndFragmentNames.get(fragment.selectionSet);
-	  if (cached) {
-	    return cached;
-	  }
-
-	  var fragmentType = (0, _typeFromAST.typeFromAST)(context.getSchema(), fragment.typeCondition);
-	  return getFieldsAndFragmentNames(context, cachedFieldsAndFragmentNames, fragmentType, fragment.selectionSet);
-	}
-
-	function _collectFieldsAndFragmentNames(context, parentType, selectionSet, astAndDefs, fragmentNames) {
-	  for (var i = 0; i < selectionSet.selections.length; i++) {
-	    var selection = selectionSet.selections[i];
-	    switch (selection.kind) {
-	      case _kinds.FIELD:
-	        var fieldName = selection.name.value;
-	        var fieldDef = void 0;
-	        if (parentType instanceof _definition.GraphQLObjectType || parentType instanceof _definition.GraphQLInterfaceType) {
-	          fieldDef = parentType.getFields()[fieldName];
-	        }
-	        var responseName = selection.alias ? selection.alias.value : fieldName;
-	        if (!astAndDefs[responseName]) {
-	          astAndDefs[responseName] = [];
-	        }
-	        astAndDefs[responseName].push([parentType, selection, fieldDef]);
-	        break;
-	      case _kinds.FRAGMENT_SPREAD:
-	        fragmentNames[selection.name.value] = true;
-	        break;
-	      case _kinds.INLINE_FRAGMENT:
-	        var typeCondition = selection.typeCondition;
-	        var inlineFragmentType = typeCondition ? (0, _typeFromAST.typeFromAST)(context.getSchema(), typeCondition) : parentType;
-	        _collectFieldsAndFragmentNames(context, inlineFragmentType, selection.selectionSet, astAndDefs, fragmentNames);
-	        break;
-	    }
-	  }
-	}
-
-	// Given a series of Conflicts which occurred between two sub-fields, generate
-	// a single Conflict.
-	function subfieldConflicts(conflicts, responseName, ast1, ast2) {
-	  if (conflicts.length > 0) {
-	    return [[responseName, conflicts.map(function (_ref3) {
-	      var reason = _ref3[0];
-	      return reason;
-	    })], conflicts.reduce(function (allFields, _ref4) {
-	      var fields1 = _ref4[1];
-	      return allFields.concat(fields1);
-	    }, [ast1]), conflicts.reduce(function (allFields, _ref5) {
-	      var fields2 = _ref5[2];
-	      return allFields.concat(fields2);
-	    }, [ast2])];
-	  }
-	}
-
-	/**
-	 * A way to keep track of pairs of things when the ordering of the pair does
-	 * not matter. We do this by maintaining a sort of double adjacency sets.
-	 */
-
-	var PairSet = function () {
-	  function PairSet() {
-	    _classCallCheck(this, PairSet);
-
-	    this._data = Object.create(null);
-	  }
-
-	  PairSet.prototype.has = function has(a, b, areMutuallyExclusive) {
-	    var first = this._data[a];
-	    var result = first && first[b];
-	    if (result === undefined) {
-	      return false;
-	    }
-	    // areMutuallyExclusive being false is a superset of being true,
-	    // hence if we want to know if this PairSet "has" these two with no
-	    // exclusivity, we have to ensure it was added as such.
-	    if (areMutuallyExclusive === false) {
-	      return result === false;
-	    }
-	    return true;
-	  };
-
-	  PairSet.prototype.add = function add(a, b, areMutuallyExclusive) {
-	    _pairSetAdd(this._data, a, b, areMutuallyExclusive);
-	    _pairSetAdd(this._data, b, a, areMutuallyExclusive);
-	  };
-
-	  return PairSet;
-	}();
-
-	function _pairSetAdd(data, a, b, areMutuallyExclusive) {
-	  var map = data[a];
-	  if (!map) {
-	    map = Object.create(null);
-	    data[a] = map;
-	  }
-	  map[b] = areMutuallyExclusive;
-	}
-
-/***/ },
-/* 243 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.duplicateInputFieldMessage = duplicateInputFieldMessage;
-	exports.UniqueInputFieldNames = UniqueInputFieldNames;
-
-	var _error = __webpack_require__(189);
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function duplicateInputFieldMessage(fieldName) {
-	  return 'There can be only one input field named "' + fieldName + '".';
-	}
-
-	/**
-	 * Unique input field names
-	 *
-	 * A GraphQL input object value is only valid if all supplied fields are
-	 * uniquely named.
-	 */
-	function UniqueInputFieldNames(context) {
-	  var knownNameStack = [];
-	  var knownNames = Object.create(null);
-
-	  return {
-	    ObjectValue: {
-	      enter: function enter() {
-	        knownNameStack.push(knownNames);
-	        knownNames = Object.create(null);
-	      },
-	      leave: function leave() {
-	        knownNames = knownNameStack.pop();
-	      }
-	    },
-	    ObjectField: function ObjectField(node) {
-	      var fieldName = node.name.value;
-	      if (knownNames[fieldName]) {
-	        context.reportError(new _error.GraphQLError(duplicateInputFieldMessage(fieldName), [knownNames[fieldName], node.name]));
-	      } else {
-	        knownNames[fieldName] = node.name;
-	      }
-	      return false;
-	    }
-	  };
-	}
-
-/***/ },
-/* 244 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.execute = execute;
-
-	var _iterall = __webpack_require__(210);
-
-	var _error = __webpack_require__(189);
-
-	var _find = __webpack_require__(211);
-
-	var _find2 = _interopRequireDefault(_find);
-
-	var _invariant = __webpack_require__(200);
-
-	var _invariant2 = _interopRequireDefault(_invariant);
-
-	var _isNullish = __webpack_require__(204);
-
-	var _isNullish2 = _interopRequireDefault(_isNullish);
-
-	var _typeFromAST = __webpack_require__(214);
-
-	var _kinds = __webpack_require__(196);
-
-	var Kind = _interopRequireWildcard(_kinds);
-
-	var _values = __webpack_require__(245);
-
-	var _definition = __webpack_require__(203);
-
-	var _schema = __webpack_require__(202);
-
-	var _introspection = __webpack_require__(208);
-
-	var _directives = __webpack_require__(206);
-
-	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 * Implements the "Evaluating requests" section of the GraphQL specification.
-	 *
-	 * Returns a Promise that will eventually be resolved and never rejected.
-	 *
-	 * If the arguments to this function do not result in a legal execution context,
-	 * a GraphQLError will be thrown immediately explaining the invalid input.
-	 */
-
-
-	/**
-	 * Terminology
-	 *
-	 * "Definitions" are the generic name for top-level statements in the document.
-	 * Examples of this include:
-	 * 1) Operations (such as a query)
-	 * 2) Fragments
-	 *
-	 * "Operations" are a generic name for requests in the document.
-	 * Examples of this include:
-	 * 1) query,
-	 * 2) mutation
-	 *
-	 * "Selections" are the definitions that can appear legally and at
-	 * single level of the query. These include:
-	 * 1) field references e.g "a"
-	 * 2) fragment "spreads" e.g. "...c"
-	 * 3) inline fragment "spreads" e.g. "...on Type { a }"
-	 */
-
-	/**
-	 * Data that must be available at all points during query execution.
-	 *
-	 * Namely, schema of the type system that is currently executing,
-	 * and the fragments defined in the query document
-	 */
-
-
-	/**
-	 * The result of execution. `data` is the result of executing the
-	 * query, `errors` is null if no errors occurred, and is a
-	 * non-empty array if an error occurred.
-	 */
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function execute(schema, documentAST, rootValue, contextValue, variableValues, operationName) {
-	  (0, _invariant2.default)(schema, 'Must provide schema');
-	  (0, _invariant2.default)(schema instanceof _schema.GraphQLSchema, 'Schema must be an instance of GraphQLSchema. Also ensure that there are ' + 'not multiple versions of GraphQL installed in your node_modules directory.');
-
-	  // Variables, if provided, must be an object.
-	  (0, _invariant2.default)(!variableValues || typeof variableValues === 'object', 'Variables must be provided as an Object where each property is a ' + 'variable value. Perhaps look to see if an unparsed JSON string ' + 'was provided.');
-
-	  // If a valid context cannot be created due to incorrect arguments,
-	  // this will throw an error.
-	  var context = buildExecutionContext(schema, documentAST, rootValue, contextValue, variableValues, operationName);
-
-	  // Return a Promise that will eventually resolve to the data described by
-	  // The "Response" section of the GraphQL specification.
-	  //
-	  // If errors are encountered while executing a GraphQL field, only that
-	  // field and its descendants will be omitted, and sibling fields will still
-	  // be executed. An execution which encounters errors will still result in a
-	  // resolved Promise.
-	  return new Promise(function (resolve) {
-	    resolve(executeOperation(context, context.operation, rootValue));
-	  }).then(undefined, function (error) {
-	    // Errors from sub-fields of a NonNull type may propagate to the top level,
-	    // at which point we still log the error and null the parent field, which
-	    // in this case is the entire response.
-	    context.errors.push(error);
-	    return null;
-	  }).then(function (data) {
-	    if (!context.errors.length) {
-	      return { data: data };
-	    }
-	    return { data: data, errors: context.errors };
-	  });
-	}
-
-	/**
-	 * Constructs a ExecutionContext object from the arguments passed to
-	 * execute, which we will pass throughout the other execution methods.
-	 *
-	 * Throws a GraphQLError if a valid execution context cannot be created.
-	 */
-	function buildExecutionContext(schema, documentAST, rootValue, contextValue, rawVariableValues, operationName) {
-	  var errors = [];
-	  var operation = void 0;
-	  var fragments = Object.create(null);
-	  documentAST.definitions.forEach(function (definition) {
-	    switch (definition.kind) {
-	      case Kind.OPERATION_DEFINITION:
-	        if (!operationName && operation) {
-	          throw new _error.GraphQLError('Must provide operation name if query contains multiple operations.');
-	        }
-	        if (!operationName || definition.name && definition.name.value === operationName) {
-	          operation = definition;
-	        }
-	        break;
-	      case Kind.FRAGMENT_DEFINITION:
-	        fragments[definition.name.value] = definition;
-	        break;
-	      default:
-	        throw new _error.GraphQLError('GraphQL cannot execute a request containing a ' + definition.kind + '.', [definition]);
-	    }
-	  });
-	  if (!operation) {
-	    if (operationName) {
-	      throw new _error.GraphQLError('Unknown operation named "' + operationName + '".');
-	    } else {
-	      throw new _error.GraphQLError('Must provide an operation.');
-	    }
-	  }
-	  var variableValues = (0, _values.getVariableValues)(schema, operation.variableDefinitions || [], rawVariableValues || {});
-
-	  return {
-	    schema: schema,
-	    fragments: fragments,
-	    rootValue: rootValue,
-	    contextValue: contextValue,
-	    operation: operation,
-	    variableValues: variableValues,
-	    errors: errors
-	  };
-	}
-
-	/**
-	 * Implements the "Evaluating operations" section of the spec.
-	 */
-	function executeOperation(exeContext, operation, rootValue) {
-	  var type = getOperationRootType(exeContext.schema, operation);
-	  var fields = collectFields(exeContext, type, operation.selectionSet, Object.create(null), Object.create(null));
-
-	  var path = [];
-
-	  if (operation.operation === 'mutation') {
-	    return executeFieldsSerially(exeContext, type, rootValue, path, fields);
-	  }
-	  return executeFields(exeContext, type, rootValue, path, fields);
-	}
-
-	/**
-	 * Extracts the root type of the operation from the schema.
-	 */
-	function getOperationRootType(schema, operation) {
-	  switch (operation.operation) {
-	    case 'query':
-	      return schema.getQueryType();
-	    case 'mutation':
-	      var mutationType = schema.getMutationType();
-	      if (!mutationType) {
-	        throw new _error.GraphQLError('Schema is not configured for mutations', [operation]);
-	      }
-	      return mutationType;
-	    case 'subscription':
-	      var subscriptionType = schema.getSubscriptionType();
-	      if (!subscriptionType) {
-	        throw new _error.GraphQLError('Schema is not configured for subscriptions', [operation]);
-	      }
-	      return subscriptionType;
-	    default:
-	      throw new _error.GraphQLError('Can only execute queries, mutations and subscriptions', [operation]);
-	  }
-	}
-
-	/**
-	 * Implements the "Evaluating selection sets" section of the spec
-	 * for "write" mode.
-	 */
-	function executeFieldsSerially(exeContext, parentType, sourceValue, path, fields) {
-	  return Object.keys(fields).reduce(function (prevPromise, responseName) {
-	    return prevPromise.then(function (results) {
-	      var fieldASTs = fields[responseName];
-	      var fieldPath = path.concat([responseName]);
-	      var result = resolveField(exeContext, parentType, sourceValue, fieldASTs, fieldPath);
-	      if (result === undefined) {
-	        return results;
-	      }
-	      if (isThenable(result)) {
-	        return result.then(function (resolvedResult) {
-	          results[responseName] = resolvedResult;
-	          return results;
-	        });
-	      }
-	      results[responseName] = result;
-	      return results;
-	    });
-	  }, Promise.resolve({}));
-	}
-
-	/**
-	 * Implements the "Evaluating selection sets" section of the spec
-	 * for "read" mode.
-	 */
-	function executeFields(exeContext, parentType, sourceValue, path, fields) {
-	  var containsPromise = false;
-
-	  var finalResults = Object.keys(fields).reduce(function (results, responseName) {
-	    var fieldASTs = fields[responseName];
-	    var fieldPath = path.concat([responseName]);
-	    var result = resolveField(exeContext, parentType, sourceValue, fieldASTs, fieldPath);
-	    if (result === undefined) {
-	      return results;
-	    }
-	    results[responseName] = result;
-	    if (isThenable(result)) {
-	      containsPromise = true;
-	    }
-	    return results;
-	  }, Object.create(null));
-
-	  // If there are no promises, we can just return the object
-	  if (!containsPromise) {
-	    return finalResults;
-	  }
-
-	  // Otherwise, results is a map from field name to the result
-	  // of resolving that field, which is possibly a promise. Return
-	  // a promise that will return this same map, but with any
-	  // promises replaced with the values they resolved to.
-	  return promiseForObject(finalResults);
-	}
-
-	/**
-	 * Given a selectionSet, adds all of the fields in that selection to
-	 * the passed in map of fields, and returns it at the end.
-	 *
-	 * CollectFields requires the "runtime type" of an object. For a field which
-	 * returns and Interface or Union type, the "runtime type" will be the actual
-	 * Object type returned by that field.
-	 */
-	function collectFields(exeContext, runtimeType, selectionSet, fields, visitedFragmentNames) {
-	  for (var i = 0; i < selectionSet.selections.length; i++) {
-	    var selection = selectionSet.selections[i];
-	    switch (selection.kind) {
-	      case Kind.FIELD:
-	        if (!shouldIncludeNode(exeContext, selection.directives)) {
-	          continue;
-	        }
-	        var _name = getFieldEntryKey(selection);
-	        if (!fields[_name]) {
-	          fields[_name] = [];
-	        }
-	        fields[_name].push(selection);
-	        break;
-	      case Kind.INLINE_FRAGMENT:
-	        if (!shouldIncludeNode(exeContext, selection.directives) || !doesFragmentConditionMatch(exeContext, selection, runtimeType)) {
-	          continue;
-	        }
-	        collectFields(exeContext, runtimeType, selection.selectionSet, fields, visitedFragmentNames);
-	        break;
-	      case Kind.FRAGMENT_SPREAD:
-	        var fragName = selection.name.value;
-	        if (visitedFragmentNames[fragName] || !shouldIncludeNode(exeContext, selection.directives)) {
-	          continue;
-	        }
-	        visitedFragmentNames[fragName] = true;
-	        var fragment = exeContext.fragments[fragName];
-	        if (!fragment || !doesFragmentConditionMatch(exeContext, fragment, runtimeType)) {
-	          continue;
-	        }
-	        collectFields(exeContext, runtimeType, fragment.selectionSet, fields, visitedFragmentNames);
-	        break;
-	    }
-	  }
-	  return fields;
-	}
-
-	/**
-	 * Determines if a field should be included based on the @include and @skip
-	 * directives, where @skip has higher precidence than @include.
-	 */
-	function shouldIncludeNode(exeContext, directives) {
-	  var skipAST = directives && (0, _find2.default)(directives, function (directive) {
-	    return directive.name.value === _directives.GraphQLSkipDirective.name;
-	  });
-	  if (skipAST) {
-	    var _getArgumentValues = (0, _values.getArgumentValues)(_directives.GraphQLSkipDirective.args, skipAST.arguments, exeContext.variableValues);
-
-	    var skipIf = _getArgumentValues.if;
-
-	    if (skipIf === true) {
-	      return false;
-	    }
-	  }
-
-	  var includeAST = directives && (0, _find2.default)(directives, function (directive) {
-	    return directive.name.value === _directives.GraphQLIncludeDirective.name;
-	  });
-	  if (includeAST) {
-	    var _getArgumentValues2 = (0, _values.getArgumentValues)(_directives.GraphQLIncludeDirective.args, includeAST.arguments, exeContext.variableValues);
-
-	    var includeIf = _getArgumentValues2.if;
-
-	    if (includeIf === false) {
-	      return false;
-	    }
-	  }
-
-	  return true;
-	}
-
-	/**
-	 * Determines if a fragment is applicable to the given type.
-	 */
-	function doesFragmentConditionMatch(exeContext, fragment, type) {
-	  var typeConditionAST = fragment.typeCondition;
-	  if (!typeConditionAST) {
-	    return true;
-	  }
-	  var conditionalType = (0, _typeFromAST.typeFromAST)(exeContext.schema, typeConditionAST);
-	  if (conditionalType === type) {
-	    return true;
-	  }
-	  if ((0, _definition.isAbstractType)(conditionalType)) {
-	    var abstractType = conditionalType;
-	    return exeContext.schema.isPossibleType(abstractType, type);
-	  }
-	  return false;
-	}
-
-	/**
-	 * This function transforms a JS object `{[key: string]: Promise<T>}` into
-	 * a `Promise<{[key: string]: T}>`
-	 *
-	 * This is akin to bluebird's `Promise.props`, but implemented only using
-	 * `Promise.all` so it will work with any implementation of ES6 promises.
-	 */
-	function promiseForObject(object) {
-	  var keys = Object.keys(object);
-	  var valuesAndPromises = keys.map(function (name) {
-	    return object[name];
-	  });
-	  return Promise.all(valuesAndPromises).then(function (values) {
-	    return values.reduce(function (resolvedObject, value, i) {
-	      resolvedObject[keys[i]] = value;
-	      return resolvedObject;
-	    }, Object.create(null));
-	  });
-	}
-
-	/**
-	 * Implements the logic to compute the key of a given field's entry
-	 */
-	function getFieldEntryKey(node) {
-	  return node.alias ? node.alias.value : node.name.value;
-	}
-
-	/**
-	 * Resolves the field on the given source object. In particular, this
-	 * figures out the value that the field returns by calling its resolve function,
-	 * then calls completeValue to complete promises, serialize scalars, or execute
-	 * the sub-selection-set for objects.
-	 */
-	function resolveField(exeContext, parentType, source, fieldASTs, path) {
-	  var fieldAST = fieldASTs[0];
-	  var fieldName = fieldAST.name.value;
-
-	  var fieldDef = getFieldDef(exeContext.schema, parentType, fieldName);
-	  if (!fieldDef) {
-	    return;
-	  }
-
-	  var returnType = fieldDef.type;
-	  var resolveFn = fieldDef.resolve || defaultResolveFn;
-
-	  // Build a JS object of arguments from the field.arguments AST, using the
-	  // variables scope to fulfill any variable references.
-	  // TODO: find a way to memoize, in case this field is within a List type.
-	  var args = (0, _values.getArgumentValues)(fieldDef.args, fieldAST.arguments, exeContext.variableValues);
-
-	  // The resolve function's optional third argument is a context value that
-	  // is provided to every resolve function within an execution. It is commonly
-	  // used to represent an authenticated user, or request-specific caches.
-	  var context = exeContext.contextValue;
-
-	  // The resolve function's optional fourth argument is a collection of
-	  // information about the current execution state.
-	  var info = {
-	    fieldName: fieldName,
-	    fieldASTs: fieldASTs,
-	    returnType: returnType,
-	    parentType: parentType,
-	    path: path,
-	    schema: exeContext.schema,
-	    fragments: exeContext.fragments,
-	    rootValue: exeContext.rootValue,
-	    operation: exeContext.operation,
-	    variableValues: exeContext.variableValues
-	  };
-
-	  // Get the resolve function, regardless of if its result is normal
-	  // or abrupt (error).
-	  var result = resolveOrError(resolveFn, source, args, context, info);
-
-	  return completeValueCatchingError(exeContext, returnType, fieldASTs, info, path, result);
-	}
-
-	// Isolates the "ReturnOrAbrupt" behavior to not de-opt the `resolveField`
-	// function. Returns the result of resolveFn or the abrupt-return Error object.
-	function resolveOrError(resolveFn, source, args, context, info) {
-	  try {
-	    return resolveFn(source, args, context, info);
-	  } catch (error) {
-	    // Sometimes a non-error is thrown, wrap it as an Error for a
-	    // consistent interface.
-	    return error instanceof Error ? error : new Error(error);
-	  }
-	}
-
-	// This is a small wrapper around completeValue which detects and logs errors
-	// in the execution context.
-	function completeValueCatchingError(exeContext, returnType, fieldASTs, info, path, result) {
-	  // If the field type is non-nullable, then it is resolved without any
-	  // protection from errors, however it still properly locates the error.
-	  if (returnType instanceof _definition.GraphQLNonNull) {
-	    return completeValueWithLocatedError(exeContext, returnType, fieldASTs, info, path, result);
-	  }
-
-	  // Otherwise, error protection is applied, logging the error and resolving
-	  // a null value for this field if one is encountered.
-	  try {
-	    var completed = completeValueWithLocatedError(exeContext, returnType, fieldASTs, info, path, result);
-	    if (isThenable(completed)) {
-	      // If `completeValueWithLocatedError` returned a rejected promise, log
-	      // the rejection error and resolve to null.
-	      // Note: we don't rely on a `catch` method, but we do expect "thenable"
-	      // to take a second callback for the error case.
-	      return completed.then(undefined, function (error) {
-	        exeContext.errors.push(error);
-	        return Promise.resolve(null);
-	      });
-	    }
-	    return completed;
-	  } catch (error) {
-	    // If `completeValueWithLocatedError` returned abruptly (threw an error),
-	    // log the error and return null.
-	    exeContext.errors.push(error);
-	    return null;
-	  }
-	}
-
-	// This is a small wrapper around completeValue which annotates errors with
-	// location information.
-	function completeValueWithLocatedError(exeContext, returnType, fieldASTs, info, path, result) {
-	  try {
-	    var completed = completeValue(exeContext, returnType, fieldASTs, info, path, result);
-	    if (isThenable(completed)) {
-	      return completed.then(undefined, function (error) {
-	        return Promise.reject((0, _error.locatedError)(error, fieldASTs, path));
-	      });
-	    }
-	    return completed;
-	  } catch (error) {
-	    throw (0, _error.locatedError)(error, fieldASTs, path);
-	  }
-	}
-
-	/**
-	 * Implements the instructions for completeValue as defined in the
-	 * "Field entries" section of the spec.
-	 *
-	 * If the field type is Non-Null, then this recursively completes the value
-	 * for the inner type. It throws a field error if that completion returns null,
-	 * as per the "Nullability" section of the spec.
-	 *
-	 * If the field type is a List, then this recursively completes the value
-	 * for the inner type on each item in the list.
-	 *
-	 * If the field type is a Scalar or Enum, ensures the completed value is a legal
-	 * value of the type by calling the `serialize` method of GraphQL type
-	 * definition.
-	 *
-	 * If the field is an abstract type, determine the runtime type of the value
-	 * and then complete based on that type
-	 *
-	 * Otherwise, the field type expects a sub-selection set, and will complete the
-	 * value by evaluating all sub-selections.
-	 */
-	function completeValue(exeContext, returnType, fieldASTs, info, path, result) {
-	  // If result is a Promise, apply-lift over completeValue.
-	  if (isThenable(result)) {
-	    return result.then(function (resolved) {
-	      return completeValue(exeContext, returnType, fieldASTs, info, path, resolved);
-	    });
-	  }
-
-	  // If result is an Error, throw a located error.
-	  if (result instanceof Error) {
-	    throw result;
-	  }
-
-	  // If field type is NonNull, complete for inner type, and throw field error
-	  // if result is null.
-	  if (returnType instanceof _definition.GraphQLNonNull) {
-	    var completed = completeValue(exeContext, returnType.ofType, fieldASTs, info, path, result);
-	    if (completed === null) {
-	      throw new Error('Cannot return null for non-nullable field ' + info.parentType.name + '.' + info.fieldName + '.');
-	    }
-	    return completed;
-	  }
-
-	  // If result value is null-ish (null, undefined, or NaN) then return null.
-	  if ((0, _isNullish2.default)(result)) {
-	    return null;
-	  }
-
-	  // If field type is List, complete each item in the list with the inner type
-	  if (returnType instanceof _definition.GraphQLList) {
-	    return completeListValue(exeContext, returnType, fieldASTs, info, path, result);
-	  }
-
-	  // If field type is a leaf type, Scalar or Enum, serialize to a valid value,
-	  // returning null if serialization is not possible.
-	  if (returnType instanceof _definition.GraphQLScalarType || returnType instanceof _definition.GraphQLEnumType) {
-	    return completeLeafValue(returnType, result);
-	  }
-
-	  // If field type is an abstract type, Interface or Union, determine the
-	  // runtime Object type and complete for that type.
-	  if (returnType instanceof _definition.GraphQLInterfaceType || returnType instanceof _definition.GraphQLUnionType) {
-	    return completeAbstractValue(exeContext, returnType, fieldASTs, info, path, result);
-	  }
-
-	  // If field type is Object, execute and complete all sub-selections.
-	  if (returnType instanceof _definition.GraphQLObjectType) {
-	    return completeObjectValue(exeContext, returnType, fieldASTs, info, path, result);
-	  }
-
-	  // Not reachable. All possible output types have been considered.
-	  throw new Error('Cannot complete value of unexpected type "' + String(returnType) + '".');
-	}
-
-	/**
-	 * Complete a list value by completing each item in the list with the
-	 * inner type
-	 */
-	function completeListValue(exeContext, returnType, fieldASTs, info, path, result) {
-	  (0, _invariant2.default)((0, _iterall.isCollection)(result), 'Expected Iterable, but did not find one for field ' + info.parentType.name + '.' + info.fieldName + '.');
-
-	  // This is specified as a simple map, however we're optimizing the path
-	  // where the list contains no Promises by avoiding creating another Promise.
-	  var itemType = returnType.ofType;
-	  var containsPromise = false;
-	  var completedResults = [];
-	  (0, _iterall.forEach)(result, function (item, index) {
-	    // No need to modify the info object containing the path,
-	    // since from here on it is not ever accessed by resolver functions.
-	    var fieldPath = path.concat([index]);
-	    var completedItem = completeValueCatchingError(exeContext, itemType, fieldASTs, info, fieldPath, item);
-
-	    if (!containsPromise && isThenable(completedItem)) {
-	      containsPromise = true;
-	    }
-	    completedResults.push(completedItem);
-	  });
-
-	  return containsPromise ? Promise.all(completedResults) : completedResults;
-	}
-
-	/**
-	 * Complete a Scalar or Enum by serializing to a valid value, returning
-	 * null if serialization is not possible.
-	 */
-	function completeLeafValue(returnType, result) {
-	  (0, _invariant2.default)(returnType.serialize, 'Missing serialize method on type');
-	  var serializedResult = returnType.serialize(result);
-	  if ((0, _isNullish2.default)(serializedResult)) {
-	    throw new Error('Expected a value of type "' + String(returnType) + '" but ' + ('received: ' + String(result)));
-	  }
-	  return serializedResult;
-	}
-
-	/**
-	 * Complete a value of an abstract type by determining the runtime object type
-	 * of that value, then complete the value for that type.
-	 */
-	function completeAbstractValue(exeContext, returnType, fieldASTs, info, path, result) {
-	  var runtimeType = returnType.resolveType ? returnType.resolveType(result, exeContext.contextValue, info) : defaultResolveTypeFn(result, exeContext.contextValue, info, returnType);
-
-	  // If resolveType returns a string, we assume it's a GraphQLObjectType name.
-	  if (typeof runtimeType === 'string') {
-	    runtimeType = exeContext.schema.getType(runtimeType);
-	  }
-
-	  if (!(runtimeType instanceof _definition.GraphQLObjectType)) {
-	    throw new _error.GraphQLError('Abstract type ' + returnType.name + ' must resolve to an Object type at ' + ('runtime for field ' + info.parentType.name + '.' + info.fieldName + ' with ') + ('value "' + String(result) + '", received "' + String(runtimeType) + '".'), fieldASTs);
-	  }
-
-	  if (!exeContext.schema.isPossibleType(returnType, runtimeType)) {
-	    throw new _error.GraphQLError('Runtime Object type "' + runtimeType.name + '" is not a possible type ' + ('for "' + returnType.name + '".'), fieldASTs);
-	  }
-
-	  return completeObjectValue(exeContext, runtimeType, fieldASTs, info, path, result);
-	}
-
-	/**
-	 * Complete an Object value by executing all sub-selections.
-	 */
-	function completeObjectValue(exeContext, returnType, fieldASTs, info, path, result) {
-	  // If there is an isTypeOf predicate function, call it with the
-	  // current result. If isTypeOf returns false, then raise an error rather
-	  // than continuing execution.
-	  if (returnType.isTypeOf && !returnType.isTypeOf(result, exeContext.contextValue, info)) {
-	    throw new _error.GraphQLError('Expected value of type "' + returnType.name + '" but got: ' + String(result) + '.', fieldASTs);
-	  }
-
-	  // Collect sub-fields to execute to complete this value.
-	  var subFieldASTs = Object.create(null);
-	  var visitedFragmentNames = Object.create(null);
-	  for (var i = 0; i < fieldASTs.length; i++) {
-	    var selectionSet = fieldASTs[i].selectionSet;
-	    if (selectionSet) {
-	      subFieldASTs = collectFields(exeContext, returnType, selectionSet, subFieldASTs, visitedFragmentNames);
-	    }
-	  }
-
-	  return executeFields(exeContext, returnType, result, path, subFieldASTs);
-	}
-
-	/**
-	 * If a resolveType function is not given, then a default resolve behavior is
-	 * used which tests each possible type for the abstract type by calling
-	 * isTypeOf for the object being coerced, returning the first type that matches.
-	 */
-	function defaultResolveTypeFn(value, context, info, abstractType) {
-	  var possibleTypes = info.schema.getPossibleTypes(abstractType);
-	  for (var i = 0; i < possibleTypes.length; i++) {
-	    var type = possibleTypes[i];
-	    if (type.isTypeOf && type.isTypeOf(value, context, info)) {
-	      return type;
-	    }
-	  }
-	}
-
-	/**
-	 * If a resolve function is not given, then a default resolve behavior is used
-	 * which takes the property of the source object of the same name as the field
-	 * and returns it as the result, or if it's a function, returns the result
-	 * of calling that function while passing along args and context.
-	 */
-	function defaultResolveFn(source, args, context, _ref) {
-	  var fieldName = _ref.fieldName;
-
-	  // ensure source is a value for which property access is acceptable.
-	  if (typeof source === 'object' || typeof source === 'function') {
-	    var property = source[fieldName];
-	    if (typeof property === 'function') {
-	      return source[fieldName](args, context);
-	    }
-	    return property;
-	  }
-	}
-
-	/**
-	 * Checks to see if this object acts like a Promise, i.e. has a "then"
-	 * function.
-	 */
-	function isThenable(value) {
-	  return typeof value === 'object' && value !== null && typeof value.then === 'function';
-	}
-
-	/**
-	 * This method looks up the field on the given type defintion.
-	 * It has special casing for the two introspection fields, __schema
-	 * and __typename. __typename is special because it can always be
-	 * queried as a field, even in situations where no other fields
-	 * are allowed, like on a Union. __schema could get automatically
-	 * added to the query type, but that would require mutating type
-	 * definitions, which would cause issues.
-	 */
-	function getFieldDef(schema, parentType, fieldName) {
-	  if (fieldName === _introspection.SchemaMetaFieldDef.name && schema.getQueryType() === parentType) {
-	    return _introspection.SchemaMetaFieldDef;
-	  } else if (fieldName === _introspection.TypeMetaFieldDef.name && schema.getQueryType() === parentType) {
-	    return _introspection.TypeMetaFieldDef;
-	  } else if (fieldName === _introspection.TypeNameMetaFieldDef.name) {
-	    return _introspection.TypeNameMetaFieldDef;
-	  }
-	  return parentType.getFields()[fieldName];
-	}
-
-/***/ },
-/* 245 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.getVariableValues = getVariableValues;
-	exports.getArgumentValues = getArgumentValues;
-
-	var _iterall = __webpack_require__(210);
-
-	var _error = __webpack_require__(189);
-
-	var _invariant = __webpack_require__(200);
-
-	var _invariant2 = _interopRequireDefault(_invariant);
-
-	var _isNullish = __webpack_require__(204);
-
-	var _isNullish2 = _interopRequireDefault(_isNullish);
-
-	var _keyMap = __webpack_require__(238);
-
-	var _keyMap2 = _interopRequireDefault(_keyMap);
-
-	var _typeFromAST = __webpack_require__(214);
-
-	var _valueFromAST = __webpack_require__(246);
-
-	var _isValidJSValue = __webpack_require__(247);
-
-	var _printer = __webpack_require__(194);
-
-	var _definition = __webpack_require__(203);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 * Prepares an object map of variableValues of the correct type based on the
-	 * provided variable definitions and arbitrary input. If the input cannot be
-	 * parsed to match the variable definitions, a GraphQLError will be thrown.
-	 */
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function getVariableValues(schema, definitionASTs, inputs) {
-	  return definitionASTs.reduce(function (values, defAST) {
-	    var varName = defAST.variable.name.value;
-	    values[varName] = getVariableValue(schema, defAST, inputs[varName]);
-	    return values;
-	  }, {});
-	}
-
-	/**
-	 * Prepares an object map of argument values given a list of argument
-	 * definitions and list of argument AST nodes.
-	 */
-	function getArgumentValues(argDefs, argASTs, variableValues) {
-	  if (!argDefs || !argASTs) {
-	    return {};
-	  }
-	  var argASTMap = (0, _keyMap2.default)(argASTs, function (arg) {
-	    return arg.name.value;
-	  });
-	  return argDefs.reduce(function (result, argDef) {
-	    var name = argDef.name;
-	    var valueAST = argASTMap[name] ? argASTMap[name].value : null;
-	    var value = (0, _valueFromAST.valueFromAST)(valueAST, argDef.type, variableValues);
-	    if ((0, _isNullish2.default)(value)) {
-	      value = argDef.defaultValue;
-	    }
-	    if (!(0, _isNullish2.default)(value)) {
-	      result[name] = value;
-	    }
-	    return result;
-	  }, {});
-	}
-
-	/**
-	 * Given a variable definition, and any value of input, return a value which
-	 * adheres to the variable definition, or throw an error.
-	 */
-	function getVariableValue(schema, definitionAST, input) {
-	  var type = (0, _typeFromAST.typeFromAST)(schema, definitionAST.type);
-	  var variable = definitionAST.variable;
-	  if (!type || !(0, _definition.isInputType)(type)) {
-	    throw new _error.GraphQLError('Variable "$' + variable.name.value + '" expected value of type ' + ('"' + (0, _printer.print)(definitionAST.type) + '" which cannot be used as an input type.'), [definitionAST]);
-	  }
-	  var inputType = type;
-	  var errors = (0, _isValidJSValue.isValidJSValue)(input, inputType);
-	  if (!errors.length) {
-	    if ((0, _isNullish2.default)(input)) {
-	      var defaultValue = definitionAST.defaultValue;
-	      if (defaultValue) {
-	        return (0, _valueFromAST.valueFromAST)(defaultValue, inputType);
-	      }
-	    }
-	    return coerceValue(inputType, input);
-	  }
-	  if ((0, _isNullish2.default)(input)) {
-	    throw new _error.GraphQLError('Variable "$' + variable.name.value + '" of required type ' + ('"' + (0, _printer.print)(definitionAST.type) + '" was not provided.'), [definitionAST]);
-	  }
-	  var message = errors ? '\n' + errors.join('\n') : '';
-	  throw new _error.GraphQLError('Variable "$' + variable.name.value + '" got invalid value ' + (JSON.stringify(input) + '.' + message), [definitionAST]);
-	}
-
-	/**
-	 * Given a type and any value, return a runtime value coerced to match the type.
-	 */
-	function coerceValue(type, value) {
-	  // Ensure flow knows that we treat function params as const.
-	  var _value = value;
-
-	  if (type instanceof _definition.GraphQLNonNull) {
-	    // Note: we're not checking that the result of coerceValue is non-null.
-	    // We only call this function after calling isValidJSValue.
-	    return coerceValue(type.ofType, _value);
-	  }
-
-	  if ((0, _isNullish2.default)(_value)) {
-	    return null;
-	  }
-
-	  if (type instanceof _definition.GraphQLList) {
-	    var _ret = function () {
-	      var itemType = type.ofType;
-	      if ((0, _iterall.isCollection)(_value)) {
-	        var _ret2 = function () {
-	          var coercedValues = [];
-	          (0, _iterall.forEach)(_value, function (item) {
-	            coercedValues.push(coerceValue(itemType, item));
-	          });
-	          return {
-	            v: {
-	              v: coercedValues
-	            }
-	          };
-	        }();
-
-	        if (typeof _ret2 === "object") return _ret2.v;
-	      }
-	      return {
-	        v: [coerceValue(itemType, _value)]
-	      };
-	    }();
-
-	    if (typeof _ret === "object") return _ret.v;
-	  }
-
-	  if (type instanceof _definition.GraphQLInputObjectType) {
-	    var _ret3 = function () {
-	      if (typeof _value !== 'object' || _value === null) {
-	        return {
-	          v: null
-	        };
-	      }
-	      var fields = type.getFields();
-	      return {
-	        v: Object.keys(fields).reduce(function (obj, fieldName) {
-	          var field = fields[fieldName];
-	          var fieldValue = coerceValue(field.type, _value[fieldName]);
-	          if ((0, _isNullish2.default)(fieldValue)) {
-	            fieldValue = field.defaultValue;
-	          }
-	          if (!(0, _isNullish2.default)(fieldValue)) {
-	            obj[fieldName] = fieldValue;
-	          }
-	          return obj;
-	        }, {})
-	      };
-	    }();
-
-	    if (typeof _ret3 === "object") return _ret3.v;
-	  }
-
-	  (0, _invariant2.default)(type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType, 'Must be input type');
-
-	  var parsed = type.parseValue(_value);
-	  if (!(0, _isNullish2.default)(parsed)) {
-	    return parsed;
-	  }
-	}
-
-/***/ },
-/* 246 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.valueFromAST = valueFromAST;
-
-	var _keyMap = __webpack_require__(238);
-
-	var _keyMap2 = _interopRequireDefault(_keyMap);
-
-	var _invariant = __webpack_require__(200);
-
-	var _invariant2 = _interopRequireDefault(_invariant);
-
-	var _isNullish = __webpack_require__(204);
-
-	var _isNullish2 = _interopRequireDefault(_isNullish);
-
-	var _kinds = __webpack_require__(196);
-
-	var Kind = _interopRequireWildcard(_kinds);
-
-	var _definition = __webpack_require__(203);
-
-	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 * Produces a JavaScript value given a GraphQL Value AST.
-	 *
-	 * A GraphQL type must be provided, which will be used to interpret different
-	 * GraphQL Value literals.
-	 *
-	 * | GraphQL Value        | JSON Value    |
-	 * | -------------------- | ------------- |
-	 * | Input Object         | Object        |
-	 * | List                 | Array         |
-	 * | Boolean              | Boolean       |
-	 * | String               | String        |
-	 * | Int / Float          | Number        |
-	 * | Enum Value           | Mixed         |
-	 *
-	 */
-	function valueFromAST(valueAST, type, variables) {
-	  if (type instanceof _definition.GraphQLNonNull) {
-	    // Note: we're not checking that the result of valueFromAST is non-null.
-	    // We're assuming that this query has been validated and the value used
-	    // here is of the correct type.
-	    return valueFromAST(valueAST, type.ofType, variables);
-	  }
-
-	  if (!valueAST) {
-	    return null;
-	  }
-
-	  if (valueAST.kind === Kind.VARIABLE) {
-	    var variableName = valueAST.name.value;
-	    if (!variables || !variables.hasOwnProperty(variableName)) {
-	      return null;
-	    }
-	    // Note: we're not doing any checking that this variable is correct. We're
-	    // assuming that this query has been validated and the variable usage here
-	    // is of the correct type.
-	    return variables[variableName];
-	  }
-
-	  if (type instanceof _definition.GraphQLList) {
-	    var _ret = function () {
-	      var itemType = type.ofType;
-	      if (valueAST.kind === Kind.LIST) {
-	        return {
-	          v: valueAST.values.map(function (itemAST) {
-	            return valueFromAST(itemAST, itemType, variables);
-	          })
-	        };
-	      }
-	      return {
-	        v: [valueFromAST(valueAST, itemType, variables)]
-	      };
-	    }();
-
-	    if (typeof _ret === "object") return _ret.v;
-	  }
-
-	  if (type instanceof _definition.GraphQLInputObjectType) {
-	    var _ret2 = function () {
-	      if (valueAST.kind !== Kind.OBJECT) {
-	        return {
-	          v: null
-	        };
-	      }
-	      var fields = type.getFields();
-	      var fieldASTs = (0, _keyMap2.default)(valueAST.fields, function (field) {
-	        return field.name.value;
-	      });
-	      return {
-	        v: Object.keys(fields).reduce(function (obj, fieldName) {
-	          var field = fields[fieldName];
-	          var fieldAST = fieldASTs[fieldName];
-	          var fieldValue = valueFromAST(fieldAST && fieldAST.value, field.type, variables);
-	          if ((0, _isNullish2.default)(fieldValue)) {
-	            fieldValue = field.defaultValue;
-	          }
-	          if (!(0, _isNullish2.default)(fieldValue)) {
-	            obj[fieldName] = fieldValue;
-	          }
-	          return obj;
-	        }, {})
-	      };
-	    }();
-
-	    if (typeof _ret2 === "object") return _ret2.v;
-	  }
-
-	  (0, _invariant2.default)(type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType, 'Must be input type');
-
-	  var parsed = type.parseLiteral(valueAST);
-	  if (!(0, _isNullish2.default)(parsed)) {
-	    return parsed;
-	  }
-	}
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-/***/ },
-/* 247 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.isValidJSValue = isValidJSValue;
-
-	var _iterall = __webpack_require__(210);
-
-	var _invariant = __webpack_require__(200);
-
-	var _invariant2 = _interopRequireDefault(_invariant);
-
-	var _isNullish = __webpack_require__(204);
-
-	var _isNullish2 = _interopRequireDefault(_isNullish);
-
-	var _definition = __webpack_require__(203);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 * Given a JavaScript value and a GraphQL type, determine if the value will be
-	 * accepted for that type. This is primarily useful for validating the
-	 * runtime values of query variables.
-	 */
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function isValidJSValue(value, type) {
-	  // A value must be provided if the type is non-null.
-	  if (type instanceof _definition.GraphQLNonNull) {
-	    if ((0, _isNullish2.default)(value)) {
-	      if (type.ofType.name) {
-	        return ['Expected "' + String(type.ofType.name) + '!", found null.'];
-	      }
-	      return ['Expected non-null value, found null.'];
-	    }
-	    return isValidJSValue(value, type.ofType);
-	  }
-
-	  if ((0, _isNullish2.default)(value)) {
-	    return [];
-	  }
-
-	  // Lists accept a non-list value as a list of one.
-	  if (type instanceof _definition.GraphQLList) {
-	    var _ret = function () {
-	      var itemType = type.ofType;
-	      if ((0, _iterall.isCollection)(value)) {
-	        var _ret2 = function () {
-	          var errors = [];
-	          (0, _iterall.forEach)(value, function (item, index) {
-	            errors.push.apply(errors, isValidJSValue(item, itemType).map(function (error) {
-	              return 'In element #' + index + ': ' + error;
-	            }));
-	          });
-	          return {
-	            v: {
-	              v: errors
-	            }
-	          };
-	        }();
-
-	        if (typeof _ret2 === "object") return _ret2.v;
-	      }
-	      return {
-	        v: isValidJSValue(value, itemType)
-	      };
-	    }();
-
-	    if (typeof _ret === "object") return _ret.v;
-	  }
-
-	  // Input objects check each defined field.
-	  if (type instanceof _definition.GraphQLInputObjectType) {
-	    var _ret3 = function () {
-	      if (typeof value !== 'object' || value === null) {
-	        return {
-	          v: ['Expected "' + type.name + '", found not an object.']
-	        };
-	      }
-	      var fields = type.getFields();
-
-	      var errors = [];
-
-	      // Ensure every provided field is defined.
-	      Object.keys(value).forEach(function (providedField) {
-	        if (!fields[providedField]) {
-	          errors.push('In field "' + providedField + '": Unknown field.');
-	        }
-	      });
-
-	      // Ensure every defined field is valid.
-	      Object.keys(fields).forEach(function (fieldName) {
-	        var newErrors = isValidJSValue(value[fieldName], fields[fieldName].type);
-	        errors.push.apply(errors, newErrors.map(function (error) {
-	          return 'In field "' + fieldName + '": ' + error;
-	        }));
-	      });
-
-	      return {
-	        v: errors
-	      };
-	    }();
-
-	    if (typeof _ret3 === "object") return _ret3.v;
-	  }
-
-	  (0, _invariant2.default)(type instanceof _definition.GraphQLScalarType || type instanceof _definition.GraphQLEnumType, 'Must be input type');
-
-	  // Scalar/Enum input checks to ensure the type can parse the value to
-	  // a non-null value.
-	  var parseResult = type.parseValue(value);
-	  if ((0, _isNullish2.default)(parseResult)) {
-	    return ['Expected type "' + type.name + '", found ' + JSON.stringify(value) + '.'];
-	  }
-
-	  return [];
-	}
-
-/***/ },
-/* 248 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-
-	var _schema = __webpack_require__(202);
-
-	Object.defineProperty(exports, 'GraphQLSchema', {
-	  enumerable: true,
-	  get: function get() {
-	    return _schema.GraphQLSchema;
-	  }
-	});
-
-	var _definition = __webpack_require__(203);
-
-	Object.defineProperty(exports, 'isType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _definition.isType;
-	  }
-	});
-	Object.defineProperty(exports, 'isInputType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _definition.isInputType;
-	  }
-	});
-	Object.defineProperty(exports, 'isOutputType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _definition.isOutputType;
-	  }
-	});
-	Object.defineProperty(exports, 'isLeafType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _definition.isLeafType;
-	  }
-	});
-	Object.defineProperty(exports, 'isCompositeType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _definition.isCompositeType;
-	  }
-	});
-	Object.defineProperty(exports, 'isAbstractType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _definition.isAbstractType;
-	  }
-	});
-	Object.defineProperty(exports, 'getNullableType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _definition.getNullableType;
-	  }
-	});
-	Object.defineProperty(exports, 'getNamedType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _definition.getNamedType;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLScalarType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _definition.GraphQLScalarType;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLObjectType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _definition.GraphQLObjectType;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLInterfaceType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _definition.GraphQLInterfaceType;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLUnionType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _definition.GraphQLUnionType;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLEnumType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _definition.GraphQLEnumType;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLInputObjectType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _definition.GraphQLInputObjectType;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLList', {
-	  enumerable: true,
-	  get: function get() {
-	    return _definition.GraphQLList;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLNonNull', {
-	  enumerable: true,
-	  get: function get() {
-	    return _definition.GraphQLNonNull;
-	  }
-	});
-
-	var _directives = __webpack_require__(206);
-
-	Object.defineProperty(exports, 'DirectiveLocation', {
-	  enumerable: true,
-	  get: function get() {
-	    return _directives.DirectiveLocation;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLDirective', {
-	  enumerable: true,
-	  get: function get() {
-	    return _directives.GraphQLDirective;
-	  }
-	});
-	Object.defineProperty(exports, 'specifiedDirectives', {
-	  enumerable: true,
-	  get: function get() {
-	    return _directives.specifiedDirectives;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLIncludeDirective', {
-	  enumerable: true,
-	  get: function get() {
-	    return _directives.GraphQLIncludeDirective;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLSkipDirective', {
-	  enumerable: true,
-	  get: function get() {
-	    return _directives.GraphQLSkipDirective;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLDeprecatedDirective', {
-	  enumerable: true,
-	  get: function get() {
-	    return _directives.GraphQLDeprecatedDirective;
-	  }
-	});
-	Object.defineProperty(exports, 'DEFAULT_DEPRECATION_REASON', {
-	  enumerable: true,
-	  get: function get() {
-	    return _directives.DEFAULT_DEPRECATION_REASON;
-	  }
-	});
-
-	var _scalars = __webpack_require__(207);
-
-	Object.defineProperty(exports, 'GraphQLInt', {
-	  enumerable: true,
-	  get: function get() {
-	    return _scalars.GraphQLInt;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLFloat', {
-	  enumerable: true,
-	  get: function get() {
-	    return _scalars.GraphQLFloat;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLString', {
-	  enumerable: true,
-	  get: function get() {
-	    return _scalars.GraphQLString;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLBoolean', {
-	  enumerable: true,
-	  get: function get() {
-	    return _scalars.GraphQLBoolean;
-	  }
-	});
-	Object.defineProperty(exports, 'GraphQLID', {
-	  enumerable: true,
-	  get: function get() {
-	    return _scalars.GraphQLID;
-	  }
-	});
-
-	var _introspection = __webpack_require__(208);
-
-	Object.defineProperty(exports, 'TypeKind', {
-	  enumerable: true,
-	  get: function get() {
-	    return _introspection.TypeKind;
-	  }
-	});
-	Object.defineProperty(exports, '__Schema', {
-	  enumerable: true,
-	  get: function get() {
-	    return _introspection.__Schema;
-	  }
-	});
-	Object.defineProperty(exports, '__Directive', {
-	  enumerable: true,
-	  get: function get() {
-	    return _introspection.__Directive;
-	  }
-	});
-	Object.defineProperty(exports, '__DirectiveLocation', {
-	  enumerable: true,
-	  get: function get() {
-	    return _introspection.__DirectiveLocation;
-	  }
-	});
-	Object.defineProperty(exports, '__Type', {
-	  enumerable: true,
-	  get: function get() {
-	    return _introspection.__Type;
-	  }
-	});
-	Object.defineProperty(exports, '__Field', {
-	  enumerable: true,
-	  get: function get() {
-	    return _introspection.__Field;
-	  }
-	});
-	Object.defineProperty(exports, '__InputValue', {
-	  enumerable: true,
-	  get: function get() {
-	    return _introspection.__InputValue;
-	  }
-	});
-	Object.defineProperty(exports, '__EnumValue', {
-	  enumerable: true,
-	  get: function get() {
-	    return _introspection.__EnumValue;
-	  }
-	});
-	Object.defineProperty(exports, '__TypeKind', {
-	  enumerable: true,
-	  get: function get() {
-	    return _introspection.__TypeKind;
-	  }
-	});
-	Object.defineProperty(exports, 'SchemaMetaFieldDef', {
-	  enumerable: true,
-	  get: function get() {
-	    return _introspection.SchemaMetaFieldDef;
-	  }
-	});
-	Object.defineProperty(exports, 'TypeMetaFieldDef', {
-	  enumerable: true,
-	  get: function get() {
-	    return _introspection.TypeMetaFieldDef;
-	  }
-	});
-	Object.defineProperty(exports, 'TypeNameMetaFieldDef', {
-	  enumerable: true,
-	  get: function get() {
-	    return _introspection.TypeNameMetaFieldDef;
-	  }
-	});
-
-/***/ },
-/* 249 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-
-	var _execute = __webpack_require__(244);
-
-	Object.defineProperty(exports, 'execute', {
-	  enumerable: true,
-	  get: function get() {
-	    return _execute.execute;
-	  }
-	});
-
-/***/ },
-/* 250 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-
-	var _validate = __webpack_require__(201);
-
-	Object.defineProperty(exports, 'validate', {
-	  enumerable: true,
-	  get: function get() {
-	    return _validate.validate;
-	  }
-	});
-
-	var _specifiedRules = __webpack_require__(215);
-
-	Object.defineProperty(exports, 'specifiedRules', {
-	  enumerable: true,
-	  get: function get() {
-	    return _specifiedRules.specifiedRules;
-	  }
-	});
-
-/***/ },
-/* 251 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-
-	var _introspectionQuery = __webpack_require__(252);
-
-	Object.defineProperty(exports, 'introspectionQuery', {
-	  enumerable: true,
-	  get: function get() {
-	    return _introspectionQuery.introspectionQuery;
-	  }
-	});
-
-	var _getOperationAST = __webpack_require__(253);
-
-	Object.defineProperty(exports, 'getOperationAST', {
-	  enumerable: true,
-	  get: function get() {
-	    return _getOperationAST.getOperationAST;
-	  }
-	});
-
-	var _buildClientSchema = __webpack_require__(254);
-
-	Object.defineProperty(exports, 'buildClientSchema', {
-	  enumerable: true,
-	  get: function get() {
-	    return _buildClientSchema.buildClientSchema;
-	  }
-	});
-
-	var _buildASTSchema = __webpack_require__(256);
-
-	Object.defineProperty(exports, 'buildASTSchema', {
-	  enumerable: true,
-	  get: function get() {
-	    return _buildASTSchema.buildASTSchema;
-	  }
-	});
-	Object.defineProperty(exports, 'buildSchema', {
-	  enumerable: true,
-	  get: function get() {
-	    return _buildASTSchema.buildSchema;
-	  }
-	});
-
-	var _extendSchema = __webpack_require__(257);
-
-	Object.defineProperty(exports, 'extendSchema', {
-	  enumerable: true,
-	  get: function get() {
-	    return _extendSchema.extendSchema;
-	  }
-	});
-
-	var _schemaPrinter = __webpack_require__(258);
-
-	Object.defineProperty(exports, 'printSchema', {
-	  enumerable: true,
-	  get: function get() {
-	    return _schemaPrinter.printSchema;
-	  }
-	});
-	Object.defineProperty(exports, 'printIntrospectionSchema', {
-	  enumerable: true,
-	  get: function get() {
-	    return _schemaPrinter.printIntrospectionSchema;
-	  }
-	});
-
-	var _typeFromAST = __webpack_require__(214);
-
-	Object.defineProperty(exports, 'typeFromAST', {
-	  enumerable: true,
-	  get: function get() {
-	    return _typeFromAST.typeFromAST;
-	  }
-	});
-
-	var _valueFromAST = __webpack_require__(246);
-
-	Object.defineProperty(exports, 'valueFromAST', {
-	  enumerable: true,
-	  get: function get() {
-	    return _valueFromAST.valueFromAST;
-	  }
-	});
-
-	var _astFromValue = __webpack_require__(209);
-
-	Object.defineProperty(exports, 'astFromValue', {
-	  enumerable: true,
-	  get: function get() {
-	    return _astFromValue.astFromValue;
-	  }
-	});
-
-	var _TypeInfo = __webpack_require__(213);
-
-	Object.defineProperty(exports, 'TypeInfo', {
-	  enumerable: true,
-	  get: function get() {
-	    return _TypeInfo.TypeInfo;
-	  }
-	});
-
-	var _isValidJSValue = __webpack_require__(247);
-
-	Object.defineProperty(exports, 'isValidJSValue', {
-	  enumerable: true,
-	  get: function get() {
-	    return _isValidJSValue.isValidJSValue;
-	  }
-	});
-
-	var _isValidLiteralValue = __webpack_require__(237);
-
-	Object.defineProperty(exports, 'isValidLiteralValue', {
-	  enumerable: true,
-	  get: function get() {
-	    return _isValidLiteralValue.isValidLiteralValue;
-	  }
-	});
-
-	var _concatAST = __webpack_require__(259);
-
-	Object.defineProperty(exports, 'concatAST', {
-	  enumerable: true,
-	  get: function get() {
-	    return _concatAST.concatAST;
-	  }
-	});
-
-	var _separateOperations = __webpack_require__(260);
-
-	Object.defineProperty(exports, 'separateOperations', {
-	  enumerable: true,
-	  get: function get() {
-	    return _separateOperations.separateOperations;
-	  }
-	});
-
-	var _typeComparators = __webpack_require__(212);
-
-	Object.defineProperty(exports, 'isEqualType', {
-	  enumerable: true,
-	  get: function get() {
-	    return _typeComparators.isEqualType;
-	  }
-	});
-	Object.defineProperty(exports, 'isTypeSubTypeOf', {
-	  enumerable: true,
-	  get: function get() {
-	    return _typeComparators.isTypeSubTypeOf;
-	  }
-	});
-	Object.defineProperty(exports, 'doTypesOverlap', {
-	  enumerable: true,
-	  get: function get() {
-	    return _typeComparators.doTypesOverlap;
-	  }
-	});
-
-	var _assertValidName = __webpack_require__(205);
-
-	Object.defineProperty(exports, 'assertValidName', {
-	  enumerable: true,
-	  get: function get() {
-	    return _assertValidName.assertValidName;
-	  }
-	});
-
-	var _findBreakingChanges = __webpack_require__(261);
-
-	Object.defineProperty(exports, 'findBreakingChanges', {
-	  enumerable: true,
-	  get: function get() {
-	    return _findBreakingChanges.findBreakingChanges;
-	  }
-	});
-
-/***/ },
-/* 252 */
-/***/ function(module, exports) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	var introspectionQuery = exports.introspectionQuery = '\n  query IntrospectionQuery {\n    __schema {\n      queryType { name }\n      mutationType { name }\n      subscriptionType { name }\n      types {\n        ...FullType\n      }\n      directives {\n        name\n        description\n        locations\n        args {\n          ...InputValue\n        }\n      }\n    }\n  }\n\n  fragment FullType on __Type {\n    kind\n    name\n    description\n    fields(includeDeprecated: true) {\n      name\n      description\n      args {\n        ...InputValue\n      }\n      type {\n        ...TypeRef\n      }\n      isDeprecated\n      deprecationReason\n    }\n    inputFields {\n      ...InputValue\n    }\n    interfaces {\n      ...TypeRef\n    }\n    enumValues(includeDeprecated: true) {\n      name\n      description\n      isDeprecated\n      deprecationReason\n    }\n    possibleTypes {\n      ...TypeRef\n    }\n  }\n\n  fragment InputValue on __InputValue {\n    name\n    description\n    type { ...TypeRef }\n    defaultValue\n  }\n\n  fragment TypeRef on __Type {\n    kind\n    name\n    ofType {\n      kind\n      name\n      ofType {\n        kind\n        name\n        ofType {\n          kind\n          name\n          ofType {\n            kind\n            name\n            ofType {\n              kind\n              name\n              ofType {\n                kind\n                name\n                ofType {\n                  kind\n                  name\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n';
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-/***/ },
-/* 253 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.getOperationAST = getOperationAST;
-
-	var _kinds = __webpack_require__(196);
-
-	/**
-	 * Returns an operation AST given a document AST and optionally an operation
-	 * name. If a name is not provided, an operation is only returned if only one is
-	 * provided in the document.
-	 */
-	function getOperationAST(documentAST, operationName) {
-	  var operation = null;
-	  for (var i = 0; i < documentAST.definitions.length; i++) {
-	    var definition = documentAST.definitions[i];
-	    if (definition.kind === _kinds.OPERATION_DEFINITION) {
-	      if (!operationName) {
-	        // If no operation name was provided, only return an Operation if there
-	        // is one defined in the document. Upon encountering the second, return
-	        // null.
-	        if (operation) {
-	          return null;
-	        }
-	        operation = definition;
-	      } else if (definition.name && definition.name.value === operationName) {
-	        return definition;
-	      }
-	    }
-	  }
-	  return operation;
-	}
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-/***/ },
-/* 254 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.buildClientSchema = buildClientSchema;
-
-	var _invariant = __webpack_require__(200);
-
-	var _invariant2 = _interopRequireDefault(_invariant);
-
-	var _keyMap = __webpack_require__(238);
-
-	var _keyMap2 = _interopRequireDefault(_keyMap);
-
-	var _keyValMap = __webpack_require__(255);
-
-	var _keyValMap2 = _interopRequireDefault(_keyValMap);
-
-	var _valueFromAST = __webpack_require__(246);
-
-	var _parser = __webpack_require__(188);
-
-	var _schema = __webpack_require__(202);
-
-	var _definition = __webpack_require__(203);
-
-	var _introspection = __webpack_require__(208);
-
-	var _scalars = __webpack_require__(207);
-
-	var _directives = __webpack_require__(206);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 * Build a GraphQLSchema for use by client tools.
-	 *
-	 * Given the result of a client running the introspection query, creates and
-	 * returns a GraphQLSchema instance which can be then used with all graphql-js
-	 * tools, but cannot be used to execute a query, as introspection does not
-	 * represent the "resolver", "parse" or "serialize" functions or any other
-	 * server-internal mechanisms.
-	 */
-	function buildClientSchema(introspection) {
-
-	  // Get the schema from the introspection result.
-	  var schemaIntrospection = introspection.__schema;
-
-	  // Converts the list of types into a keyMap based on the type names.
-	  var typeIntrospectionMap = (0, _keyMap2.default)(schemaIntrospection.types, function (type) {
-	    return type.name;
-	  });
-
-	  // A cache to use to store the actual GraphQLType definition objects by name.
-	  // Initialize to the GraphQL built in scalars. All functions below are inline
-	  // so that this type def cache is within the scope of the closure.
-	  var typeDefCache = {
-	    String: _scalars.GraphQLString,
-	    Int: _scalars.GraphQLInt,
-	    Float: _scalars.GraphQLFloat,
-	    Boolean: _scalars.GraphQLBoolean,
-	    ID: _scalars.GraphQLID,
-	    __Schema: _introspection.__Schema,
-	    __Directive: _introspection.__Directive,
-	    __DirectiveLocation: _introspection.__DirectiveLocation,
-	    __Type: _introspection.__Type,
-	    __Field: _introspection.__Field,
-	    __InputValue: _introspection.__InputValue,
-	    __EnumValue: _introspection.__EnumValue,
-	    __TypeKind: _introspection.__TypeKind
-	  };
-
-	  // Given a type reference in introspection, return the GraphQLType instance.
-	  // preferring cached instances before building new instances.
-	  function getType(typeRef) {
-	    if (typeRef.kind === _introspection.TypeKind.LIST) {
-	      var itemRef = typeRef.ofType;
-	      if (!itemRef) {
-	        throw new Error('Decorated type deeper than introspection query.');
-	      }
-	      return new _definition.GraphQLList(getType(itemRef));
-	    }
-	    if (typeRef.kind === _introspection.TypeKind.NON_NULL) {
-	      var nullableRef = typeRef.ofType;
-	      if (!nullableRef) {
-	        throw new Error('Decorated type deeper than introspection query.');
-	      }
-	      var nullableType = getType(nullableRef);
-	      (0, _invariant2.default)(!(nullableType instanceof _definition.GraphQLNonNull), 'No nesting nonnull.');
-	      return new _definition.GraphQLNonNull(nullableType);
-	    }
-	    return getNamedType(typeRef.name);
-	  }
-
-	  function getNamedType(typeName) {
-	    if (typeDefCache[typeName]) {
-	      return typeDefCache[typeName];
-	    }
-	    var typeIntrospection = typeIntrospectionMap[typeName];
-	    if (!typeIntrospection) {
-	      throw new Error('Invalid or incomplete schema, unknown type: ' + typeName + '. Ensure ' + 'that a full introspection query is used in order to build a ' + 'client schema.');
-	    }
-	    var typeDef = buildType(typeIntrospection);
-	    typeDefCache[typeName] = typeDef;
-	    return typeDef;
-	  }
-
-	  function getInputType(typeRef) {
-	    var type = getType(typeRef);
-	    (0, _invariant2.default)((0, _definition.isInputType)(type), 'Introspection must provide input type for arguments.');
-	    return type;
-	  }
-
-	  function getOutputType(typeRef) {
-	    var type = getType(typeRef);
-	    (0, _invariant2.default)((0, _definition.isOutputType)(type), 'Introspection must provide output type for fields.');
-	    return type;
-	  }
-
-	  function getObjectType(typeRef) {
-	    var type = getType(typeRef);
-	    (0, _invariant2.default)(type instanceof _definition.GraphQLObjectType, 'Introspection must provide object type for possibleTypes.');
-	    return type;
-	  }
-
-	  function getInterfaceType(typeRef) {
-	    var type = getType(typeRef);
-	    (0, _invariant2.default)(type instanceof _definition.GraphQLInterfaceType, 'Introspection must provide interface type for interfaces.');
-	    return type;
-	  }
-
-	  // Given a type's introspection result, construct the correct
-	  // GraphQLType instance.
-	  function buildType(type) {
-	    switch (type.kind) {
-	      case _introspection.TypeKind.SCALAR:
-	        return buildScalarDef(type);
-	      case _introspection.TypeKind.OBJECT:
-	        return buildObjectDef(type);
-	      case _introspection.TypeKind.INTERFACE:
-	        return buildInterfaceDef(type);
-	      case _introspection.TypeKind.UNION:
-	        return buildUnionDef(type);
-	      case _introspection.TypeKind.ENUM:
-	        return buildEnumDef(type);
-	      case _introspection.TypeKind.INPUT_OBJECT:
-	        return buildInputObjectDef(type);
-	      default:
-	        throw new Error('Invalid or incomplete schema, unknown kind: ' + type.kind + '. Ensure ' + 'that a full introspection query is used in order to build a ' + 'client schema.');
-	    }
-	  }
-
-	  function buildScalarDef(scalarIntrospection) {
-	    return new _definition.GraphQLScalarType({
-	      name: scalarIntrospection.name,
-	      description: scalarIntrospection.description,
-	      serialize: function serialize(id) {
-	        return id;
-	      },
-	      // Note: validation calls the parse functions to determine if a
-	      // literal value is correct. Returning null would cause use of custom
-	      // scalars to always fail validation. Returning false causes them to
-	      // always pass validation.
-	      parseValue: function parseValue() {
-	        return false;
-	      },
-	      parseLiteral: function parseLiteral() {
-	        return false;
-	      }
-	    });
-	  }
-
-	  function buildObjectDef(objectIntrospection) {
-	    return new _definition.GraphQLObjectType({
-	      name: objectIntrospection.name,
-	      description: objectIntrospection.description,
-	      interfaces: objectIntrospection.interfaces.map(getInterfaceType),
-	      fields: function fields() {
-	        return buildFieldDefMap(objectIntrospection);
-	      }
-	    });
-	  }
-
-	  function buildInterfaceDef(interfaceIntrospection) {
-	    return new _definition.GraphQLInterfaceType({
-	      name: interfaceIntrospection.name,
-	      description: interfaceIntrospection.description,
-	      fields: function fields() {
-	        return buildFieldDefMap(interfaceIntrospection);
-	      },
-	      resolveType: cannotExecuteClientSchema
-	    });
-	  }
-
-	  function buildUnionDef(unionIntrospection) {
-	    return new _definition.GraphQLUnionType({
-	      name: unionIntrospection.name,
-	      description: unionIntrospection.description,
-	      types: unionIntrospection.possibleTypes.map(getObjectType),
-	      resolveType: cannotExecuteClientSchema
-	    });
-	  }
-
-	  function buildEnumDef(enumIntrospection) {
-	    return new _definition.GraphQLEnumType({
-	      name: enumIntrospection.name,
-	      description: enumIntrospection.description,
-	      values: (0, _keyValMap2.default)(enumIntrospection.enumValues, function (valueIntrospection) {
-	        return valueIntrospection.name;
-	      }, function (valueIntrospection) {
-	        return {
-	          description: valueIntrospection.description,
-	          deprecationReason: valueIntrospection.deprecationReason
-	        };
-	      })
-	    });
-	  }
-
-	  function buildInputObjectDef(inputObjectIntrospection) {
-	    return new _definition.GraphQLInputObjectType({
-	      name: inputObjectIntrospection.name,
-	      description: inputObjectIntrospection.description,
-	      fields: function fields() {
-	        return buildInputValueDefMap(inputObjectIntrospection.inputFields);
-	      }
-	    });
-	  }
-
-	  function buildFieldDefMap(typeIntrospection) {
-	    return (0, _keyValMap2.default)(typeIntrospection.fields, function (fieldIntrospection) {
-	      return fieldIntrospection.name;
-	    }, function (fieldIntrospection) {
-	      return {
-	        description: fieldIntrospection.description,
-	        deprecationReason: fieldIntrospection.deprecationReason,
-	        type: getOutputType(fieldIntrospection.type),
-	        args: buildInputValueDefMap(fieldIntrospection.args)
-	      };
-	    });
-	  }
-
-	  function buildInputValueDefMap(inputValueIntrospections) {
-	    return (0, _keyValMap2.default)(inputValueIntrospections, function (inputValue) {
-	      return inputValue.name;
-	    }, buildInputValue);
-	  }
-
-	  function buildInputValue(inputValueIntrospection) {
-	    var type = getInputType(inputValueIntrospection.type);
-	    var defaultValue = inputValueIntrospection.defaultValue ? (0, _valueFromAST.valueFromAST)((0, _parser.parseValue)(inputValueIntrospection.defaultValue), type) : null;
-	    return {
-	      name: inputValueIntrospection.name,
-	      description: inputValueIntrospection.description,
-	      type: type,
-	      defaultValue: defaultValue
-	    };
-	  }
-
-	  function buildDirective(directiveIntrospection) {
-	    // Support deprecated `on****` fields for building `locations`, as this
-	    // is used by GraphiQL which may need to support outdated servers.
-	    var locations = directiveIntrospection.locations ? directiveIntrospection.locations.slice() : [].concat(!directiveIntrospection.onField ? [] : [_directives.DirectiveLocation.FIELD], !directiveIntrospection.onOperation ? [] : [_directives.DirectiveLocation.QUERY, _directives.DirectiveLocation.MUTATION, _directives.DirectiveLocation.SUBSCRIPTION], !directiveIntrospection.onFragment ? [] : [_directives.DirectiveLocation.FRAGMENT_DEFINITION, _directives.DirectiveLocation.FRAGMENT_SPREAD, _directives.DirectiveLocation.INLINE_FRAGMENT]);
-	    return new _directives.GraphQLDirective({
-	      name: directiveIntrospection.name,
-	      description: directiveIntrospection.description,
-	      locations: locations,
-	      args: buildInputValueDefMap(directiveIntrospection.args)
-	    });
-	  }
-
-	  // Iterate through all types, getting the type definition for each, ensuring
-	  // that any type not directly referenced by a field will get created.
-	  var types = schemaIntrospection.types.map(function (typeIntrospection) {
-	    return getNamedType(typeIntrospection.name);
-	  });
-
-	  // Get the root Query, Mutation, and Subscription types.
-	  var queryType = getObjectType(schemaIntrospection.queryType);
-
-	  var mutationType = schemaIntrospection.mutationType ? getObjectType(schemaIntrospection.mutationType) : null;
-
-	  var subscriptionType = schemaIntrospection.subscriptionType ? getObjectType(schemaIntrospection.subscriptionType) : null;
-
-	  // Get the directives supported by Introspection, assuming empty-set if
-	  // directives were not queried for.
-	  var directives = schemaIntrospection.directives ? schemaIntrospection.directives.map(buildDirective) : [];
-
-	  // Then produce and return a Schema with these types.
-	  return new _schema.GraphQLSchema({
-	    query: queryType,
-	    mutation: mutationType,
-	    subscription: subscriptionType,
-	    types: types,
-	    directives: directives
-	  });
-	}
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function cannotExecuteClientSchema() {
-	  throw new Error('Client Schema cannot use Interface or Union types for execution.');
-	}
-
-/***/ },
-/* 255 */
-/***/ function(module, exports) {
-
-	"use strict";
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.default = keyValMap;
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	/**
-	 * Creates a keyed JS object from an array, given a function to produce the keys
-	 * and a function to produce the values from each item in the array.
-	 *
-	 *     const phoneBook = [
-	 *       { name: 'Jon', num: '555-1234' },
-	 *       { name: 'Jenny', num: '867-5309' }
-	 *     ]
-	 *
-	 *     // { Jon: '555-1234', Jenny: '867-5309' }
-	 *     const phonesByName = keyValMap(
-	 *       phoneBook,
-	 *       entry => entry.name,
-	 *       entry => entry.num
-	 *     )
-	 *
-	 */
-	function keyValMap(list, keyFn, valFn) {
-	  return list.reduce(function (map, item) {
-	    return map[keyFn(item)] = valFn(item), map;
-	  }, {});
-	}
-
-/***/ },
-/* 256 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.buildASTSchema = buildASTSchema;
-	exports.getDescription = getDescription;
-	exports.buildSchema = buildSchema;
-
-	var _find = __webpack_require__(211);
-
-	var _find2 = _interopRequireDefault(_find);
-
-	var _invariant = __webpack_require__(200);
-
-	var _invariant2 = _interopRequireDefault(_invariant);
-
-	var _keyValMap = __webpack_require__(255);
-
-	var _keyValMap2 = _interopRequireDefault(_keyValMap);
-
-	var _valueFromAST = __webpack_require__(246);
-
-	var _lexer = __webpack_require__(193);
-
-	var _parser = __webpack_require__(188);
-
-	var _values = __webpack_require__(245);
-
-	var _kinds = __webpack_require__(196);
-
-	var _schema = __webpack_require__(202);
-
-	var _scalars = __webpack_require__(207);
-
-	var _definition = __webpack_require__(203);
-
-	var _directives = __webpack_require__(206);
-
-	var _introspection = __webpack_require__(208);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function buildWrappedType(innerType, inputTypeAST) {
-	  if (inputTypeAST.kind === _kinds.LIST_TYPE) {
-	    return new _definition.GraphQLList(buildWrappedType(innerType, inputTypeAST.type));
-	  }
-	  if (inputTypeAST.kind === _kinds.NON_NULL_TYPE) {
-	    var wrappedType = buildWrappedType(innerType, inputTypeAST.type);
-	    (0, _invariant2.default)(!(wrappedType instanceof _definition.GraphQLNonNull), 'No nesting nonnull.');
-	    return new _definition.GraphQLNonNull(wrappedType);
-	  }
-	  return innerType;
-	}
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function getNamedTypeAST(typeAST) {
-	  var namedType = typeAST;
-	  while (namedType.kind === _kinds.LIST_TYPE || namedType.kind === _kinds.NON_NULL_TYPE) {
-	    namedType = namedType.type;
-	  }
-	  return namedType;
-	}
-
-	/**
-	 * This takes the ast of a schema document produced by the parse function in
-	 * src/language/parser.js.
-	 *
-	 * If no schema definition is provided, then it will look for types named Query
-	 * and Mutation.
-	 *
-	 * Given that AST it constructs a GraphQLSchema. The resulting schema
-	 * has no resolve methods, so execution will use default resolvers.
-	 */
-	function buildASTSchema(ast) {
-	  if (!ast || ast.kind !== _kinds.DOCUMENT) {
-	    throw new Error('Must provide a document ast.');
-	  }
-
-	  var schemaDef = void 0;
-
-	  var typeDefs = [];
-	  var astMap = Object.create(null);
-	  var directiveDefs = [];
-	  for (var i = 0; i < ast.definitions.length; i++) {
-	    var d = ast.definitions[i];
-	    switch (d.kind) {
-	      case _kinds.SCHEMA_DEFINITION:
-	        if (schemaDef) {
-	          throw new Error('Must provide only one schema definition.');
-	        }
-	        schemaDef = d;
-	        break;
-	      case _kinds.SCALAR_TYPE_DEFINITION:
-	      case _kinds.OBJECT_TYPE_DEFINITION:
-	      case _kinds.INTERFACE_TYPE_DEFINITION:
-	      case _kinds.ENUM_TYPE_DEFINITION:
-	      case _kinds.UNION_TYPE_DEFINITION:
-	      case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
-	        typeDefs.push(d);
-	        astMap[d.name.value] = d;
-	        break;
-	      case _kinds.DIRECTIVE_DEFINITION:
-	        directiveDefs.push(d);
-	        break;
-	    }
-	  }
-
-	  var queryTypeName = void 0;
-	  var mutationTypeName = void 0;
-	  var subscriptionTypeName = void 0;
-	  if (schemaDef) {
-	    schemaDef.operationTypes.forEach(function (operationType) {
-	      var typeName = operationType.type.name.value;
-	      if (operationType.operation === 'query') {
-	        if (queryTypeName) {
-	          throw new Error('Must provide only one query type in schema.');
-	        }
-	        if (!astMap[typeName]) {
-	          throw new Error('Specified query type "' + typeName + '" not found in document.');
-	        }
-	        queryTypeName = typeName;
-	      } else if (operationType.operation === 'mutation') {
-	        if (mutationTypeName) {
-	          throw new Error('Must provide only one mutation type in schema.');
-	        }
-	        if (!astMap[typeName]) {
-	          throw new Error('Specified mutation type "' + typeName + '" not found in document.');
-	        }
-	        mutationTypeName = typeName;
-	      } else if (operationType.operation === 'subscription') {
-	        if (subscriptionTypeName) {
-	          throw new Error('Must provide only one subscription type in schema.');
-	        }
-	        if (!astMap[typeName]) {
-	          throw new Error('Specified subscription type "' + typeName + '" not found in document.');
-	        }
-	        subscriptionTypeName = typeName;
-	      }
-	    });
-	  } else {
-	    if (astMap.Query) {
-	      queryTypeName = 'Query';
-	    }
-	    if (astMap.Mutation) {
-	      mutationTypeName = 'Mutation';
-	    }
-	    if (astMap.Subscription) {
-	      subscriptionTypeName = 'Subscription';
-	    }
-	  }
-
-	  if (!queryTypeName) {
-	    throw new Error('Must provide schema definition with query type or a type named Query.');
-	  }
-
-	  var innerTypeMap = {
-	    String: _scalars.GraphQLString,
-	    Int: _scalars.GraphQLInt,
-	    Float: _scalars.GraphQLFloat,
-	    Boolean: _scalars.GraphQLBoolean,
-	    ID: _scalars.GraphQLID,
-	    __Schema: _introspection.__Schema,
-	    __Directive: _introspection.__Directive,
-	    __DirectiveLocation: _introspection.__DirectiveLocation,
-	    __Type: _introspection.__Type,
-	    __Field: _introspection.__Field,
-	    __InputValue: _introspection.__InputValue,
-	    __EnumValue: _introspection.__EnumValue,
-	    __TypeKind: _introspection.__TypeKind
-	  };
-
-	  var types = typeDefs.map(function (def) {
-	    return typeDefNamed(def.name.value);
-	  });
-
-	  var directives = directiveDefs.map(getDirective);
-
-	  // If specified directives were not explicitly declared, add them.
-	  if (!directives.some(function (directive) {
-	    return directive.name === 'skip';
-	  })) {
-	    directives.push(_directives.GraphQLSkipDirective);
-	  }
-
-	  if (!directives.some(function (directive) {
-	    return directive.name === 'include';
-	  })) {
-	    directives.push(_directives.GraphQLIncludeDirective);
-	  }
-
-	  if (!directives.some(function (directive) {
-	    return directive.name === 'deprecated';
-	  })) {
-	    directives.push(_directives.GraphQLDeprecatedDirective);
-	  }
-
-	  return new _schema.GraphQLSchema({
-	    query: getObjectType(astMap[queryTypeName]),
-	    mutation: mutationTypeName ? getObjectType(astMap[mutationTypeName]) : null,
-	    subscription: subscriptionTypeName ? getObjectType(astMap[subscriptionTypeName]) : null,
-	    types: types,
-	    directives: directives
-	  });
-
-	  function getDirective(directiveAST) {
-	    return new _directives.GraphQLDirective({
-	      name: directiveAST.name.value,
-	      description: getDescription(directiveAST),
-	      locations: directiveAST.locations.map(function (node) {
-	        return node.value;
-	      }),
-	      args: directiveAST.arguments && makeInputValues(directiveAST.arguments)
-	    });
-	  }
-
-	  function getObjectType(typeAST) {
-	    var type = typeDefNamed(typeAST.name.value);
-	    (0, _invariant2.default)(type instanceof _definition.GraphQLObjectType, 'AST must provide object type.');
-	    return type;
-	  }
-
-	  function produceType(typeAST) {
-	    var typeName = getNamedTypeAST(typeAST).name.value;
-	    var typeDef = typeDefNamed(typeName);
-	    return buildWrappedType(typeDef, typeAST);
-	  }
-
-	  function produceInputType(typeAST) {
-	    var type = produceType(typeAST);
-	    (0, _invariant2.default)((0, _definition.isInputType)(type), 'Expected Input type.');
-	    return type;
-	  }
-
-	  function produceOutputType(typeAST) {
-	    var type = produceType(typeAST);
-	    (0, _invariant2.default)((0, _definition.isOutputType)(type), 'Expected Output type.');
-	    return type;
-	  }
-
-	  function produceObjectType(typeAST) {
-	    var type = produceType(typeAST);
-	    (0, _invariant2.default)(type instanceof _definition.GraphQLObjectType, 'Expected Object type.');
-	    return type;
-	  }
-
-	  function produceInterfaceType(typeAST) {
-	    var type = produceType(typeAST);
-	    (0, _invariant2.default)(type instanceof _definition.GraphQLInterfaceType, 'Expected Object type.');
-	    return type;
-	  }
-
-	  function typeDefNamed(typeName) {
-	    if (innerTypeMap[typeName]) {
-	      return innerTypeMap[typeName];
-	    }
-
-	    if (!astMap[typeName]) {
-	      throw new Error('Type "' + typeName + '" not found in document.');
-	    }
-
-	    var innerTypeDef = makeSchemaDef(astMap[typeName]);
-	    if (!innerTypeDef) {
-	      throw new Error('Nothing constructed for "' + typeName + '".');
-	    }
-	    innerTypeMap[typeName] = innerTypeDef;
-	    return innerTypeDef;
-	  }
-
-	  function makeSchemaDef(def) {
-	    if (!def) {
-	      throw new Error('def must be defined');
-	    }
-	    switch (def.kind) {
-	      case _kinds.OBJECT_TYPE_DEFINITION:
-	        return makeTypeDef(def);
-	      case _kinds.INTERFACE_TYPE_DEFINITION:
-	        return makeInterfaceDef(def);
-	      case _kinds.ENUM_TYPE_DEFINITION:
-	        return makeEnumDef(def);
-	      case _kinds.UNION_TYPE_DEFINITION:
-	        return makeUnionDef(def);
-	      case _kinds.SCALAR_TYPE_DEFINITION:
-	        return makeScalarDef(def);
-	      case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
-	        return makeInputObjectDef(def);
-	      default:
-	        throw new Error('Type kind "' + def.kind + '" not supported.');
-	    }
-	  }
-
-	  function makeTypeDef(def) {
-	    var typeName = def.name.value;
-	    return new _definition.GraphQLObjectType({
-	      name: typeName,
-	      description: getDescription(def),
-	      fields: function fields() {
-	        return makeFieldDefMap(def);
-	      },
-	      interfaces: function interfaces() {
-	        return makeImplementedInterfaces(def);
-	      }
-	    });
-	  }
-
-	  function makeFieldDefMap(def) {
-	    return (0, _keyValMap2.default)(def.fields, function (field) {
-	      return field.name.value;
-	    }, function (field) {
-	      return {
-	        type: produceOutputType(field.type),
-	        description: getDescription(field),
-	        args: makeInputValues(field.arguments),
-	        deprecationReason: getDeprecationReason(field.directives)
-	      };
-	    });
-	  }
-
-	  function makeImplementedInterfaces(def) {
-	    return def.interfaces && def.interfaces.map(function (iface) {
-	      return produceInterfaceType(iface);
-	    });
-	  }
-
-	  function makeInputValues(values) {
-	    return (0, _keyValMap2.default)(values, function (value) {
-	      return value.name.value;
-	    }, function (value) {
-	      var type = produceInputType(value.type);
-	      return {
-	        type: type,
-	        description: getDescription(value),
-	        defaultValue: (0, _valueFromAST.valueFromAST)(value.defaultValue, type)
-	      };
-	    });
-	  }
-
-	  function makeInterfaceDef(def) {
-	    var typeName = def.name.value;
-	    return new _definition.GraphQLInterfaceType({
-	      name: typeName,
-	      description: getDescription(def),
-	      fields: function fields() {
-	        return makeFieldDefMap(def);
-	      },
-	      resolveType: cannotExecuteSchema
-	    });
-	  }
-
-	  function makeEnumDef(def) {
-	    var enumType = new _definition.GraphQLEnumType({
-	      name: def.name.value,
-	      description: getDescription(def),
-	      values: (0, _keyValMap2.default)(def.values, function (enumValue) {
-	        return enumValue.name.value;
-	      }, function (enumValue) {
-	        return {
-	          description: getDescription(enumValue),
-	          deprecationReason: getDeprecationReason(enumValue.directives)
-	        };
-	      })
-	    });
-
-	    return enumType;
-	  }
-
-	  function makeUnionDef(def) {
-	    return new _definition.GraphQLUnionType({
-	      name: def.name.value,
-	      description: getDescription(def),
-	      types: def.types.map(function (t) {
-	        return produceObjectType(t);
-	      }),
-	      resolveType: cannotExecuteSchema
-	    });
-	  }
-
-	  function makeScalarDef(def) {
-	    return new _definition.GraphQLScalarType({
-	      name: def.name.value,
-	      description: getDescription(def),
-	      serialize: function serialize() {
-	        return null;
-	      },
-	      // Note: validation calls the parse functions to determine if a
-	      // literal value is correct. Returning null would cause use of custom
-	      // scalars to always fail validation. Returning false causes them to
-	      // always pass validation.
-	      parseValue: function parseValue() {
-	        return false;
-	      },
-	      parseLiteral: function parseLiteral() {
-	        return false;
-	      }
-	    });
-	  }
-
-	  function makeInputObjectDef(def) {
-	    return new _definition.GraphQLInputObjectType({
-	      name: def.name.value,
-	      description: getDescription(def),
-	      fields: function fields() {
-	        return makeInputValues(def.fields);
-	      }
-	    });
-	  }
-	}
-
-	function getDeprecationReason(directives) {
-	  var deprecatedAST = directives && (0, _find2.default)(directives, function (directive) {
-	    return directive.name.value === _directives.GraphQLDeprecatedDirective.name;
-	  });
-	  if (!deprecatedAST) {
-	    return;
-	  }
-
-	  var _getArgumentValues = (0, _values.getArgumentValues)(_directives.GraphQLDeprecatedDirective.args, deprecatedAST.arguments);
-
-	  var reason = _getArgumentValues.reason;
-
-	  return reason;
-	}
-
-	/**
-	 * Given an ast node, returns its string description based on a contiguous
-	 * block full-line of comments preceding it.
-	 */
-	function getDescription(node) {
-	  var loc = node.loc;
-	  if (!loc) {
-	    return;
-	  }
-	  var comments = [];
-	  var minSpaces = void 0;
-	  var token = loc.startToken.prev;
-	  while (token && token.kind === _lexer.TokenKind.COMMENT && token.next && token.prev && token.line + 1 === token.next.line && token.line !== token.prev.line) {
-	    var value = String(token.value);
-	    var spaces = leadingSpaces(value);
-	    if (minSpaces === undefined || spaces < minSpaces) {
-	      minSpaces = spaces;
-	    }
-	    comments.push(value);
-	    token = token.prev;
-	  }
-	  return comments.reverse().map(function (comment) {
-	    return comment.slice(minSpaces);
-	  }).join('\n');
-	}
-
-	/**
-	 * A helper function to build a GraphQLSchema directly from a source
-	 * document.
-	 */
-	function buildSchema(source) {
-	  return buildASTSchema((0, _parser.parse)(source));
-	}
-
-	// Count the number of spaces on the starting side of a string.
-	function leadingSpaces(str) {
-	  var i = 0;
-	  for (; i < str.length; i++) {
-	    if (str[i] !== ' ') {
-	      break;
-	    }
-	  }
-	  return i;
-	}
-
-	function cannotExecuteSchema() {
-	  throw new Error('Generated Schema cannot use Interface or Union types for execution.');
-	}
-
-/***/ },
-/* 257 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.extendSchema = extendSchema;
-
-	var _invariant = __webpack_require__(200);
-
-	var _invariant2 = _interopRequireDefault(_invariant);
-
-	var _keyMap = __webpack_require__(238);
-
-	var _keyMap2 = _interopRequireDefault(_keyMap);
-
-	var _keyValMap = __webpack_require__(255);
-
-	var _keyValMap2 = _interopRequireDefault(_keyValMap);
-
-	var _buildASTSchema = __webpack_require__(256);
-
-	var _valueFromAST = __webpack_require__(246);
-
-	var _GraphQLError = __webpack_require__(190);
-
-	var _schema = __webpack_require__(202);
-
-	var _definition = __webpack_require__(203);
-
-	var _directives = __webpack_require__(206);
-
-	var _introspection = __webpack_require__(208);
-
-	var _scalars = __webpack_require__(207);
-
-	var _kinds = __webpack_require__(196);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 * Produces a new schema given an existing schema and a document which may
-	 * contain GraphQL type extensions and definitions. The original schema will
-	 * remain unaltered.
-	 *
-	 * Because a schema represents a graph of references, a schema cannot be
-	 * extended without effectively making an entire copy. We do not know until it's
-	 * too late if subgraphs remain unchanged.
-	 *
-	 * This algorithm copies the provided schema, applying extensions while
-	 * producing the copy. The original schema remains unaltered.
-	 */
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function extendSchema(schema, documentAST) {
-	  (0, _invariant2.default)(schema instanceof _schema.GraphQLSchema, 'Must provide valid GraphQLSchema');
-
-	  (0, _invariant2.default)(documentAST && documentAST.kind === _kinds.DOCUMENT, 'Must provide valid Document AST');
-
-	  // Collect the type definitions and extensions found in the document.
-	  var typeDefinitionMap = {};
-	  var typeExtensionsMap = {};
-
-	  // New directives and types are separate because a directives and types can
-	  // have the same name. For example, a type named "skip".
-	  var directiveDefinitions = [];
-
-	  for (var i = 0; i < documentAST.definitions.length; i++) {
-	    var def = documentAST.definitions[i];
-	    switch (def.kind) {
-	      case _kinds.OBJECT_TYPE_DEFINITION:
-	      case _kinds.INTERFACE_TYPE_DEFINITION:
-	      case _kinds.ENUM_TYPE_DEFINITION:
-	      case _kinds.UNION_TYPE_DEFINITION:
-	      case _kinds.SCALAR_TYPE_DEFINITION:
-	      case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
-	        // Sanity check that none of the defined types conflict with the
-	        // schema's existing types.
-	        var typeName = def.name.value;
-	        if (schema.getType(typeName)) {
-	          throw new _GraphQLError.GraphQLError('Type "' + typeName + '" already exists in the schema. It cannot also ' + 'be defined in this type definition.', [def]);
-	        }
-	        typeDefinitionMap[typeName] = def;
-	        break;
-	      case _kinds.TYPE_EXTENSION_DEFINITION:
-	        // Sanity check that this type extension exists within the
-	        // schema's existing types.
-	        var extendedTypeName = def.definition.name.value;
-	        var existingType = schema.getType(extendedTypeName);
-	        if (!existingType) {
-	          throw new _GraphQLError.GraphQLError('Cannot extend type "' + extendedTypeName + '" because it does not ' + 'exist in the existing schema.', [def.definition]);
-	        }
-	        if (!(existingType instanceof _definition.GraphQLObjectType)) {
-	          throw new _GraphQLError.GraphQLError('Cannot extend non-object type "' + extendedTypeName + '".', [def.definition]);
-	        }
-	        var extensions = typeExtensionsMap[extendedTypeName];
-	        if (extensions) {
-	          extensions.push(def);
-	        } else {
-	          extensions = [def];
-	        }
-	        typeExtensionsMap[extendedTypeName] = extensions;
-	        break;
-	      case _kinds.DIRECTIVE_DEFINITION:
-	        var directiveName = def.name.value;
-	        var existingDirective = schema.getDirective(directiveName);
-	        if (existingDirective) {
-	          throw new _GraphQLError.GraphQLError('Directive "' + directiveName + '" already exists in the schema. It ' + 'cannot be redefined.', [def]);
-	        }
-	        directiveDefinitions.push(def);
-	        break;
-	    }
-	  }
-
-	  // If this document contains no new types, extensions, or directives then
-	  // return the same unmodified GraphQLSchema instance.
-	  if (Object.keys(typeExtensionsMap).length === 0 && Object.keys(typeDefinitionMap).length === 0 && directiveDefinitions.length === 0) {
-	    return schema;
-	  }
-
-	  // A cache to use to store the actual GraphQLType definition objects by name.
-	  // Initialize to the GraphQL built in scalars and introspection types. All
-	  // functions below are inline so that this type def cache is within the scope
-	  // of the closure.
-	  var typeDefCache = {
-	    String: _scalars.GraphQLString,
-	    Int: _scalars.GraphQLInt,
-	    Float: _scalars.GraphQLFloat,
-	    Boolean: _scalars.GraphQLBoolean,
-	    ID: _scalars.GraphQLID,
-	    __Schema: _introspection.__Schema,
-	    __Directive: _introspection.__Directive,
-	    __DirectiveLocation: _introspection.__DirectiveLocation,
-	    __Type: _introspection.__Type,
-	    __Field: _introspection.__Field,
-	    __InputValue: _introspection.__InputValue,
-	    __EnumValue: _introspection.__EnumValue,
-	    __TypeKind: _introspection.__TypeKind
-	  };
-
-	  // Get the root Query, Mutation, and Subscription object types.
-	  var queryType = getTypeFromDef(schema.getQueryType());
-
-	  var existingMutationType = schema.getMutationType();
-	  var mutationType = existingMutationType ? getTypeFromDef(existingMutationType) : null;
-
-	  var existingSubscriptionType = schema.getSubscriptionType();
-	  var subscriptionType = existingSubscriptionType ? getTypeFromDef(existingSubscriptionType) : null;
-
-	  // Iterate through all types, getting the type definition for each, ensuring
-	  // that any type not directly referenced by a field will get created.
-	  var typeMap = schema.getTypeMap();
-	  var types = Object.keys(typeMap).map(function (typeName) {
-	    return getTypeFromDef(typeMap[typeName]);
-	  });
-
-	  // Do the same with new types, appending to the list of defined types.
-	  Object.keys(typeDefinitionMap).forEach(function (typeName) {
-	    types.push(getTypeFromAST(typeDefinitionMap[typeName]));
-	  });
-
-	  // Then produce and return a Schema with these types.
-	  return new _schema.GraphQLSchema({
-	    query: queryType,
-	    mutation: mutationType,
-	    subscription: subscriptionType,
-	    types: types,
-	    directives: getMergedDirectives()
-	  });
-
-	  // Below are functions used for producing this schema that have closed over
-	  // this scope and have access to the schema, cache, and newly defined types.
-
-	  function getMergedDirectives() {
-	    var existingDirectives = schema.getDirectives();
-	    (0, _invariant2.default)(existingDirectives, 'schema must have default directives');
-
-	    var newDirectives = directiveDefinitions.map(function (directiveAST) {
-	      return getDirective(directiveAST);
-	    });
-	    return existingDirectives.concat(newDirectives);
-	  }
-
-	  function getTypeFromDef(typeDef) {
-	    var type = _getNamedType(typeDef.name);
-	    (0, _invariant2.default)(type, 'Missing type from schema');
-	    return type;
-	  }
-
-	  function getTypeFromAST(astNode) {
-	    var type = _getNamedType(astNode.name.value);
-	    if (!type) {
-	      throw new _GraphQLError.GraphQLError('Unknown type: "' + astNode.name.value + '". Ensure that this type exists ' + 'either in the original schema, or is added in a type definition.', [astNode]);
-	    }
-	    return type;
-	  }
-
-	  function getObjectTypeFromAST(astNode) {
-	    var type = getTypeFromAST(astNode);
-	    (0, _invariant2.default)(type instanceof _definition.GraphQLObjectType, 'Must be Object type.');
-	    return type;
-	  }
-
-	  function getInterfaceTypeFromAST(astNode) {
-	    var type = getTypeFromAST(astNode);
-	    (0, _invariant2.default)(type instanceof _definition.GraphQLInterfaceType, 'Must be Interface type.');
-	    return type;
-	  }
-
-	  function getInputTypeFromAST(astNode) {
-	    var type = getTypeFromAST(astNode);
-	    (0, _invariant2.default)((0, _definition.isInputType)(type), 'Must be Input type.');
-	    return type;
-	  }
-
-	  function getOutputTypeFromAST(astNode) {
-	    var type = getTypeFromAST(astNode);
-	    (0, _invariant2.default)((0, _definition.isOutputType)(type), 'Must be Output type.');
-	    return type;
-	  }
-
-	  // Given a name, returns a type from either the existing schema or an
-	  // added type.
-	  function _getNamedType(typeName) {
-	    var cachedTypeDef = typeDefCache[typeName];
-	    if (cachedTypeDef) {
-	      return cachedTypeDef;
-	    }
-
-	    var existingType = schema.getType(typeName);
-	    if (existingType) {
-	      var typeDef = extendType(existingType);
-	      typeDefCache[typeName] = typeDef;
-	      return typeDef;
-	    }
-
-	    var typeAST = typeDefinitionMap[typeName];
-	    if (typeAST) {
-	      var _typeDef = buildType(typeAST);
-	      typeDefCache[typeName] = _typeDef;
-	      return _typeDef;
-	    }
-	  }
-
-	  // Given a type's introspection result, construct the correct
-	  // GraphQLType instance.
-	  function extendType(type) {
-	    if (type instanceof _definition.GraphQLObjectType) {
-	      return extendObjectType(type);
-	    }
-	    if (type instanceof _definition.GraphQLInterfaceType) {
-	      return extendInterfaceType(type);
-	    }
-	    if (type instanceof _definition.GraphQLUnionType) {
-	      return extendUnionType(type);
-	    }
-	    return type;
-	  }
-
-	  function extendObjectType(type) {
-	    return new _definition.GraphQLObjectType({
-	      name: type.name,
-	      description: type.description,
-	      interfaces: function interfaces() {
-	        return extendImplementedInterfaces(type);
-	      },
-	      fields: function fields() {
-	        return extendFieldMap(type);
-	      },
-	      isTypeOf: type.isTypeOf
-	    });
-	  }
-
-	  function extendInterfaceType(type) {
-	    return new _definition.GraphQLInterfaceType({
-	      name: type.name,
-	      description: type.description,
-	      fields: function fields() {
-	        return extendFieldMap(type);
-	      },
-	      resolveType: type.resolveType
-	    });
-	  }
-
-	  function extendUnionType(type) {
-	    return new _definition.GraphQLUnionType({
-	      name: type.name,
-	      description: type.description,
-	      types: type.getTypes().map(getTypeFromDef),
-	      resolveType: type.resolveType
-	    });
-	  }
-
-	  function extendImplementedInterfaces(type) {
-	    var interfaces = type.getInterfaces().map(getTypeFromDef);
-
-	    // If there are any extensions to the interfaces, apply those here.
-	    var extensions = typeExtensionsMap[type.name];
-	    if (extensions) {
-	      extensions.forEach(function (extension) {
-	        extension.definition.interfaces.forEach(function (namedType) {
-	          var interfaceName = namedType.name.value;
-	          if (interfaces.some(function (def) {
-	            return def.name === interfaceName;
-	          })) {
-	            throw new _GraphQLError.GraphQLError('Type "' + type.name + '" already implements "' + interfaceName + '". ' + 'It cannot also be implemented in this type extension.', [namedType]);
-	          }
-	          interfaces.push(getInterfaceTypeFromAST(namedType));
-	        });
-	      });
-	    }
-
-	    return interfaces;
-	  }
-
-	  function extendFieldMap(type) {
-	    var newFieldMap = {};
-	    var oldFieldMap = type.getFields();
-	    Object.keys(oldFieldMap).forEach(function (fieldName) {
-	      var field = oldFieldMap[fieldName];
-	      newFieldMap[fieldName] = {
-	        description: field.description,
-	        deprecationReason: field.deprecationReason,
-	        type: extendFieldType(field.type),
-	        args: (0, _keyMap2.default)(field.args, function (arg) {
-	          return arg.name;
-	        }),
-	        resolve: field.resolve
-	      };
-	    });
-
-	    // If there are any extensions to the fields, apply those here.
-	    var extensions = typeExtensionsMap[type.name];
-	    if (extensions) {
-	      extensions.forEach(function (extension) {
-	        extension.definition.fields.forEach(function (field) {
-	          var fieldName = field.name.value;
-	          if (oldFieldMap[fieldName]) {
-	            throw new _GraphQLError.GraphQLError('Field "' + type.name + '.' + fieldName + '" already exists in the ' + 'schema. It cannot also be defined in this type extension.', [field]);
-	          }
-	          newFieldMap[fieldName] = {
-	            description: (0, _buildASTSchema.getDescription)(field),
-	            type: buildOutputFieldType(field.type),
-	            args: buildInputValues(field.arguments)
-	          };
-	        });
-	      });
-	    }
-
-	    return newFieldMap;
-	  }
-
-	  function extendFieldType(typeDef) {
-	    if (typeDef instanceof _definition.GraphQLList) {
-	      return new _definition.GraphQLList(extendFieldType(typeDef.ofType));
-	    }
-	    if (typeDef instanceof _definition.GraphQLNonNull) {
-	      return new _definition.GraphQLNonNull(extendFieldType(typeDef.ofType));
-	    }
-	    return getTypeFromDef(typeDef);
-	  }
-
-	  function buildType(typeAST) {
-	    switch (typeAST.kind) {
-	      case _kinds.OBJECT_TYPE_DEFINITION:
-	        return buildObjectType(typeAST);
-	      case _kinds.INTERFACE_TYPE_DEFINITION:
-	        return buildInterfaceType(typeAST);
-	      case _kinds.UNION_TYPE_DEFINITION:
-	        return buildUnionType(typeAST);
-	      case _kinds.SCALAR_TYPE_DEFINITION:
-	        return buildScalarType(typeAST);
-	      case _kinds.ENUM_TYPE_DEFINITION:
-	        return buildEnumType(typeAST);
-	      case _kinds.INPUT_OBJECT_TYPE_DEFINITION:
-	        return buildInputObjectType(typeAST);
-	    }
-	    throw new TypeError('Unknown type kind ' + typeAST.kind);
-	  }
-
-	  function buildObjectType(typeAST) {
-	    return new _definition.GraphQLObjectType({
-	      name: typeAST.name.value,
-	      description: (0, _buildASTSchema.getDescription)(typeAST),
-	      interfaces: function interfaces() {
-	        return buildImplementedInterfaces(typeAST);
-	      },
-	      fields: function fields() {
-	        return buildFieldMap(typeAST);
-	      }
-	    });
-	  }
-
-	  function buildInterfaceType(typeAST) {
-	    return new _definition.GraphQLInterfaceType({
-	      name: typeAST.name.value,
-	      description: (0, _buildASTSchema.getDescription)(typeAST),
-	      fields: function fields() {
-	        return buildFieldMap(typeAST);
-	      },
-	      resolveType: cannotExecuteExtendedSchema
-	    });
-	  }
-
-	  function buildUnionType(typeAST) {
-	    return new _definition.GraphQLUnionType({
-	      name: typeAST.name.value,
-	      description: (0, _buildASTSchema.getDescription)(typeAST),
-	      types: typeAST.types.map(getObjectTypeFromAST),
-	      resolveType: cannotExecuteExtendedSchema
-	    });
-	  }
-
-	  function buildScalarType(typeAST) {
-	    return new _definition.GraphQLScalarType({
-	      name: typeAST.name.value,
-	      description: (0, _buildASTSchema.getDescription)(typeAST),
-	      serialize: function serialize(id) {
-	        return id;
-	      },
-	      // Note: validation calls the parse functions to determine if a
-	      // literal value is correct. Returning null would cause use of custom
-	      // scalars to always fail validation. Returning false causes them to
-	      // always pass validation.
-	      parseValue: function parseValue() {
-	        return false;
-	      },
-	      parseLiteral: function parseLiteral() {
-	        return false;
-	      }
-	    });
-	  }
-
-	  function buildEnumType(typeAST) {
-	    return new _definition.GraphQLEnumType({
-	      name: typeAST.name.value,
-	      description: (0, _buildASTSchema.getDescription)(typeAST),
-	      values: (0, _keyValMap2.default)(typeAST.values, function (v) {
-	        return v.name.value;
-	      }, function () {
-	        return {};
-	      })
-	    });
-	  }
-
-	  function buildInputObjectType(typeAST) {
-	    return new _definition.GraphQLInputObjectType({
-	      name: typeAST.name.value,
-	      description: (0, _buildASTSchema.getDescription)(typeAST),
-	      fields: function fields() {
-	        return buildInputValues(typeAST.fields);
-	      }
-	    });
-	  }
-
-	  function getDirective(directiveAST) {
-	    return new _directives.GraphQLDirective({
-	      name: directiveAST.name.value,
-	      locations: directiveAST.locations.map(function (node) {
-	        return node.value;
-	      }),
-	      args: directiveAST.arguments && buildInputValues(directiveAST.arguments)
-	    });
-	  }
-
-	  function buildImplementedInterfaces(typeAST) {
-	    return typeAST.interfaces && typeAST.interfaces.map(getInterfaceTypeFromAST);
-	  }
-
-	  function buildFieldMap(typeAST) {
-	    return (0, _keyValMap2.default)(typeAST.fields, function (field) {
-	      return field.name.value;
-	    }, function (field) {
-	      return {
-	        type: buildOutputFieldType(field.type),
-	        description: (0, _buildASTSchema.getDescription)(field),
-	        args: buildInputValues(field.arguments)
-	      };
-	    });
-	  }
-
-	  function buildInputValues(values) {
-	    return (0, _keyValMap2.default)(values, function (value) {
-	      return value.name.value;
-	    }, function (value) {
-	      var type = buildInputFieldType(value.type);
-	      return {
-	        type: type,
-	        description: (0, _buildASTSchema.getDescription)(value),
-	        defaultValue: (0, _valueFromAST.valueFromAST)(value.defaultValue, type)
-	      };
-	    });
-	  }
-
-	  function buildInputFieldType(typeAST) {
-	    if (typeAST.kind === _kinds.LIST_TYPE) {
-	      return new _definition.GraphQLList(buildInputFieldType(typeAST.type));
-	    }
-	    if (typeAST.kind === _kinds.NON_NULL_TYPE) {
-	      var nullableType = buildInputFieldType(typeAST.type);
-	      (0, _invariant2.default)(!(nullableType instanceof _definition.GraphQLNonNull), 'Must be nullable');
-	      return new _definition.GraphQLNonNull(nullableType);
-	    }
-	    return getInputTypeFromAST(typeAST);
-	  }
-
-	  function buildOutputFieldType(typeAST) {
-	    if (typeAST.kind === _kinds.LIST_TYPE) {
-	      return new _definition.GraphQLList(buildOutputFieldType(typeAST.type));
-	    }
-	    if (typeAST.kind === _kinds.NON_NULL_TYPE) {
-	      var nullableType = buildOutputFieldType(typeAST.type);
-	      (0, _invariant2.default)(!(nullableType instanceof _definition.GraphQLNonNull), 'Must be nullable');
-	      return new _definition.GraphQLNonNull(nullableType);
-	    }
-	    return getOutputTypeFromAST(typeAST);
-	  }
-	}
-
-	function cannotExecuteExtendedSchema() {
-	  throw new Error('Extended Schema cannot use Interface or Union types for execution.');
-	}
-
-/***/ },
-/* 258 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.printSchema = printSchema;
-	exports.printIntrospectionSchema = printIntrospectionSchema;
-
-	var _invariant = __webpack_require__(200);
-
-	var _invariant2 = _interopRequireDefault(_invariant);
-
-	var _isNullish = __webpack_require__(204);
-
-	var _isNullish2 = _interopRequireDefault(_isNullish);
-
-	var _astFromValue = __webpack_require__(209);
-
-	var _printer = __webpack_require__(194);
-
-	var _definition = __webpack_require__(203);
-
-	var _scalars = __webpack_require__(207);
-
-	var _directives = __webpack_require__(206);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function printSchema(schema) {
-	  return printFilteredSchema(schema, function (n) {
-	    return !isSpecDirective(n);
-	  }, isDefinedType);
-	}
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function printIntrospectionSchema(schema) {
-	  return printFilteredSchema(schema, isSpecDirective, isIntrospectionType);
-	}
-
-	function isSpecDirective(directiveName) {
-	  return directiveName === 'skip' || directiveName === 'include' || directiveName === 'deprecated';
-	}
-
-	function isDefinedType(typename) {
-	  return !isIntrospectionType(typename) && !isBuiltInScalar(typename);
-	}
-
-	function isIntrospectionType(typename) {
-	  return typename.indexOf('__') === 0;
-	}
-
-	function isBuiltInScalar(typename) {
-	  return typename === 'String' || typename === 'Boolean' || typename === 'Int' || typename === 'Float' || typename === 'ID';
-	}
-
-	function printFilteredSchema(schema, directiveFilter, typeFilter) {
-	  var directives = schema.getDirectives().filter(function (directive) {
-	    return directiveFilter(directive.name);
-	  });
-	  var typeMap = schema.getTypeMap();
-	  var types = Object.keys(typeMap).filter(typeFilter).sort(function (name1, name2) {
-	    return name1.localeCompare(name2);
-	  }).map(function (typeName) {
-	    return typeMap[typeName];
-	  });
-
-	  return [printSchemaDefinition(schema)].concat(directives.map(printDirective), types.map(printType)).filter(Boolean).join('\n\n') + '\n';
-	}
-
-	function printSchemaDefinition(schema) {
-	  if (isSchemaOfCommonNames(schema)) {
-	    return;
-	  }
-
-	  var operationTypes = [];
-
-	  var queryType = schema.getQueryType();
-	  if (queryType) {
-	    operationTypes.push('  query: ' + queryType.name);
-	  }
-
-	  var mutationType = schema.getMutationType();
-	  if (mutationType) {
-	    operationTypes.push('  mutation: ' + mutationType.name);
-	  }
-
-	  var subscriptionType = schema.getSubscriptionType();
-	  if (subscriptionType) {
-	    operationTypes.push('  subscription: ' + subscriptionType.name);
-	  }
-
-	  return 'schema {\n' + operationTypes.join('\n') + '\n}';
-	}
-
-	/**
-	 * GraphQL schema define root types for each type of operation. These types are
-	 * the same as any other type and can be named in any manner, however there is
-	 * a common naming convention:
-	 *
-	 *   schema {
-	 *     query: Query
-	 *     mutation: Mutation
-	 *   }
-	 *
-	 * When using this naming convention, the schema description can be omitted.
-	 */
-	function isSchemaOfCommonNames(schema) {
-	  var queryType = schema.getQueryType();
-	  if (queryType && queryType.name !== 'Query') {
-	    return false;
-	  }
-
-	  var mutationType = schema.getMutationType();
-	  if (mutationType && mutationType.name !== 'Mutation') {
-	    return false;
-	  }
-
-	  var subscriptionType = schema.getSubscriptionType();
-	  if (subscriptionType && subscriptionType.name !== 'Subscription') {
-	    return false;
-	  }
-
-	  return true;
-	}
-
-	function printType(type) {
-	  if (type instanceof _definition.GraphQLScalarType) {
-	    return printScalar(type);
-	  } else if (type instanceof _definition.GraphQLObjectType) {
-	    return printObject(type);
-	  } else if (type instanceof _definition.GraphQLInterfaceType) {
-	    return printInterface(type);
-	  } else if (type instanceof _definition.GraphQLUnionType) {
-	    return printUnion(type);
-	  } else if (type instanceof _definition.GraphQLEnumType) {
-	    return printEnum(type);
-	  }
-	  (0, _invariant2.default)(type instanceof _definition.GraphQLInputObjectType);
-	  return printInputObject(type);
-	}
-
-	function printScalar(type) {
-	  return printDescription(type) + ('scalar ' + type.name);
-	}
-
-	function printObject(type) {
-	  var interfaces = type.getInterfaces();
-	  var implementedInterfaces = interfaces.length ? ' implements ' + interfaces.map(function (i) {
-	    return i.name;
-	  }).join(', ') : '';
-	  return printDescription(type) + ('type ' + type.name + implementedInterfaces + ' {\n') + printFields(type) + '\n' + '}';
-	}
-
-	function printInterface(type) {
-	  return printDescription(type) + ('interface ' + type.name + ' {\n') + printFields(type) + '\n' + '}';
-	}
-
-	function printUnion(type) {
-	  return printDescription(type) + ('union ' + type.name + ' = ' + type.getTypes().join(' | '));
-	}
-
-	function printEnum(type) {
-	  return printDescription(type) + ('enum ' + type.name + ' {\n') + printEnumValues(type.getValues()) + '\n' + '}';
-	}
-
-	function printEnumValues(values) {
-	  return values.map(function (value, i) {
-	    return printDescription(value, '  ', !i) + '  ' + value.name + printDeprecated(value);
-	  }).join('\n');
-	}
-
-	function printInputObject(type) {
-	  var fieldMap = type.getFields();
-	  var fields = Object.keys(fieldMap).map(function (fieldName) {
-	    return fieldMap[fieldName];
-	  });
-	  return printDescription(type) + ('input ' + type.name + ' {\n') + fields.map(function (f, i) {
-	    return printDescription(f, '  ', !i) + '  ' + printInputValue(f);
-	  }).join('\n') + '\n' + '}';
-	}
-
-	function printFields(type) {
-	  var fieldMap = type.getFields();
-	  var fields = Object.keys(fieldMap).map(function (fieldName) {
-	    return fieldMap[fieldName];
-	  });
-	  return fields.map(function (f, i) {
-	    return printDescription(f, '  ', !i) + '  ' + f.name + printArgs(f.args, '  ') + ': ' + String(f.type) + printDeprecated(f);
-	  }).join('\n');
-	}
-
-	function printArgs(args) {
-	  var indentation = arguments.length <= 1 || arguments[1] === undefined ? '' : arguments[1];
-
-	  if (args.length === 0) {
-	    return '';
-	  }
-
-	  // If every arg does not have a description, print them on one line.
-	  if (args.every(function (arg) {
-	    return !arg.description;
-	  })) {
-	    return '(' + args.map(printInputValue).join(', ') + ')';
-	  }
-
-	  return '(\n' + args.map(function (arg, i) {
-	    return printDescription(arg, '  ' + indentation, !i) + '  ' + indentation + printInputValue(arg);
-	  }).join('\n') + '\n' + indentation + ')';
-	}
-
-	function printInputValue(arg) {
-	  var argDecl = arg.name + ': ' + String(arg.type);
-	  if (!(0, _isNullish2.default)(arg.defaultValue)) {
-	    argDecl += ' = ' + (0, _printer.print)((0, _astFromValue.astFromValue)(arg.defaultValue, arg.type));
-	  }
-	  return argDecl;
-	}
-
-	function printDirective(directive) {
-	  return printDescription(directive) + 'directive @' + directive.name + printArgs(directive.args) + ' on ' + directive.locations.join(' | ');
-	}
-
-	function printDeprecated(fieldOrEnumVal) {
-	  var reason = fieldOrEnumVal.deprecationReason;
-	  if ((0, _isNullish2.default)(reason)) {
-	    return '';
-	  }
-	  if (reason === '' || reason === _directives.DEFAULT_DEPRECATION_REASON) {
-	    return ' @deprecated';
-	  }
-	  return ' @deprecated(reason: ' + (0, _printer.print)((0, _astFromValue.astFromValue)(reason, _scalars.GraphQLString)) + ')';
-	}
-
-	function printDescription(def) {
-	  var indentation = arguments.length <= 1 || arguments[1] === undefined ? '' : arguments[1];
-	  var firstInBlock = arguments.length <= 2 || arguments[2] === undefined ? true : arguments[2];
-
-	  if (!def.description) {
-	    return '';
-	  }
-	  var lines = def.description.split('\n');
-	  var description = indentation && !firstInBlock ? '\n' : '';
-	  for (var i = 0; i < lines.length; i++) {
-	    if (lines[i] === '') {
-	      description += indentation + '#\n';
-	    } else {
-	      // For > 120 character long lines, cut at space boundaries into sublines
-	      // of ~80 chars.
-	      var sublines = breakLine(lines[i], 120 - indentation.length);
-	      for (var j = 0; j < sublines.length; j++) {
-	        description += indentation + '# ' + sublines[j] + '\n';
-	      }
-	    }
-	  }
-	  return description;
-	}
-
-	function breakLine(line, len) {
-	  if (line.length < len + 5) {
-	    return [line];
-	  }
-	  var parts = line.split(new RegExp('((?: |^).{15,' + (len - 40) + '}(?= |$))'));
-	  if (parts.length < 4) {
-	    return [line];
-	  }
-	  var sublines = [parts[0] + parts[1] + parts[2]];
-	  for (var i = 3; i < parts.length; i += 2) {
-	    sublines.push(parts[i].slice(1) + parts[i + 1]);
-	  }
-	  return sublines;
-	}
-
-/***/ },
-/* 259 */
-/***/ function(module, exports) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.concatAST = concatAST;
-
-
-	/**
-	 * Provided a collection of ASTs, presumably each from different files,
-	 * concatenate the ASTs together into batched AST, useful for validating many
-	 * GraphQL source files which together represent one conceptual application.
-	 */
-	function concatAST(asts) {
-	  var batchDefinitions = [];
-	  for (var i = 0; i < asts.length; i++) {
-	    var definitions = asts[i].definitions;
-	    for (var j = 0; j < definitions.length; j++) {
-	      batchDefinitions.push(definitions[j]);
-	    }
-	  }
-	  return {
-	    kind: 'Document',
-	    definitions: batchDefinitions
-	  };
-	}
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-/***/ },
-/* 260 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.separateOperations = separateOperations;
-
-	var _visitor = __webpack_require__(195);
-
-	/**
-	 * separateOperations accepts a single AST document which may contain many
-	 * operations and fragments and returns a collection of AST documents each of
-	 * which contains a single operation as well the fragment definitions it
-	 * refers to.
-	 */
-	function separateOperations(documentAST) {
-
-	  var operations = [];
-	  var depGraph = Object.create(null);
-	  var fromName = void 0;
-
-	  // Populate the list of operations and build a dependency graph.
-	  (0, _visitor.visit)(documentAST, {
-	    OperationDefinition: function OperationDefinition(node) {
-	      operations.push(node);
-	      fromName = opName(node);
-	    },
-	    FragmentDefinition: function FragmentDefinition(node) {
-	      fromName = node.name.value;
-	    },
-	    FragmentSpread: function FragmentSpread(node) {
-	      var toName = node.name.value;
-	      (depGraph[fromName] || (depGraph[fromName] = Object.create(null)))[toName] = true;
-	    }
-	  });
-
-	  // For each operation, produce a new synthesized AST which includes only what
-	  // is necessary for completing that operation.
-	  var separatedDocumentASTs = Object.create(null);
-	  operations.forEach(function (operation) {
-	    var operationName = opName(operation);
-	    var dependencies = Object.create(null);
-	    collectTransitiveDependencies(dependencies, depGraph, operationName);
-
-	    separatedDocumentASTs[operationName] = {
-	      kind: 'Document',
-	      definitions: documentAST.definitions.filter(function (def) {
-	        return def === operation || def.kind === 'FragmentDefinition' && dependencies[def.name.value];
-	      })
-	    };
-	  });
-
-	  return separatedDocumentASTs;
-	}
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	// Provides the empty string for anonymous operations.
-	function opName(operation) {
-	  return operation.name ? operation.name.value : '';
-	}
-
-	// From a dependency graph, collects a list of transitive dependencies by
-	// recursing through a dependency graph.
-	function collectTransitiveDependencies(collected, depGraph, fromName) {
-	  var immediateDeps = depGraph[fromName];
-	  if (immediateDeps) {
-	    Object.keys(immediateDeps).forEach(function (toName) {
-	      if (!collected[toName]) {
-	        collected[toName] = true;
-	        collectTransitiveDependencies(collected, depGraph, toName);
-	      }
-	    });
-	  }
-	}
-
-/***/ },
-/* 261 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.BreakingChangeType = undefined;
-	exports.findBreakingChanges = findBreakingChanges;
-	exports.findRemovedTypes = findRemovedTypes;
-	exports.findTypesThatChangedKind = findTypesThatChangedKind;
-	exports.findFieldsThatChangedType = findFieldsThatChangedType;
-	exports.findTypesRemovedFromUnions = findTypesRemovedFromUnions;
-	exports.findValuesRemovedFromEnums = findValuesRemovedFromEnums;
-
-	var _definition = __webpack_require__(203);
-
-	var _schema = __webpack_require__(202);
-
-	/**
-	 *  Copyright (c) 2016, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	var BreakingChangeType = exports.BreakingChangeType = {
-	  FIELD_CHANGED_KIND: 'FIELD_CHANGED_KIND',
-	  FIELD_REMOVED: 'FIELD_REMOVED',
-	  TYPE_CHANGED_KIND: 'TYPE_CHANGED_KIND',
-	  TYPE_REMOVED: 'TYPE_REMOVED',
-	  TYPE_REMOVED_FROM_UNION: 'TYPE_REMOVED_FROM_UNION',
-	  VALUE_REMOVED_FROM_ENUM: 'VALUE_REMOVED_FROM_ENUM'
-	};
-
-	/**
-	 * Given two schemas, returns an Array containing descriptions of all the types
-	 * of breaking changes covered by the other functions down below.
-	 */
-	function findBreakingChanges(oldSchema, newSchema) {
-	  return [].concat(findRemovedTypes(oldSchema, newSchema), findTypesThatChangedKind(oldSchema, newSchema), findFieldsThatChangedType(oldSchema, newSchema), findTypesRemovedFromUnions(oldSchema, newSchema), findValuesRemovedFromEnums(oldSchema, newSchema));
-	}
-
-	/**
-	 * Given two schemas, returns an Array containing descriptions of any breaking
-	 * changes in the newSchema related to removing an entire type.
-	 */
-	function findRemovedTypes(oldSchema, newSchema) {
-	  var oldTypeMap = oldSchema.getTypeMap();
-	  var newTypeMap = newSchema.getTypeMap();
-
-	  var breakingChanges = [];
-	  Object.keys(oldTypeMap).forEach(function (typeName) {
-	    if (!newTypeMap[typeName]) {
-	      breakingChanges.push({
-	        type: BreakingChangeType.TYPE_REMOVED,
-	        description: typeName + ' was removed.'
-	      });
-	    }
-	  });
-	  return breakingChanges;
-	}
-
-	/**
-	 * Given two schemas, returns an Array containing descriptions of any breaking
-	 * changes in the newSchema related to changing the type of a type.
-	 */
-	function findTypesThatChangedKind(oldSchema, newSchema) {
-	  var oldTypeMap = oldSchema.getTypeMap();
-	  var newTypeMap = newSchema.getTypeMap();
-
-	  var breakingChanges = [];
-	  Object.keys(oldTypeMap).forEach(function (typeName) {
-	    if (!newTypeMap[typeName]) {
-	      return;
-	    }
-	    var oldType = oldTypeMap[typeName];
-	    var newType = newTypeMap[typeName];
-	    if (!(oldType instanceof newType.constructor)) {
-	      breakingChanges.push({
-	        type: BreakingChangeType.TYPE_CHANGED_KIND,
-	        description: typeName + ' changed from ' + (typeKindName(oldType) + ' to ' + typeKindName(newType) + '.')
-	      });
-	    }
-	  });
-	  return breakingChanges;
-	}
-
-	function typeKindName(type) {
-	  if (type instanceof _definition.GraphQLScalarType) {
-	    return 'a Scalar type';
-	  }
-	  if (type instanceof _definition.GraphQLObjectType) {
-	    return 'an Object type';
-	  }
-	  if (type instanceof _definition.GraphQLInterfaceType) {
-	    return 'an Interface type';
-	  }
-	  if (type instanceof _definition.GraphQLUnionType) {
-	    return 'a Union type';
-	  }
-	  if (type instanceof _definition.GraphQLEnumType) {
-	    return 'an Enum type';
-	  }
-	  if (type instanceof _definition.GraphQLInputObjectType) {
-	    return 'an Input type';
-	  }
-	  throw new TypeError('Unknown type ' + type.constructor.name);
-	}
-
-	/**
-	 * Given two schemas, returns an Array containing descriptions of any breaking
-	 * changes in the newSchema related to the fields on a type. This includes if
-	 * a field has been removed from a type or if a field has changed type.
-	 */
-	function findFieldsThatChangedType(oldSchema, newSchema) {
-	  var oldTypeMap = oldSchema.getTypeMap();
-	  var newTypeMap = newSchema.getTypeMap();
-
-	  var breakingFieldChanges = [];
-	  Object.keys(oldTypeMap).forEach(function (typeName) {
-	    var oldType = oldTypeMap[typeName];
-	    var newType = newTypeMap[typeName];
-	    if (!(oldType instanceof _definition.GraphQLObjectType || oldType instanceof _definition.GraphQLInterfaceType || oldType instanceof _definition.GraphQLInputObjectType) || !(newType instanceof oldType.constructor)) {
-	      return;
-	    }
-
-	    var oldTypeFieldsDef = oldType.getFields();
-	    var newTypeFieldsDef = newType.getFields();
-	    Object.keys(oldTypeFieldsDef).forEach(function (fieldName) {
-	      // Check if the field is missing on the type in the new schema.
-	      if (!(fieldName in newTypeFieldsDef)) {
-	        breakingFieldChanges.push({
-	          type: BreakingChangeType.FIELD_REMOVED,
-	          description: typeName + '.' + fieldName + ' was removed.'
-	        });
-	      } else {
-	        // Check if the field's type has changed in the new schema.
-	        var oldFieldType = (0, _definition.getNamedType)(oldTypeFieldsDef[fieldName].type);
-	        var newFieldType = (0, _definition.getNamedType)(newTypeFieldsDef[fieldName].type);
-	        if (oldFieldType && newFieldType && oldFieldType.name !== newFieldType.name) {
-	          breakingFieldChanges.push({
-	            type: BreakingChangeType.FIELD_CHANGED_KIND,
-	            description: typeName + '.' + fieldName + ' changed type from ' + (oldFieldType.name + ' to ' + newFieldType.name + '.')
-	          });
-	        }
-	      }
-	    });
-	  });
-	  return breakingFieldChanges;
-	}
-
-	/**
-	 * Given two schemas, returns an Array containing descriptions of any breaking
-	 * changes in the newSchema related to removing types from a union type.
-	 */
-	function findTypesRemovedFromUnions(oldSchema, newSchema) {
-	  var oldTypeMap = oldSchema.getTypeMap();
-	  var newTypeMap = newSchema.getTypeMap();
-
-	  var typesRemovedFromUnion = [];
-	  Object.keys(oldTypeMap).forEach(function (typeName) {
-	    var oldType = oldTypeMap[typeName];
-	    var newType = newTypeMap[typeName];
-	    if (!(oldType instanceof _definition.GraphQLUnionType) || !(newType instanceof _definition.GraphQLUnionType)) {
-	      return;
-	    }
-	    var typeNamesInNewUnion = Object.create(null);
-	    newType.getTypes().forEach(function (type) {
-	      typeNamesInNewUnion[type.name] = true;
-	    });
-	    oldType.getTypes().forEach(function (type) {
-	      if (!typeNamesInNewUnion[type.name]) {
-	        typesRemovedFromUnion.push({
-	          type: BreakingChangeType.TYPE_REMOVED_FROM_UNION,
-	          description: type.name + ' was removed from union type ' + typeName + '.'
-	        });
-	      }
-	    });
-	  });
-	  return typesRemovedFromUnion;
-	}
-
-	/**
-	 * Given two schemas, returns an Array containing descriptions of any breaking
-	 * changes in the newSchema related to removing values from an enum type.
-	 */
-	function findValuesRemovedFromEnums(oldSchema, newSchema) {
-	  var oldTypeMap = oldSchema.getTypeMap();
-	  var newTypeMap = newSchema.getTypeMap();
-
-	  var valuesRemovedFromEnums = [];
-	  Object.keys(oldTypeMap).forEach(function (typeName) {
-	    var oldType = oldTypeMap[typeName];
-	    var newType = newTypeMap[typeName];
-	    if (!(oldType instanceof _definition.GraphQLEnumType) || !(newType instanceof _definition.GraphQLEnumType)) {
-	      return;
-	    }
-	    var valuesInNewEnum = Object.create(null);
-	    newType.getValues().forEach(function (value) {
-	      valuesInNewEnum[value.name] = true;
-	    });
-	    oldType.getValues().forEach(function (value) {
-	      if (!valuesInNewEnum[value.name]) {
-	        valuesRemovedFromEnums.push({
-	          type: BreakingChangeType.VALUE_REMOVED_FROM_ENUM,
-	          description: value.name + ' was removed from enum type ' + typeName + '.'
-	        });
-	      }
-	    });
-	  });
-	  return valuesRemovedFromEnums;
-	}
-
-/***/ },
-/* 262 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.ExecuteButton = undefined;
-
-	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-	var _react = __webpack_require__(1);
-
-	var _react2 = _interopRequireDefault(_react);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /**
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  Copyright (c) 2015, Facebook, Inc.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  All rights reserved.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  This source code is licensed under the license found in the
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  LICENSE-examples file in the root directory of this source tree.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
-
-	/**
-	 * ExecuteButton
-	 *
-	 * What a nice round shiny button. Shows a drop-down when there are multiple
-	 * queries to run.
-	 */
-	var ExecuteButton = exports.ExecuteButton = function (_React$Component) {
-	  _inherits(ExecuteButton, _React$Component);
-
-	  function ExecuteButton(props) {
-	    _classCallCheck(this, ExecuteButton);
-
-	    var _this = _possibleConstructorReturn(this, (ExecuteButton.__proto__ || Object.getPrototypeOf(ExecuteButton)).call(this, props));
-
-	    _this._onClick = function () {
-	      if (_this.props.isRunning) {
-	        _this.props.onStop();
-	      } else {
-	        _this.props.onRun();
-	      }
-	    };
-
-	    _this._onOptionSelected = function (operation) {
-	      _this.setState({ optionsOpen: false });
-	      _this.props.onRun(operation.name && operation.name.value);
-	    };
-
-	    _this._onOptionsOpen = function (downEvent) {
-	      var initialPress = true;
-	      var downTarget = downEvent.target;
-	      _this.setState({ highlight: null, optionsOpen: true });
-
-	      var _onMouseUp = function onMouseUp(upEvent) {
-	        if (initialPress && upEvent.target === downTarget) {
-	          initialPress = false;
-	        } else {
-	          document.removeEventListener('mouseup', _onMouseUp);
-	          _onMouseUp = null;
-	          var isOptionsMenuClicked = downTarget.parentNode.compareDocumentPosition(upEvent.target) & Node.DOCUMENT_POSITION_CONTAINED_BY;
-	          if (!isOptionsMenuClicked) {
-	            // menu calls setState if it was clicked
-	            _this.setState({ optionsOpen: false });
-	          }
-	        }
-	      };
-
-	      document.addEventListener('mouseup', _onMouseUp);
-	    };
-
-	    _this.state = {
-	      optionsOpen: false,
-	      highlight: null
-	    };
-	    return _this;
-	  }
-
-	  _createClass(ExecuteButton, [{
-	    key: 'render',
-	    value: function render() {
-	      var _this2 = this;
-
-	      var operations = this.props.operations;
-	      var optionsOpen = this.state.optionsOpen;
-	      var hasOptions = operations && operations.length > 1;
-
-	      var options = null;
-	      if (hasOptions && optionsOpen) {
-	        (function () {
-	          var highlight = _this2.state.highlight;
-	          options = _react2.default.createElement(
-	            'ul',
-	            { className: 'execute-options' },
-	            operations.map(function (operation) {
-	              return _react2.default.createElement(
-	                'li',
-	                {
-	                  key: operation.name ? operation.name.value : '*',
-	                  className: operation === highlight && 'selected',
-	                  onMouseOver: function onMouseOver() {
-	                    return _this2.setState({ highlight: operation });
-	                  },
-	                  onMouseOut: function onMouseOut() {
-	                    return _this2.setState({ highlight: null });
-	                  },
-	                  onMouseUp: function onMouseUp() {
-	                    return _this2._onOptionSelected(operation);
-	                  } },
-	                operation.name ? operation.name.value : '<Unnamed>'
-	              );
-	            })
-	          );
-	        })();
-	      }
-
-	      // Allow click event if there is a running query or if there are not options
-	      // for which operation to run.
-	      var onClick = void 0;
-	      if (this.props.isRunning || !hasOptions) {
-	        onClick = this._onClick;
-	      }
-
-	      // Allow mouse down if there is no running query, there are options for
-	      // which operation to run, and the dropdown is currently closed.
-	      var onMouseDown = void 0;
-	      if (!this.props.isRunning && hasOptions && !optionsOpen) {
-	        onMouseDown = this._onOptionsOpen;
-	      }
-
-	      var pathJSX = this.props.isRunning ? _react2.default.createElement('path', { d: 'M 10 10 L 23 10 L 23 23 L 10 23 z' }) : _react2.default.createElement('path', { d: 'M 11 9 L 24 16 L 11 23 z' });
-
-	      return _react2.default.createElement(
-	        'div',
-	        { className: 'execute-button-wrap' },
-	        _react2.default.createElement(
-	          'button',
-	          {
-	            className: 'execute-button',
-	            onMouseDown: onMouseDown,
-	            onClick: onClick,
-	            title: 'Execute Query (Ctrl-Enter)' },
-	          _react2.default.createElement(
-	            'svg',
-	            { width: '34', height: '34' },
-	            pathJSX
-	          )
-	        ),
-	        options
-	      );
-	    }
-	  }]);
-
-	  return ExecuteButton;
-	}(_react2.default.Component);
-
-	ExecuteButton.propTypes = {
-	  onRun: _react.PropTypes.func,
-	  onStop: _react.PropTypes.func,
-	  isRunning: _react.PropTypes.bool,
-	  operations: _react.PropTypes.array
-	};
-
-/***/ },
-/* 263 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.ToolbarButton = undefined;
-
-	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-	var _react = __webpack_require__(1);
-
-	var _react2 = _interopRequireDefault(_react);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /**
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  Copyright (c) 2015, Facebook, Inc.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  All rights reserved.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  This source code is licensed under the license found in the
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  LICENSE-examples file in the root directory of this source tree.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
-
-	/**
-	 * ToolbarButton
-	 *
-	 * A button to use within the Toolbar.
-	 */
-	var ToolbarButton = exports.ToolbarButton = function (_React$Component) {
-	  _inherits(ToolbarButton, _React$Component);
-
-	  function ToolbarButton(props) {
-	    _classCallCheck(this, ToolbarButton);
-
-	    var _this = _possibleConstructorReturn(this, (ToolbarButton.__proto__ || Object.getPrototypeOf(ToolbarButton)).call(this, props));
-
-	    _this.handleClick = function (e) {
-	      e.preventDefault();
-	      try {
-	        _this.props.onClick();
-	        _this.setState({ error: null });
-	      } catch (error) {
-	        _this.setState({ error: error });
-	      }
-	    };
-
-	    _this.state = { error: null };
-	    return _this;
-	  }
-
-	  _createClass(ToolbarButton, [{
-	    key: 'render',
-	    value: function render() {
-	      var error = this.state.error;
-
-	      return _react2.default.createElement(
-	        'a',
-	        {
-	          className: 'toolbar-button' + (error ? ' error' : ''),
-	          onClick: this.handleClick,
-	          title: error ? error.message : this.props.title },
-	        this.props.label
-	      );
-	    }
-	  }]);
-
-	  return ToolbarButton;
-	}(_react2.default.Component);
-
-	ToolbarButton.propTypes = {
-	  onClick: _react.PropTypes.func,
-	  title: _react.PropTypes.string,
-	  label: _react.PropTypes.string
-	};
-
-/***/ },
-/* 264 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.QueryEditor = undefined;
-
-	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-	var _react = __webpack_require__(1);
-
-	var _react2 = _interopRequireDefault(_react);
-
-	var _reactDom = __webpack_require__(32);
-
-	var _reactDom2 = _interopRequireDefault(_reactDom);
-
-	var _graphql = __webpack_require__(185);
-
-	var _onHasCompletion = __webpack_require__(265);
-
-	var _onHasCompletion2 = _interopRequireDefault(_onHasCompletion);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /**
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  Copyright (c) 2015, Facebook, Inc.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  All rights reserved.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  This source code is licensed under the license found in the
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  LICENSE-examples file in the root directory of this source tree.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
-
-	/**
-	 * QueryEditor
-	 *
-	 * Maintains an instance of CodeMirror responsible for editing a GraphQL query.
-	 *
-	 * Props:
-	 *
-	 *   - schema: A GraphQLSchema instance enabling editor linting and hinting.
-	 *   - value: The text of the editor.
-	 *   - onEdit: A function called when the editor changes, given the edited text.
-	 *
-	 */
-	var QueryEditor = exports.QueryEditor = function (_React$Component) {
-	  _inherits(QueryEditor, _React$Component);
-
-	  function QueryEditor(props) {
-	    _classCallCheck(this, QueryEditor);
-
-	    // Keep a cached version of the value, this cache will be updated when the
-	    // editor is updated, which can later be used to protect the editor from
-	    // unnecessary updates during the update lifecycle.
-	    var _this = _possibleConstructorReturn(this, (QueryEditor.__proto__ || Object.getPrototypeOf(QueryEditor)).call(this));
-
-	    _this._onKeyUp = function (cm, event) {
-	      var code = event.keyCode;
-	      if (code >= 65 && code <= 90 || // letters
-	      !event.shiftKey && code >= 48 && code <= 57 || // numbers
-	      event.shiftKey && code === 189 || // underscore
-	      event.shiftKey && code === 50 || // @
-	      event.shiftKey && code === 57 // (
-	      ) {
-	          _this.editor.execCommand('autocomplete');
-	        }
-	    };
-
-	    _this._onEdit = function () {
-	      if (!_this.ignoreChangeEvent) {
-	        _this.cachedValue = _this.editor.getValue();
-	        if (_this.props.onEdit) {
-	          _this.props.onEdit(_this.cachedValue);
-	        }
-	      }
-	    };
-
-	    _this._onHasCompletion = function (cm, data) {
-	      (0, _onHasCompletion2.default)(cm, data, _this.props.onHintInformationRender);
-	    };
-
-	    _this.cachedValue = props.value || '';
-	    return _this;
-	  }
-
-	  _createClass(QueryEditor, [{
-	    key: 'componentDidMount',
-	    value: function componentDidMount() {
-	      var _this2 = this;
-
-	      // Lazily require to ensure requiring GraphiQL outside of a Browser context
-	      // does not produce an error.
-	      var CodeMirror = __webpack_require__(267);
-	      __webpack_require__(268);
-	      __webpack_require__(269);
-	      __webpack_require__(270);
-	      __webpack_require__(271);
-	      __webpack_require__(272);
-	      __webpack_require__(274);
-	      __webpack_require__(275);
-	      __webpack_require__(276);
-	      __webpack_require__(278);
-	      __webpack_require__(288);
-	      __webpack_require__(289);
-
-	      this.editor = CodeMirror(_reactDom2.default.findDOMNode(this), {
-	        value: this.props.value || '',
-	        lineNumbers: true,
-	        tabSize: 2,
-	        mode: 'graphql',
-	        theme: 'graphiql',
-	        keyMap: 'sublime',
-	        autoCloseBrackets: true,
-	        matchBrackets: true,
-	        showCursorWhenSelecting: true,
-	        foldGutter: {
-	          minFoldSize: 4
-	        },
-	        lint: {
-	          schema: this.props.schema
-	        },
-	        hintOptions: {
-	          schema: this.props.schema,
-	          closeOnUnfocus: false,
-	          completeSingle: false
-	        },
-	        gutters: ['CodeMirror-linenumbers', 'CodeMirror-foldgutter'],
-	        extraKeys: {
-	          'Cmd-Space': function CmdSpace() {
-	            return _this2.editor.showHint({ completeSingle: true });
-	          },
-	          'Ctrl-Space': function CtrlSpace() {
-	            return _this2.editor.showHint({ completeSingle: true });
-	          },
-	          'Alt-Space': function AltSpace() {
-	            return _this2.editor.showHint({ completeSingle: true });
-	          },
-	          'Shift-Space': function ShiftSpace() {
-	            return _this2.editor.showHint({ completeSingle: true });
-	          },
-
-	          'Cmd-Enter': function CmdEnter() {
-	            if (_this2.props.onRunQuery) {
-	              _this2.props.onRunQuery();
-	            }
-	          },
-	          'Ctrl-Enter': function CtrlEnter() {
-	            if (_this2.props.onRunQuery) {
-	              _this2.props.onRunQuery();
-	            }
-	          },
-
-	          // Editor improvements
-	          'Ctrl-Left': 'goSubwordLeft',
-	          'Ctrl-Right': 'goSubwordRight',
-	          'Alt-Left': 'goGroupLeft',
-	          'Alt-Right': 'goGroupRight'
-	        }
-	      });
-
-	      this.editor.on('change', this._onEdit);
-	      this.editor.on('keyup', this._onKeyUp);
-	      this.editor.on('hasCompletion', this._onHasCompletion);
-	    }
-	  }, {
-	    key: 'componentDidUpdate',
-	    value: function componentDidUpdate(prevProps) {
-	      var CodeMirror = __webpack_require__(267);
-
-	      // Ensure the changes caused by this update are not interpretted as
-	      // user-input changes which could otherwise result in an infinite
-	      // event loop.
-	      this.ignoreChangeEvent = true;
-	      if (this.props.schema !== prevProps.schema) {
-	        this.editor.options.lint.schema = this.props.schema;
-	        this.editor.options.hintOptions.schema = this.props.schema;
-	        CodeMirror.signal(this.editor, 'change', this.editor);
-	      }
-	      if (this.props.value !== prevProps.value && this.props.value !== this.cachedValue) {
-	        this.cachedValue = this.props.value;
-	        this.editor.setValue(this.props.value);
-	      }
-	      this.ignoreChangeEvent = false;
-	    }
-	  }, {
-	    key: 'componentWillUnmount',
-	    value: function componentWillUnmount() {
-	      this.editor.off('change', this._onEdit);
-	      this.editor.off('keyup', this._onKeyUp);
-	      this.editor.off('hasCompletion', this._onHasCompletion);
-	      this.editor = null;
-	    }
-	  }, {
-	    key: 'render',
-	    value: function render() {
-	      return _react2.default.createElement('div', { className: 'query-editor' });
-	    }
-
-	    /**
-	     * Public API for retrieving the CodeMirror instance from this
-	     * React component.
-	     */
-
-	  }, {
-	    key: 'getCodeMirror',
-	    value: function getCodeMirror() {
-	      return this.editor;
-	    }
-
-	    /**
-	     * Render a custom UI for CodeMirror's hint which includes additional info
-	     * about the type and description for the selected context.
-	     */
-
-	  }]);
-
-	  return QueryEditor;
-	}(_react2.default.Component);
-
-	QueryEditor.propTypes = {
-	  schema: _react.PropTypes.instanceOf(_graphql.GraphQLSchema),
-	  value: _react.PropTypes.string,
-	  onEdit: _react.PropTypes.func,
-	  onHintInformationRender: _react.PropTypes.func,
-	  onRunQuery: _react.PropTypes.func
-	};
-
-/***/ },
-/* 265 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.default = onHasCompletion;
-
-	var _graphql = __webpack_require__(185);
-
-	var _marked = __webpack_require__(266);
-
-	var _marked2 = _interopRequireDefault(_marked);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 * Render a custom UI for CodeMirror's hint which includes additional info
-	 * about the type and description for the selected context.
-	 */
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function onHasCompletion(cm, data, onHintInformationRender) {
-	  var CodeMirror = __webpack_require__(267);
-
-	  var wrapper = void 0;
-	  var information = void 0;
-
-	  // When a hint result is selected, we touch the UI.
-	  CodeMirror.on(data, 'select', function (ctx, el) {
-	    // Only the first time (usually when the hint UI is first displayed)
-	    // do we create the wrapping node.
-	    if (!wrapper) {
-	      (function () {
-	        // Wrap the existing hint UI, so we have a place to put information.
-	        var hintsUl = el.parentNode;
-	        var container = hintsUl.parentNode;
-	        wrapper = document.createElement('div');
-	        container.appendChild(wrapper);
-
-	        // CodeMirror vertically inverts the hint UI if there is not enough
-	        // space below the cursor. Since this modified UI appends to the bottom
-	        // of CodeMirror's existing UI, it could cover the cursor. This adjusts
-	        // the positioning of the hint UI to accomodate.
-	        var top = hintsUl.style.top;
-	        var bottom = '';
-	        var cursorTop = cm.cursorCoords().top;
-	        if (parseInt(top, 10) < cursorTop) {
-	          top = '';
-	          bottom = window.innerHeight - cursorTop + 3 + 'px';
-	        }
-
-	        // Style the wrapper, remove positioning from hints. Note that usage
-	        // of this option will need to specify CSS to remove some styles from
-	        // the existing hint UI.
-	        wrapper.className = 'CodeMirror-hints-wrapper';
-	        wrapper.style.left = hintsUl.style.left;
-	        wrapper.style.top = top;
-	        wrapper.style.bottom = bottom;
-	        hintsUl.style.left = '';
-	        hintsUl.style.top = '';
-
-	        // This "information" node will contain the additional info about the
-	        // highlighted typeahead option.
-	        information = document.createElement('div');
-	        information.className = 'CodeMirror-hint-information';
-	        if (bottom) {
-	          wrapper.appendChild(information);
-	          wrapper.appendChild(hintsUl);
-	        } else {
-	          wrapper.appendChild(hintsUl);
-	          wrapper.appendChild(information);
-	        }
-
-	        // When CodeMirror attempts to remove the hint UI, we detect that it was
-	        // removed from our wrapper and in turn remove the wrapper from the
-	        // original container.
-	        var _onRemoveFn = void 0;
-	        wrapper.addEventListener('DOMNodeRemoved', _onRemoveFn = function onRemoveFn(event) {
-	          if (event.target === hintsUl) {
-	            wrapper.removeEventListener('DOMNodeRemoved', _onRemoveFn);
-	            wrapper.parentNode.removeChild(wrapper);
-	            wrapper = null;
-	            information = null;
-	            _onRemoveFn = null;
-	          }
-	        });
-	      })();
-	    }
-
-	    // Now that the UI has been set up, add info to information.
-	    var description = ctx.description ? (0, _marked2.default)(ctx.description, { smartypants: true }) : 'Self descriptive.';
-	    var type = ctx.type ? '<span class="infoType">' + renderType(ctx.type) + '</span>' : '';
-
-	    information.innerHTML = '<div class="content">' + (description.slice(0, 3) === '<p>' ? '<p>' + type + description.slice(3) : type + description) + '</div>';
-
-	    // Additional rendering?
-	    if (onHintInformationRender) {
-	      onHintInformationRender(information);
-	    }
-	  });
-	}
-
-	function renderType(type) {
-	  if (type instanceof _graphql.GraphQLNonNull) {
-	    return renderType(type.ofType) + '!';
-	  }
-	  if (type instanceof _graphql.GraphQLList) {
-	    return '[' + renderType(type.ofType) + ']';
-	  }
-	  return '<a class="typeName">' + type.name + '</a>';
-	}
-
-/***/ },
-/* 266 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/* WEBPACK VAR INJECTION */(function(global) {/**
-	 * marked - a markdown parser
-	 * Copyright (c) 2011-2014, Christopher Jeffrey. (MIT Licensed)
-	 * https://github.com/chjj/marked
-	 */
-
-	;(function() {
-
-	/**
-	 * Block-Level Grammar
-	 */
-
-	var block = {
-	  newline: /^\n+/,
-	  code: /^( {4}[^\n]+\n*)+/,
-	  fences: noop,
-	  hr: /^( *[-*_]){3,} *(?:\n+|$)/,
-	  heading: /^ *(#{1,6}) *([^\n]+?) *#* *(?:\n+|$)/,
-	  nptable: noop,
-	  lheading: /^([^\n]+)\n *(=|-){2,} *(?:\n+|$)/,
-	  blockquote: /^( *>[^\n]+(\n(?!def)[^\n]+)*\n*)+/,
-	  list: /^( *)(bull) [\s\S]+?(?:hr|def|\n{2,}(?! )(?!\1bull )\n*|\s*$)/,
-	  html: /^ *(?:comment *(?:\n|\s*$)|closed *(?:\n{2,}|\s*$)|closing *(?:\n{2,}|\s*$))/,
-	  def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +["(]([^\n]+)[")])? *(?:\n+|$)/,
-	  table: noop,
-	  paragraph: /^((?:[^\n]+\n?(?!hr|heading|lheading|blockquote|tag|def))+)\n*/,
-	  text: /^[^\n]+/
-	};
-
-	block.bullet = /(?:[*+-]|\d+\.)/;
-	block.item = /^( *)(bull) [^\n]*(?:\n(?!\1bull )[^\n]*)*/;
-	block.item = replace(block.item, 'gm')
-	  (/bull/g, block.bullet)
-	  ();
-
-	block.list = replace(block.list)
-	  (/bull/g, block.bullet)
-	  ('hr', '\\n+(?=\\1?(?:[-*_] *){3,}(?:\\n+|$))')
-	  ('def', '\\n+(?=' + block.def.source + ')')
-	  ();
-
-	block.blockquote = replace(block.blockquote)
-	  ('def', block.def)
-	  ();
-
-	block._tag = '(?!(?:'
-	  + 'a|em|strong|small|s|cite|q|dfn|abbr|data|time|code'
-	  + '|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo'
-	  + '|span|br|wbr|ins|del|img)\\b)\\w+(?!:/|[^\\w\\s@]*@)\\b';
-
-	block.html = replace(block.html)
-	  ('comment', /<!--[\s\S]*?-->/)
-	  ('closed', /<(tag)[\s\S]+?<\/\1>/)
-	  ('closing', /<tag(?:"[^"]*"|'[^']*'|[^'">])*?>/)
-	  (/tag/g, block._tag)
-	  ();
-
-	block.paragraph = replace(block.paragraph)
-	  ('hr', block.hr)
-	  ('heading', block.heading)
-	  ('lheading', block.lheading)
-	  ('blockquote', block.blockquote)
-	  ('tag', '<' + block._tag)
-	  ('def', block.def)
-	  ();
-
-	/**
-	 * Normal Block Grammar
-	 */
-
-	block.normal = merge({}, block);
-
-	/**
-	 * GFM Block Grammar
-	 */
-
-	block.gfm = merge({}, block.normal, {
-	  fences: /^ *(`{3,}|~{3,})[ \.]*(\S+)? *\n([\s\S]*?)\s*\1 *(?:\n+|$)/,
-	  paragraph: /^/,
-	  heading: /^ *(#{1,6}) +([^\n]+?) *#* *(?:\n+|$)/
-	});
-
-	block.gfm.paragraph = replace(block.paragraph)
-	  ('(?!', '(?!'
-	    + block.gfm.fences.source.replace('\\1', '\\2') + '|'
-	    + block.list.source.replace('\\1', '\\3') + '|')
-	  ();
-
-	/**
-	 * GFM + Tables Block Grammar
-	 */
-
-	block.tables = merge({}, block.gfm, {
-	  nptable: /^ *(\S.*\|.*)\n *([-:]+ *\|[-| :]*)\n((?:.*\|.*(?:\n|$))*)\n*/,
-	  table: /^ *\|(.+)\n *\|( *[-:]+[-| :]*)\n((?: *\|.*(?:\n|$))*)\n*/
-	});
-
-	/**
-	 * Block Lexer
-	 */
-
-	function Lexer(options) {
-	  this.tokens = [];
-	  this.tokens.links = {};
-	  this.options = options || marked.defaults;
-	  this.rules = block.normal;
-
-	  if (this.options.gfm) {
-	    if (this.options.tables) {
-	      this.rules = block.tables;
-	    } else {
-	      this.rules = block.gfm;
-	    }
-	  }
-	}
-
-	/**
-	 * Expose Block Rules
-	 */
-
-	Lexer.rules = block;
-
-	/**
-	 * Static Lex Method
-	 */
-
-	Lexer.lex = function(src, options) {
-	  var lexer = new Lexer(options);
-	  return lexer.lex(src);
-	};
-
-	/**
-	 * Preprocessing
-	 */
-
-	Lexer.prototype.lex = function(src) {
-	  src = src
-	    .replace(/\r\n|\r/g, '\n')
-	    .replace(/\t/g, '    ')
-	    .replace(/\u00a0/g, ' ')
-	    .replace(/\u2424/g, '\n');
-
-	  return this.token(src, true);
-	};
-
-	/**
-	 * Lexing
-	 */
-
-	Lexer.prototype.token = function(src, top, bq) {
-	  var src = src.replace(/^ +$/gm, '')
-	    , next
-	    , loose
-	    , cap
-	    , bull
-	    , b
-	    , item
-	    , space
-	    , i
-	    , l;
-
-	  while (src) {
-	    // newline
-	    if (cap = this.rules.newline.exec(src)) {
-	      src = src.substring(cap[0].length);
-	      if (cap[0].length > 1) {
-	        this.tokens.push({
-	          type: 'space'
-	        });
-	      }
-	    }
-
-	    // code
-	    if (cap = this.rules.code.exec(src)) {
-	      src = src.substring(cap[0].length);
-	      cap = cap[0].replace(/^ {4}/gm, '');
-	      this.tokens.push({
-	        type: 'code',
-	        text: !this.options.pedantic
-	          ? cap.replace(/\n+$/, '')
-	          : cap
-	      });
-	      continue;
-	    }
-
-	    // fences (gfm)
-	    if (cap = this.rules.fences.exec(src)) {
-	      src = src.substring(cap[0].length);
-	      this.tokens.push({
-	        type: 'code',
-	        lang: cap[2],
-	        text: cap[3] || ''
-	      });
-	      continue;
-	    }
-
-	    // heading
-	    if (cap = this.rules.heading.exec(src)) {
-	      src = src.substring(cap[0].length);
-	      this.tokens.push({
-	        type: 'heading',
-	        depth: cap[1].length,
-	        text: cap[2]
-	      });
-	      continue;
-	    }
-
-	    // table no leading pipe (gfm)
-	    if (top && (cap = this.rules.nptable.exec(src))) {
-	      src = src.substring(cap[0].length);
-
-	      item = {
-	        type: 'table',
-	        header: cap[1].replace(/^ *| *\| *$/g, '').split(/ *\| */),
-	        align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
-	        cells: cap[3].replace(/\n$/, '').split('\n')
-	      };
-
-	      for (i = 0; i < item.align.length; i++) {
-	        if (/^ *-+: *$/.test(item.align[i])) {
-	          item.align[i] = 'right';
-	        } else if (/^ *:-+: *$/.test(item.align[i])) {
-	          item.align[i] = 'center';
-	        } else if (/^ *:-+ *$/.test(item.align[i])) {
-	          item.align[i] = 'left';
-	        } else {
-	          item.align[i] = null;
-	        }
-	      }
-
-	      for (i = 0; i < item.cells.length; i++) {
-	        item.cells[i] = item.cells[i].split(/ *\| */);
-	      }
-
-	      this.tokens.push(item);
-
-	      continue;
-	    }
-
-	    // lheading
-	    if (cap = this.rules.lheading.exec(src)) {
-	      src = src.substring(cap[0].length);
-	      this.tokens.push({
-	        type: 'heading',
-	        depth: cap[2] === '=' ? 1 : 2,
-	        text: cap[1]
-	      });
-	      continue;
-	    }
-
-	    // hr
-	    if (cap = this.rules.hr.exec(src)) {
-	      src = src.substring(cap[0].length);
-	      this.tokens.push({
-	        type: 'hr'
-	      });
-	      continue;
-	    }
-
-	    // blockquote
-	    if (cap = this.rules.blockquote.exec(src)) {
-	      src = src.substring(cap[0].length);
-
-	      this.tokens.push({
-	        type: 'blockquote_start'
-	      });
-
-	      cap = cap[0].replace(/^ *> ?/gm, '');
-
-	      // Pass `top` to keep the current
-	      // "toplevel" state. This is exactly
-	      // how markdown.pl works.
-	      this.token(cap, top, true);
-
-	      this.tokens.push({
-	        type: 'blockquote_end'
-	      });
-
-	      continue;
-	    }
-
-	    // list
-	    if (cap = this.rules.list.exec(src)) {
-	      src = src.substring(cap[0].length);
-	      bull = cap[2];
-
-	      this.tokens.push({
-	        type: 'list_start',
-	        ordered: bull.length > 1
-	      });
-
-	      // Get each top-level item.
-	      cap = cap[0].match(this.rules.item);
-
-	      next = false;
-	      l = cap.length;
-	      i = 0;
-
-	      for (; i < l; i++) {
-	        item = cap[i];
-
-	        // Remove the list item's bullet
-	        // so it is seen as the next token.
-	        space = item.length;
-	        item = item.replace(/^ *([*+-]|\d+\.) +/, '');
-
-	        // Outdent whatever the
-	        // list item contains. Hacky.
-	        if (~item.indexOf('\n ')) {
-	          space -= item.length;
-	          item = !this.options.pedantic
-	            ? item.replace(new RegExp('^ {1,' + space + '}', 'gm'), '')
-	            : item.replace(/^ {1,4}/gm, '');
-	        }
-
-	        // Determine whether the next list item belongs here.
-	        // Backpedal if it does not belong in this list.
-	        if (this.options.smartLists && i !== l - 1) {
-	          b = block.bullet.exec(cap[i + 1])[0];
-	          if (bull !== b && !(bull.length > 1 && b.length > 1)) {
-	            src = cap.slice(i + 1).join('\n') + src;
-	            i = l - 1;
-	          }
-	        }
-
-	        // Determine whether item is loose or not.
-	        // Use: /(^|\n)(?! )[^\n]+\n\n(?!\s*$)/
-	        // for discount behavior.
-	        loose = next || /\n\n(?!\s*$)/.test(item);
-	        if (i !== l - 1) {
-	          next = item.charAt(item.length - 1) === '\n';
-	          if (!loose) loose = next;
-	        }
-
-	        this.tokens.push({
-	          type: loose
-	            ? 'loose_item_start'
-	            : 'list_item_start'
-	        });
-
-	        // Recurse.
-	        this.token(item, false, bq);
-
-	        this.tokens.push({
-	          type: 'list_item_end'
-	        });
-	      }
-
-	      this.tokens.push({
-	        type: 'list_end'
-	      });
-
-	      continue;
-	    }
-
-	    // html
-	    if (cap = this.rules.html.exec(src)) {
-	      src = src.substring(cap[0].length);
-	      this.tokens.push({
-	        type: this.options.sanitize
-	          ? 'paragraph'
-	          : 'html',
-	        pre: !this.options.sanitizer
-	          && (cap[1] === 'pre' || cap[1] === 'script' || cap[1] === 'style'),
-	        text: cap[0]
-	      });
-	      continue;
-	    }
-
-	    // def
-	    if ((!bq && top) && (cap = this.rules.def.exec(src))) {
-	      src = src.substring(cap[0].length);
-	      this.tokens.links[cap[1].toLowerCase()] = {
-	        href: cap[2],
-	        title: cap[3]
-	      };
-	      continue;
-	    }
-
-	    // table (gfm)
-	    if (top && (cap = this.rules.table.exec(src))) {
-	      src = src.substring(cap[0].length);
-
-	      item = {
-	        type: 'table',
-	        header: cap[1].replace(/^ *| *\| *$/g, '').split(/ *\| */),
-	        align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
-	        cells: cap[3].replace(/(?: *\| *)?\n$/, '').split('\n')
-	      };
-
-	      for (i = 0; i < item.align.length; i++) {
-	        if (/^ *-+: *$/.test(item.align[i])) {
-	          item.align[i] = 'right';
-	        } else if (/^ *:-+: *$/.test(item.align[i])) {
-	          item.align[i] = 'center';
-	        } else if (/^ *:-+ *$/.test(item.align[i])) {
-	          item.align[i] = 'left';
-	        } else {
-	          item.align[i] = null;
-	        }
-	      }
-
-	      for (i = 0; i < item.cells.length; i++) {
-	        item.cells[i] = item.cells[i]
-	          .replace(/^ *\| *| *\| *$/g, '')
-	          .split(/ *\| */);
-	      }
-
-	      this.tokens.push(item);
-
-	      continue;
-	    }
-
-	    // top-level paragraph
-	    if (top && (cap = this.rules.paragraph.exec(src))) {
-	      src = src.substring(cap[0].length);
-	      this.tokens.push({
-	        type: 'paragraph',
-	        text: cap[1].charAt(cap[1].length - 1) === '\n'
-	          ? cap[1].slice(0, -1)
-	          : cap[1]
-	      });
-	      continue;
-	    }
-
-	    // text
-	    if (cap = this.rules.text.exec(src)) {
-	      // Top-level should never reach here.
-	      src = src.substring(cap[0].length);
-	      this.tokens.push({
-	        type: 'text',
-	        text: cap[0]
-	      });
-	      continue;
-	    }
-
-	    if (src) {
-	      throw new
-	        Error('Infinite loop on byte: ' + src.charCodeAt(0));
-	    }
-	  }
-
-	  return this.tokens;
-	};
-
-	/**
-	 * Inline-Level Grammar
-	 */
-
-	var inline = {
-	  escape: /^\\([\\`*{}\[\]()#+\-.!_>])/,
-	  autolink: /^<([^ >]+(@|:\/)[^ >]+)>/,
-	  url: noop,
-	  tag: /^<!--[\s\S]*?-->|^<\/?\w+(?:"[^"]*"|'[^']*'|[^'">])*?>/,
-	  link: /^!?\[(inside)\]\(href\)/,
-	  reflink: /^!?\[(inside)\]\s*\[([^\]]*)\]/,
-	  nolink: /^!?\[((?:\[[^\]]*\]|[^\[\]])*)\]/,
-	  strong: /^__([\s\S]+?)__(?!_)|^\*\*([\s\S]+?)\*\*(?!\*)/,
-	  em: /^\b_((?:[^_]|__)+?)_\b|^\*((?:\*\*|[\s\S])+?)\*(?!\*)/,
-	  code: /^(`+)\s*([\s\S]*?[^`])\s*\1(?!`)/,
-	  br: /^ {2,}\n(?!\s*$)/,
-	  del: noop,
-	  text: /^[\s\S]+?(?=[\\<!\[_*`]| {2,}\n|$)/
-	};
-
-	inline._inside = /(?:\[[^\]]*\]|[^\[\]]|\](?=[^\[]*\]))*/;
-	inline._href = /\s*<?([\s\S]*?)>?(?:\s+['"]([\s\S]*?)['"])?\s*/;
-
-	inline.link = replace(inline.link)
-	  ('inside', inline._inside)
-	  ('href', inline._href)
-	  ();
-
-	inline.reflink = replace(inline.reflink)
-	  ('inside', inline._inside)
-	  ();
-
-	/**
-	 * Normal Inline Grammar
-	 */
-
-	inline.normal = merge({}, inline);
-
-	/**
-	 * Pedantic Inline Grammar
-	 */
-
-	inline.pedantic = merge({}, inline.normal, {
-	  strong: /^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,
-	  em: /^_(?=\S)([\s\S]*?\S)_(?!_)|^\*(?=\S)([\s\S]*?\S)\*(?!\*)/
-	});
-
-	/**
-	 * GFM Inline Grammar
-	 */
-
-	inline.gfm = merge({}, inline.normal, {
-	  escape: replace(inline.escape)('])', '~|])')(),
-	  url: /^(https?:\/\/[^\s<]+[^<.,:;"')\]\s])/,
-	  del: /^~~(?=\S)([\s\S]*?\S)~~/,
-	  text: replace(inline.text)
-	    (']|', '~]|')
-	    ('|', '|https?://|')
-	    ()
-	});
-
-	/**
-	 * GFM + Line Breaks Inline Grammar
-	 */
-
-	inline.breaks = merge({}, inline.gfm, {
-	  br: replace(inline.br)('{2,}', '*')(),
-	  text: replace(inline.gfm.text)('{2,}', '*')()
-	});
-
-	/**
-	 * Inline Lexer & Compiler
-	 */
-
-	function InlineLexer(links, options) {
-	  this.options = options || marked.defaults;
-	  this.links = links;
-	  this.rules = inline.normal;
-	  this.renderer = this.options.renderer || new Renderer;
-	  this.renderer.options = this.options;
-
-	  if (!this.links) {
-	    throw new
-	      Error('Tokens array requires a `links` property.');
-	  }
-
-	  if (this.options.gfm) {
-	    if (this.options.breaks) {
-	      this.rules = inline.breaks;
-	    } else {
-	      this.rules = inline.gfm;
-	    }
-	  } else if (this.options.pedantic) {
-	    this.rules = inline.pedantic;
-	  }
-	}
-
-	/**
-	 * Expose Inline Rules
-	 */
-
-	InlineLexer.rules = inline;
-
-	/**
-	 * Static Lexing/Compiling Method
-	 */
-
-	InlineLexer.output = function(src, links, options) {
-	  var inline = new InlineLexer(links, options);
-	  return inline.output(src);
-	};
-
-	/**
-	 * Lexing/Compiling
-	 */
-
-	InlineLexer.prototype.output = function(src) {
-	  var out = ''
-	    , link
-	    , text
-	    , href
-	    , cap;
-
-	  while (src) {
-	    // escape
-	    if (cap = this.rules.escape.exec(src)) {
-	      src = src.substring(cap[0].length);
-	      out += cap[1];
-	      continue;
-	    }
-
-	    // autolink
-	    if (cap = this.rules.autolink.exec(src)) {
-	      src = src.substring(cap[0].length);
-	      if (cap[2] === '@') {
-	        text = cap[1].charAt(6) === ':'
-	          ? this.mangle(cap[1].substring(7))
-	          : this.mangle(cap[1]);
-	        href = this.mangle('mailto:') + text;
-	      } else {
-	        text = escape(cap[1]);
-	        href = text;
-	      }
-	      out += this.renderer.link(href, null, text);
-	      continue;
-	    }
-
-	    // url (gfm)
-	    if (!this.inLink && (cap = this.rules.url.exec(src))) {
-	      src = src.substring(cap[0].length);
-	      text = escape(cap[1]);
-	      href = text;
-	      out += this.renderer.link(href, null, text);
-	      continue;
-	    }
-
-	    // tag
-	    if (cap = this.rules.tag.exec(src)) {
-	      if (!this.inLink && /^<a /i.test(cap[0])) {
-	        this.inLink = true;
-	      } else if (this.inLink && /^<\/a>/i.test(cap[0])) {
-	        this.inLink = false;
-	      }
-	      src = src.substring(cap[0].length);
-	      out += this.options.sanitize
-	        ? this.options.sanitizer
-	          ? this.options.sanitizer(cap[0])
-	          : escape(cap[0])
-	        : cap[0]
-	      continue;
-	    }
-
-	    // link
-	    if (cap = this.rules.link.exec(src)) {
-	      src = src.substring(cap[0].length);
-	      this.inLink = true;
-	      out += this.outputLink(cap, {
-	        href: cap[2],
-	        title: cap[3]
-	      });
-	      this.inLink = false;
-	      continue;
-	    }
-
-	    // reflink, nolink
-	    if ((cap = this.rules.reflink.exec(src))
-	        || (cap = this.rules.nolink.exec(src))) {
-	      src = src.substring(cap[0].length);
-	      link = (cap[2] || cap[1]).replace(/\s+/g, ' ');
-	      link = this.links[link.toLowerCase()];
-	      if (!link || !link.href) {
-	        out += cap[0].charAt(0);
-	        src = cap[0].substring(1) + src;
-	        continue;
-	      }
-	      this.inLink = true;
-	      out += this.outputLink(cap, link);
-	      this.inLink = false;
-	      continue;
-	    }
-
-	    // strong
-	    if (cap = this.rules.strong.exec(src)) {
-	      src = src.substring(cap[0].length);
-	      out += this.renderer.strong(this.output(cap[2] || cap[1]));
-	      continue;
-	    }
-
-	    // em
-	    if (cap = this.rules.em.exec(src)) {
-	      src = src.substring(cap[0].length);
-	      out += this.renderer.em(this.output(cap[2] || cap[1]));
-	      continue;
-	    }
-
-	    // code
-	    if (cap = this.rules.code.exec(src)) {
-	      src = src.substring(cap[0].length);
-	      out += this.renderer.codespan(escape(cap[2], true));
-	      continue;
-	    }
-
-	    // br
-	    if (cap = this.rules.br.exec(src)) {
-	      src = src.substring(cap[0].length);
-	      out += this.renderer.br();
-	      continue;
-	    }
-
-	    // del (gfm)
-	    if (cap = this.rules.del.exec(src)) {
-	      src = src.substring(cap[0].length);
-	      out += this.renderer.del(this.output(cap[1]));
-	      continue;
-	    }
-
-	    // text
-	    if (cap = this.rules.text.exec(src)) {
-	      src = src.substring(cap[0].length);
-	      out += this.renderer.text(escape(this.smartypants(cap[0])));
-	      continue;
-	    }
-
-	    if (src) {
-	      throw new
-	        Error('Infinite loop on byte: ' + src.charCodeAt(0));
-	    }
-	  }
-
-	  return out;
-	};
-
-	/**
-	 * Compile Link
-	 */
-
-	InlineLexer.prototype.outputLink = function(cap, link) {
-	  var href = escape(link.href)
-	    , title = link.title ? escape(link.title) : null;
-
-	  return cap[0].charAt(0) !== '!'
-	    ? this.renderer.link(href, title, this.output(cap[1]))
-	    : this.renderer.image(href, title, escape(cap[1]));
-	};
-
-	/**
-	 * Smartypants Transformations
-	 */
-
-	InlineLexer.prototype.smartypants = function(text) {
-	  if (!this.options.smartypants) return text;
-	  return text
-	    // em-dashes
-	    .replace(/---/g, '\u2014')
-	    // en-dashes
-	    .replace(/--/g, '\u2013')
-	    // opening singles
-	    .replace(/(^|[-\u2014/(\[{"\s])'/g, '$1\u2018')
-	    // closing singles & apostrophes
-	    .replace(/'/g, '\u2019')
-	    // opening doubles
-	    .replace(/(^|[-\u2014/(\[{\u2018\s])"/g, '$1\u201c')
-	    // closing doubles
-	    .replace(/"/g, '\u201d')
-	    // ellipses
-	    .replace(/\.{3}/g, '\u2026');
-	};
-
-	/**
-	 * Mangle Links
-	 */
-
-	InlineLexer.prototype.mangle = function(text) {
-	  if (!this.options.mangle) return text;
-	  var out = ''
-	    , l = text.length
-	    , i = 0
-	    , ch;
-
-	  for (; i < l; i++) {
-	    ch = text.charCodeAt(i);
-	    if (Math.random() > 0.5) {
-	      ch = 'x' + ch.toString(16);
-	    }
-	    out += '&#' + ch + ';';
-	  }
-
-	  return out;
-	};
-
-	/**
-	 * Renderer
-	 */
-
-	function Renderer(options) {
-	  this.options = options || {};
-	}
-
-	Renderer.prototype.code = function(code, lang, escaped) {
-	  if (this.options.highlight) {
-	    var out = this.options.highlight(code, lang);
-	    if (out != null && out !== code) {
-	      escaped = true;
-	      code = out;
-	    }
-	  }
-
-	  if (!lang) {
-	    return '<pre><code>'
-	      + (escaped ? code : escape(code, true))
-	      + '\n</code></pre>';
-	  }
-
-	  return '<pre><code class="'
-	    + this.options.langPrefix
-	    + escape(lang, true)
-	    + '">'
-	    + (escaped ? code : escape(code, true))
-	    + '\n</code></pre>\n';
-	};
-
-	Renderer.prototype.blockquote = function(quote) {
-	  return '<blockquote>\n' + quote + '</blockquote>\n';
-	};
-
-	Renderer.prototype.html = function(html) {
-	  return html;
-	};
-
-	Renderer.prototype.heading = function(text, level, raw) {
-	  return '<h'
-	    + level
-	    + ' id="'
-	    + this.options.headerPrefix
-	    + raw.toLowerCase().replace(/[^\w]+/g, '-')
-	    + '">'
-	    + text
-	    + '</h'
-	    + level
-	    + '>\n';
-	};
-
-	Renderer.prototype.hr = function() {
-	  return this.options.xhtml ? '<hr/>\n' : '<hr>\n';
-	};
-
-	Renderer.prototype.list = function(body, ordered) {
-	  var type = ordered ? 'ol' : 'ul';
-	  return '<' + type + '>\n' + body + '</' + type + '>\n';
-	};
-
-	Renderer.prototype.listitem = function(text) {
-	  return '<li>' + text + '</li>\n';
-	};
-
-	Renderer.prototype.paragraph = function(text) {
-	  return '<p>' + text + '</p>\n';
-	};
-
-	Renderer.prototype.table = function(header, body) {
-	  return '<table>\n'
-	    + '<thead>\n'
-	    + header
-	    + '</thead>\n'
-	    + '<tbody>\n'
-	    + body
-	    + '</tbody>\n'
-	    + '</table>\n';
-	};
-
-	Renderer.prototype.tablerow = function(content) {
-	  return '<tr>\n' + content + '</tr>\n';
-	};
-
-	Renderer.prototype.tablecell = function(content, flags) {
-	  var type = flags.header ? 'th' : 'td';
-	  var tag = flags.align
-	    ? '<' + type + ' style="text-align:' + flags.align + '">'
-	    : '<' + type + '>';
-	  return tag + content + '</' + type + '>\n';
-	};
-
-	// span level renderer
-	Renderer.prototype.strong = function(text) {
-	  return '<strong>' + text + '</strong>';
-	};
-
-	Renderer.prototype.em = function(text) {
-	  return '<em>' + text + '</em>';
-	};
-
-	Renderer.prototype.codespan = function(text) {
-	  return '<code>' + text + '</code>';
-	};
-
-	Renderer.prototype.br = function() {
-	  return this.options.xhtml ? '<br/>' : '<br>';
-	};
-
-	Renderer.prototype.del = function(text) {
-	  return '<del>' + text + '</del>';
-	};
-
-	Renderer.prototype.link = function(href, title, text) {
-	  if (this.options.sanitize) {
-	    try {
-	      var prot = decodeURIComponent(unescape(href))
-	        .replace(/[^\w:]/g, '')
-	        .toLowerCase();
-	    } catch (e) {
-	      return '';
-	    }
-	    if (prot.indexOf('javascript:') === 0 || prot.indexOf('vbscript:') === 0) {
-	      return '';
-	    }
-	  }
-	  var out = '<a href="' + href + '"';
-	  if (title) {
-	    out += ' title="' + title + '"';
-	  }
-	  out += '>' + text + '</a>';
-	  return out;
-	};
-
-	Renderer.prototype.image = function(href, title, text) {
-	  var out = '<img src="' + href + '" alt="' + text + '"';
-	  if (title) {
-	    out += ' title="' + title + '"';
-	  }
-	  out += this.options.xhtml ? '/>' : '>';
-	  return out;
-	};
-
-	Renderer.prototype.text = function(text) {
-	  return text;
-	};
-
-	/**
-	 * Parsing & Compiling
-	 */
-
-	function Parser(options) {
-	  this.tokens = [];
-	  this.token = null;
-	  this.options = options || marked.defaults;
-	  this.options.renderer = this.options.renderer || new Renderer;
-	  this.renderer = this.options.renderer;
-	  this.renderer.options = this.options;
-	}
-
-	/**
-	 * Static Parse Method
-	 */
-
-	Parser.parse = function(src, options, renderer) {
-	  var parser = new Parser(options, renderer);
-	  return parser.parse(src);
-	};
-
-	/**
-	 * Parse Loop
-	 */
-
-	Parser.prototype.parse = function(src) {
-	  this.inline = new InlineLexer(src.links, this.options, this.renderer);
-	  this.tokens = src.reverse();
-
-	  var out = '';
-	  while (this.next()) {
-	    out += this.tok();
-	  }
-
-	  return out;
-	};
-
-	/**
-	 * Next Token
-	 */
-
-	Parser.prototype.next = function() {
-	  return this.token = this.tokens.pop();
-	};
-
-	/**
-	 * Preview Next Token
-	 */
-
-	Parser.prototype.peek = function() {
-	  return this.tokens[this.tokens.length - 1] || 0;
-	};
-
-	/**
-	 * Parse Text Tokens
-	 */
-
-	Parser.prototype.parseText = function() {
-	  var body = this.token.text;
-
-	  while (this.peek().type === 'text') {
-	    body += '\n' + this.next().text;
-	  }
-
-	  return this.inline.output(body);
-	};
-
-	/**
-	 * Parse Current Token
-	 */
-
-	Parser.prototype.tok = function() {
-	  switch (this.token.type) {
-	    case 'space': {
-	      return '';
-	    }
-	    case 'hr': {
-	      return this.renderer.hr();
-	    }
-	    case 'heading': {
-	      return this.renderer.heading(
-	        this.inline.output(this.token.text),
-	        this.token.depth,
-	        this.token.text);
-	    }
-	    case 'code': {
-	      return this.renderer.code(this.token.text,
-	        this.token.lang,
-	        this.token.escaped);
-	    }
-	    case 'table': {
-	      var header = ''
-	        , body = ''
-	        , i
-	        , row
-	        , cell
-	        , flags
-	        , j;
-
-	      // header
-	      cell = '';
-	      for (i = 0; i < this.token.header.length; i++) {
-	        flags = { header: true, align: this.token.align[i] };
-	        cell += this.renderer.tablecell(
-	          this.inline.output(this.token.header[i]),
-	          { header: true, align: this.token.align[i] }
-	        );
-	      }
-	      header += this.renderer.tablerow(cell);
-
-	      for (i = 0; i < this.token.cells.length; i++) {
-	        row = this.token.cells[i];
-
-	        cell = '';
-	        for (j = 0; j < row.length; j++) {
-	          cell += this.renderer.tablecell(
-	            this.inline.output(row[j]),
-	            { header: false, align: this.token.align[j] }
-	          );
-	        }
-
-	        body += this.renderer.tablerow(cell);
-	      }
-	      return this.renderer.table(header, body);
-	    }
-	    case 'blockquote_start': {
-	      var body = '';
-
-	      while (this.next().type !== 'blockquote_end') {
-	        body += this.tok();
-	      }
-
-	      return this.renderer.blockquote(body);
-	    }
-	    case 'list_start': {
-	      var body = ''
-	        , ordered = this.token.ordered;
-
-	      while (this.next().type !== 'list_end') {
-	        body += this.tok();
-	      }
-
-	      return this.renderer.list(body, ordered);
-	    }
-	    case 'list_item_start': {
-	      var body = '';
-
-	      while (this.next().type !== 'list_item_end') {
-	        body += this.token.type === 'text'
-	          ? this.parseText()
-	          : this.tok();
-	      }
-
-	      return this.renderer.listitem(body);
-	    }
-	    case 'loose_item_start': {
-	      var body = '';
-
-	      while (this.next().type !== 'list_item_end') {
-	        body += this.tok();
-	      }
-
-	      return this.renderer.listitem(body);
-	    }
-	    case 'html': {
-	      var html = !this.token.pre && !this.options.pedantic
-	        ? this.inline.output(this.token.text)
-	        : this.token.text;
-	      return this.renderer.html(html);
-	    }
-	    case 'paragraph': {
-	      return this.renderer.paragraph(this.inline.output(this.token.text));
-	    }
-	    case 'text': {
-	      return this.renderer.paragraph(this.parseText());
-	    }
-	  }
-	};
-
-	/**
-	 * Helpers
-	 */
-
-	function escape(html, encode) {
-	  return html
-	    .replace(!encode ? /&(?!#?\w+;)/g : /&/g, '&amp;')
-	    .replace(/</g, '&lt;')
-	    .replace(/>/g, '&gt;')
-	    .replace(/"/g, '&quot;')
-	    .replace(/'/g, '&#39;');
-	}
-
-	function unescape(html) {
-		// explicitly match decimal, hex, and named HTML entities 
-	  return html.replace(/&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/g, function(_, n) {
-	    n = n.toLowerCase();
-	    if (n === 'colon') return ':';
-	    if (n.charAt(0) === '#') {
-	      return n.charAt(1) === 'x'
-	        ? String.fromCharCode(parseInt(n.substring(2), 16))
-	        : String.fromCharCode(+n.substring(1));
-	    }
-	    return '';
-	  });
-	}
-
-	function replace(regex, opt) {
-	  regex = regex.source;
-	  opt = opt || '';
-	  return function self(name, val) {
-	    if (!name) return new RegExp(regex, opt);
-	    val = val.source || val;
-	    val = val.replace(/(^|[^\[])\^/g, '$1');
-	    regex = regex.replace(name, val);
-	    return self;
-	  };
-	}
-
-	function noop() {}
-	noop.exec = noop;
-
-	function merge(obj) {
-	  var i = 1
-	    , target
-	    , key;
-
-	  for (; i < arguments.length; i++) {
-	    target = arguments[i];
-	    for (key in target) {
-	      if (Object.prototype.hasOwnProperty.call(target, key)) {
-	        obj[key] = target[key];
-	      }
-	    }
-	  }
-
-	  return obj;
-	}
-
-
-	/**
-	 * Marked
-	 */
-
-	function marked(src, opt, callback) {
-	  if (callback || typeof opt === 'function') {
-	    if (!callback) {
-	      callback = opt;
-	      opt = null;
-	    }
-
-	    opt = merge({}, marked.defaults, opt || {});
-
-	    var highlight = opt.highlight
-	      , tokens
-	      , pending
-	      , i = 0;
-
-	    try {
-	      tokens = Lexer.lex(src, opt)
-	    } catch (e) {
-	      return callback(e);
-	    }
-
-	    pending = tokens.length;
-
-	    var done = function(err) {
-	      if (err) {
-	        opt.highlight = highlight;
-	        return callback(err);
-	      }
-
-	      var out;
-
-	      try {
-	        out = Parser.parse(tokens, opt);
-	      } catch (e) {
-	        err = e;
-	      }
-
-	      opt.highlight = highlight;
-
-	      return err
-	        ? callback(err)
-	        : callback(null, out);
-	    };
-
-	    if (!highlight || highlight.length < 3) {
-	      return done();
-	    }
-
-	    delete opt.highlight;
-
-	    if (!pending) return done();
-
-	    for (; i < tokens.length; i++) {
-	      (function(token) {
-	        if (token.type !== 'code') {
-	          return --pending || done();
-	        }
-	        return highlight(token.text, token.lang, function(err, code) {
-	          if (err) return done(err);
-	          if (code == null || code === token.text) {
-	            return --pending || done();
-	          }
-	          token.text = code;
-	          token.escaped = true;
-	          --pending || done();
-	        });
-	      })(tokens[i]);
-	    }
-
-	    return;
-	  }
-	  try {
-	    if (opt) opt = merge({}, marked.defaults, opt);
-	    return Parser.parse(Lexer.lex(src, opt), opt);
-	  } catch (e) {
-	    e.message += '\nPlease report this to https://github.com/chjj/marked.';
-	    if ((opt || marked.defaults).silent) {
-	      return '<p>An error occured:</p><pre>'
-	        + escape(e.message + '', true)
-	        + '</pre>';
-	    }
-	    throw e;
-	  }
-	}
-
-	/**
-	 * Options
-	 */
-
-	marked.options =
-	marked.setOptions = function(opt) {
-	  merge(marked.defaults, opt);
-	  return marked;
-	};
-
-	marked.defaults = {
-	  gfm: true,
-	  tables: true,
-	  breaks: false,
-	  pedantic: false,
-	  sanitize: false,
-	  sanitizer: null,
-	  mangle: true,
-	  smartLists: false,
-	  silent: false,
-	  highlight: null,
-	  langPrefix: 'lang-',
-	  smartypants: false,
-	  headerPrefix: '',
-	  renderer: new Renderer,
-	  xhtml: false
-	};
-
-	/**
-	 * Expose
-	 */
-
-	marked.Parser = Parser;
-	marked.parser = Parser.parse;
-
-	marked.Renderer = Renderer;
-
-	marked.Lexer = Lexer;
-	marked.lexer = Lexer.lex;
-
-	marked.InlineLexer = InlineLexer;
-	marked.inlineLexer = InlineLexer.output;
-
-	marked.parse = marked;
-
-	if (true) {
-	  module.exports = marked;
-	} else if (typeof define === 'function' && define.amd) {
-	  define(function() { return marked; });
-	} else {
-	  this.marked = marked;
-	}
-
-	}).call(function() {
-	  return this || (typeof window !== 'undefined' ? window : global);
-	}());
-
-	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
-
-/***/ },
-/* 267 */
-/***/ function(module, exports, __webpack_require__) {
-
-	// CodeMirror, copyright (c) by Marijn Haverbeke and others
-	// Distributed under an MIT license: http://codemirror.net/LICENSE
-
-	// This is CodeMirror (http://codemirror.net), a code editor
-	// implemented in JavaScript on top of the browser's DOM.
-	//
-	// You can find some technical background for some of the code below
-	// at http://marijnhaverbeke.nl/blog/#cm-internals .
-
-	(function (global, factory) {
-	   true ? module.exports = factory() :
-	  typeof define === 'function' && define.amd ? define(factory) :
-	  (global.CodeMirror = factory());
-	}(this, (function () { 'use strict';
-
-	// Kludges for bugs and behavior differences that can't be feature
-	// detected are enabled based on userAgent etc sniffing.
-	var userAgent = navigator.userAgent
-	var platform = navigator.platform
-
-	var gecko = /gecko\/\d/i.test(userAgent)
-	var ie_upto10 = /MSIE \d/.test(userAgent)
-	var ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(userAgent)
-	var ie = ie_upto10 || ie_11up
-	var ie_version = ie && (ie_upto10 ? document.documentMode || 6 : ie_11up[1])
-	var webkit = /WebKit\//.test(userAgent)
-	var qtwebkit = webkit && /Qt\/\d+\.\d+/.test(userAgent)
-	var chrome = /Chrome\//.test(userAgent)
-	var presto = /Opera\//.test(userAgent)
-	var safari = /Apple Computer/.test(navigator.vendor)
-	var mac_geMountainLion = /Mac OS X 1\d\D([8-9]|\d\d)\D/.test(userAgent)
-	var phantom = /PhantomJS/.test(userAgent)
-
-	var ios = /AppleWebKit/.test(userAgent) && /Mobile\/\w+/.test(userAgent)
-	// This is woefully incomplete. Suggestions for alternative methods welcome.
-	var mobile = ios || /Android|webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(userAgent)
-	var mac = ios || /Mac/.test(platform)
-	var chromeOS = /\bCrOS\b/.test(userAgent)
-	var windows = /win/i.test(platform)
-
-	var presto_version = presto && userAgent.match(/Version\/(\d*\.\d*)/)
-	if (presto_version) { presto_version = Number(presto_version[1]) }
-	if (presto_version && presto_version >= 15) { presto = false; webkit = true }
-	// Some browsers use the wrong event properties to signal cmd/ctrl on OS X
-	var flipCtrlCmd = mac && (qtwebkit || presto && (presto_version == null || presto_version < 12.11))
-	var captureRightClick = gecko || (ie && ie_version >= 9)
-
-	function classTest(cls) { return new RegExp("(^|\\s)" + cls + "(?:$|\\s)\\s*") }
-
-	var rmClass = function(node, cls) {
-	  var current = node.className
-	  var match = classTest(cls).exec(current)
-	  if (match) {
-	    var after = current.slice(match.index + match[0].length)
-	    node.className = current.slice(0, match.index) + (after ? match[1] + after : "")
-	  }
-	}
-
-	function removeChildren(e) {
-	  for (var count = e.childNodes.length; count > 0; --count)
-	    { e.removeChild(e.firstChild) }
-	  return e
-	}
-
-	function removeChildrenAndAdd(parent, e) {
-	  return removeChildren(parent).appendChild(e)
-	}
-
-	function elt(tag, content, className, style) {
-	  var e = document.createElement(tag)
-	  if (className) { e.className = className }
-	  if (style) { e.style.cssText = style }
-	  if (typeof content == "string") { e.appendChild(document.createTextNode(content)) }
-	  else if (content) { for (var i = 0; i < content.length; ++i) { e.appendChild(content[i]) } }
-	  return e
-	}
-
-	var range
-	if (document.createRange) { range = function(node, start, end, endNode) {
-	  var r = document.createRange()
-	  r.setEnd(endNode || node, end)
-	  r.setStart(node, start)
-	  return r
-	} }
-	else { range = function(node, start, end) {
-	  var r = document.body.createTextRange()
-	  try { r.moveToElementText(node.parentNode) }
-	  catch(e) { return r }
-	  r.collapse(true)
-	  r.moveEnd("character", end)
-	  r.moveStart("character", start)
-	  return r
-	} }
-
-	function contains(parent, child) {
-	  if (child.nodeType == 3) // Android browser always returns false when child is a textnode
-	    { child = child.parentNode }
-	  if (parent.contains)
-	    { return parent.contains(child) }
-	  do {
-	    if (child.nodeType == 11) { child = child.host }
-	    if (child == parent) { return true }
-	  } while (child = child.parentNode)
-	}
-
-	function activeElt() {
-	  // IE and Edge may throw an "Unspecified Error" when accessing document.activeElement.
-	  // IE < 10 will throw when accessed while the page is loading or in an iframe.
-	  // IE > 9 and Edge will throw when accessed in an iframe if document.body is unavailable.
-	  var activeElement
-	  try {
-	    activeElement = document.activeElement
-	  } catch(e) {
-	    activeElement = document.body || null
-	  }
-	  while (activeElement && activeElement.root && activeElement.root.activeElement)
-	    { activeElement = activeElement.root.activeElement }
-	  return activeElement
-	}
-
-	function addClass(node, cls) {
-	  var current = node.className
-	  if (!classTest(cls).test(current)) { node.className += (current ? " " : "") + cls }
-	}
-	function joinClasses(a, b) {
-	  var as = a.split(" ")
-	  for (var i = 0; i < as.length; i++)
-	    { if (as[i] && !classTest(as[i]).test(b)) { b += " " + as[i] } }
-	  return b
-	}
-
-	var selectInput = function(node) { node.select() }
-	if (ios) // Mobile Safari apparently has a bug where select() is broken.
-	  { selectInput = function(node) { node.selectionStart = 0; node.selectionEnd = node.value.length } }
-	else if (ie) // Suppress mysterious IE10 errors
-	  { selectInput = function(node) { try { node.select() } catch(_e) {} } }
-
-	function bind(f) {
-	  var args = Array.prototype.slice.call(arguments, 1)
-	  return function(){return f.apply(null, args)}
-	}
-
-	function copyObj(obj, target, overwrite) {
-	  if (!target) { target = {} }
-	  for (var prop in obj)
-	    { if (obj.hasOwnProperty(prop) && (overwrite !== false || !target.hasOwnProperty(prop)))
-	      { target[prop] = obj[prop] } }
-	  return target
-	}
-
-	// Counts the column offset in a string, taking tabs into account.
-	// Used mostly to find indentation.
-	function countColumn(string, end, tabSize, startIndex, startValue) {
-	  if (end == null) {
-	    end = string.search(/[^\s\u00a0]/)
-	    if (end == -1) { end = string.length }
-	  }
-	  for (var i = startIndex || 0, n = startValue || 0;;) {
-	    var nextTab = string.indexOf("\t", i)
-	    if (nextTab < 0 || nextTab >= end)
-	      { return n + (end - i) }
-	    n += nextTab - i
-	    n += tabSize - (n % tabSize)
-	    i = nextTab + 1
-	  }
-	}
-
-	function Delayed() {this.id = null}
-	Delayed.prototype.set = function(ms, f) {
-	  clearTimeout(this.id)
-	  this.id = setTimeout(f, ms)
-	}
-
-	function indexOf(array, elt) {
-	  for (var i = 0; i < array.length; ++i)
-	    { if (array[i] == elt) { return i } }
-	  return -1
-	}
-
-	// Number of pixels added to scroller and sizer to hide scrollbar
-	var scrollerGap = 30
-
-	// Returned or thrown by various protocols to signal 'I'm not
-	// handling this'.
-	var Pass = {toString: function(){return "CodeMirror.Pass"}}
-
-	// Reused option objects for setSelection & friends
-	var sel_dontScroll = {scroll: false};
-	var sel_mouse = {origin: "*mouse"};
-	var sel_move = {origin: "+move"};
-	// The inverse of countColumn -- find the offset that corresponds to
-	// a particular column.
-	function findColumn(string, goal, tabSize) {
-	  for (var pos = 0, col = 0;;) {
-	    var nextTab = string.indexOf("\t", pos)
-	    if (nextTab == -1) { nextTab = string.length }
-	    var skipped = nextTab - pos
-	    if (nextTab == string.length || col + skipped >= goal)
-	      { return pos + Math.min(skipped, goal - col) }
-	    col += nextTab - pos
-	    col += tabSize - (col % tabSize)
-	    pos = nextTab + 1
-	    if (col >= goal) { return pos }
-	  }
-	}
-
-	var spaceStrs = [""]
-	function spaceStr(n) {
-	  while (spaceStrs.length <= n)
-	    { spaceStrs.push(lst(spaceStrs) + " ") }
-	  return spaceStrs[n]
-	}
-
-	function lst(arr) { return arr[arr.length-1] }
-
-	function map(array, f) {
-	  var out = []
-	  for (var i = 0; i < array.length; i++) { out[i] = f(array[i], i) }
-	  return out
-	}
-
-	function insertSorted(array, value, score) {
-	  var pos = 0, priority = score(value)
-	  while (pos < array.length && score(array[pos]) <= priority) { pos++ }
-	  array.splice(pos, 0, value)
-	}
-
-	function nothing() {}
-
-	function createObj(base, props) {
-	  var inst
-	  if (Object.create) {
-	    inst = Object.create(base)
-	  } else {
-	    nothing.prototype = base
-	    inst = new nothing()
-	  }
-	  if (props) { copyObj(props, inst) }
-	  return inst
-	}
-
-	var nonASCIISingleCaseWordChar = /[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/
-	function isWordCharBasic(ch) {
-	  return /\w/.test(ch) || ch > "\x80" &&
-	    (ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch))
-	}
-	function isWordChar(ch, helper) {
-	  if (!helper) { return isWordCharBasic(ch) }
-	  if (helper.source.indexOf("\\w") > -1 && isWordCharBasic(ch)) { return true }
-	  return helper.test(ch)
-	}
-
-	function isEmpty(obj) {
-	  for (var n in obj) { if (obj.hasOwnProperty(n) && obj[n]) { return false } }
-	  return true
-	}
-
-	// Extending unicode characters. A series of a non-extending char +
-	// any number of extending chars is treated as a single unit as far
-	// as editing and measuring is concerned. This is not fully correct,
-	// since some scripts/fonts/browsers also treat other configurations
-	// of code points as a group.
-	var extendingChars = /[\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u065e\u0670\u06d6-\u06dc\u06de-\u06e4\u06e7\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0900-\u0902\u093c\u0941-\u0948\u094d\u0951-\u0955\u0962\u0963\u0981\u09bc\u09be\u09c1-\u09c4\u09cd\u09d7\u09e2\u09e3\u0a01\u0a02\u0a3c\u0a41\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a70\u0a71\u0a75\u0a81\u0a82\u0abc\u0ac1-\u0ac5\u0ac7\u0ac8\u0acd\u0ae2\u0ae3\u0b01\u0b3c\u0b3e\u0b3f\u0b41-\u0b44\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b82\u0bbe\u0bc0\u0bcd\u0bd7\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0cbc\u0cbf\u0cc2\u0cc6\u0ccc\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0d3e\u0d41-\u0d44\u0d4d\u0d57\u0d62\u0d63\u0dca\u0dcf\u0dd2-\u0dd4\u0dd6\u0ddf\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0f18\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86\u0f87\u0f90-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039\u103a\u103d\u103e\u1058\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085\u1086\u108d\u109d\u135f\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd\u180b-\u180d\u18a9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193b\u1a17\u1a18\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1b00-\u1b03\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80\u1b81\u1ba2-\u1ba5\u1ba8\u1ba9\u1c2c-\u1c33\u1c36\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1dc0-\u1de6\u1dfd-\u1dff\u200c\u200d\u20d0-\u20f0\u2cef-\u2cf1\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua66f-\ua672\ua67c\ua67d\ua6f0\ua6f1\ua802\ua806\ua80b\ua825\ua826\ua8c4\ua8e0-\ua8f1\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc\uaa29-\uaa2e\uaa31\uaa32\uaa35\uaa36\uaa43\uaa4c\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uabe5\uabe8\uabed\udc00-\udfff\ufb1e\ufe00-\ufe0f\ufe20-\ufe26\uff9e\uff9f]/
-	function isExtendingChar(ch) { return ch.charCodeAt(0) >= 768 && extendingChars.test(ch) }
-
-	// The display handles the DOM integration, both for input reading
-	// and content drawing. It holds references to DOM nodes and
-	// display-related state.
-
-	function Display(place, doc, input) {
-	  var d = this
-	  this.input = input
-
-	  // Covers bottom-right square when both scrollbars are present.
-	  d.scrollbarFiller = elt("div", null, "CodeMirror-scrollbar-filler")
-	  d.scrollbarFiller.setAttribute("cm-not-content", "true")
-	  // Covers bottom of gutter when coverGutterNextToScrollbar is on
-	  // and h scrollbar is present.
-	  d.gutterFiller = elt("div", null, "CodeMirror-gutter-filler")
-	  d.gutterFiller.setAttribute("cm-not-content", "true")
-	  // Will contain the actual code, positioned to cover the viewport.
-	  d.lineDiv = elt("div", null, "CodeMirror-code")
-	  // Elements are added to these to represent selection and cursors.
-	  d.selectionDiv = elt("div", null, null, "position: relative; z-index: 1")
-	  d.cursorDiv = elt("div", null, "CodeMirror-cursors")
-	  // A visibility: hidden element used to find the size of things.
-	  d.measure = elt("div", null, "CodeMirror-measure")
-	  // When lines outside of the viewport are measured, they are drawn in this.
-	  d.lineMeasure = elt("div", null, "CodeMirror-measure")
-	  // Wraps everything that needs to exist inside the vertically-padded coordinate system
-	  d.lineSpace = elt("div", [d.measure, d.lineMeasure, d.selectionDiv, d.cursorDiv, d.lineDiv],
-	                    null, "position: relative; outline: none")
-	  // Moved around its parent to cover visible view.
-	  d.mover = elt("div", [elt("div", [d.lineSpace], "CodeMirror-lines")], null, "position: relative")
-	  // Set to the height of the document, allowing scrolling.
-	  d.sizer = elt("div", [d.mover], "CodeMirror-sizer")
-	  d.sizerWidth = null
-	  // Behavior of elts with overflow: auto and padding is
-	  // inconsistent across browsers. This is used to ensure the
-	  // scrollable area is big enough.
-	  d.heightForcer = elt("div", null, null, "position: absolute; height: " + scrollerGap + "px; width: 1px;")
-	  // Will contain the gutters, if any.
-	  d.gutters = elt("div", null, "CodeMirror-gutters")
-	  d.lineGutter = null
-	  // Actual scrollable element.
-	  d.scroller = elt("div", [d.sizer, d.heightForcer, d.gutters], "CodeMirror-scroll")
-	  d.scroller.setAttribute("tabIndex", "-1")
-	  // The element in which the editor lives.
-	  d.wrapper = elt("div", [d.scrollbarFiller, d.gutterFiller, d.scroller], "CodeMirror")
-
-	  // Work around IE7 z-index bug (not perfect, hence IE7 not really being supported)
-	  if (ie && ie_version < 8) { d.gutters.style.zIndex = -1; d.scroller.style.paddingRight = 0 }
-	  if (!webkit && !(gecko && mobile)) { d.scroller.draggable = true }
-
-	  if (place) {
-	    if (place.appendChild) { place.appendChild(d.wrapper) }
-	    else { place(d.wrapper) }
-	  }
-
-	  // Current rendered range (may be bigger than the view window).
-	  d.viewFrom = d.viewTo = doc.first
-	  d.reportedViewFrom = d.reportedViewTo = doc.first
-	  // Information about the rendered lines.
-	  d.view = []
-	  d.renderedView = null
-	  // Holds info about a single rendered line when it was rendered
-	  // for measurement, while not in view.
-	  d.externalMeasured = null
-	  // Empty space (in pixels) above the view
-	  d.viewOffset = 0
-	  d.lastWrapHeight = d.lastWrapWidth = 0
-	  d.updateLineNumbers = null
-
-	  d.nativeBarWidth = d.barHeight = d.barWidth = 0
-	  d.scrollbarsClipped = false
-
-	  // Used to only resize the line number gutter when necessary (when
-	  // the amount of lines crosses a boundary that makes its width change)
-	  d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null
-	  // Set to true when a non-horizontal-scrolling line widget is
-	  // added. As an optimization, line widget aligning is skipped when
-	  // this is false.
-	  d.alignWidgets = false
-
-	  d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null
-
-	  // Tracks the maximum line length so that the horizontal scrollbar
-	  // can be kept static when scrolling.
-	  d.maxLine = null
-	  d.maxLineLength = 0
-	  d.maxLineChanged = false
-
-	  // Used for measuring wheel scrolling granularity
-	  d.wheelDX = d.wheelDY = d.wheelStartX = d.wheelStartY = null
-
-	  // True when shift is held down.
-	  d.shift = false
-
-	  // Used to track whether anything happened since the context menu
-	  // was opened.
-	  d.selForContextMenu = null
-
-	  d.activeTouch = null
-
-	  input.init(d)
-	}
-
-	// Find the line object corresponding to the given line number.
-	function getLine(doc, n) {
-	  n -= doc.first
-	  if (n < 0 || n >= doc.size) { throw new Error("There is no line " + (n + doc.first) + " in the document.") }
-	  var chunk = doc
-	  while (!chunk.lines) {
-	    for (var i = 0;; ++i) {
-	      var child = chunk.children[i], sz = child.chunkSize()
-	      if (n < sz) { chunk = child; break }
-	      n -= sz
-	    }
-	  }
-	  return chunk.lines[n]
-	}
-
-	// Get the part of a document between two positions, as an array of
-	// strings.
-	function getBetween(doc, start, end) {
-	  var out = [], n = start.line
-	  doc.iter(start.line, end.line + 1, function (line) {
-	    var text = line.text
-	    if (n == end.line) { text = text.slice(0, end.ch) }
-	    if (n == start.line) { text = text.slice(start.ch) }
-	    out.push(text)
-	    ++n
-	  })
-	  return out
-	}
-	// Get the lines between from and to, as array of strings.
-	function getLines(doc, from, to) {
-	  var out = []
-	  doc.iter(from, to, function (line) { out.push(line.text) }) // iter aborts when callback returns truthy value
-	  return out
-	}
-
-	// Update the height of a line, propagating the height change
-	// upwards to parent nodes.
-	function updateLineHeight(line, height) {
-	  var diff = height - line.height
-	  if (diff) { for (var n = line; n; n = n.parent) { n.height += diff } }
-	}
-
-	// Given a line object, find its line number by walking up through
-	// its parent links.
-	function lineNo(line) {
-	  if (line.parent == null) { return null }
-	  var cur = line.parent, no = indexOf(cur.lines, line)
-	  for (var chunk = cur.parent; chunk; cur = chunk, chunk = chunk.parent) {
-	    for (var i = 0;; ++i) {
-	      if (chunk.children[i] == cur) { break }
-	      no += chunk.children[i].chunkSize()
-	    }
-	  }
-	  return no + cur.first
-	}
-
-	// Find the line at the given vertical position, using the height
-	// information in the document tree.
-	function lineAtHeight(chunk, h) {
-	  var n = chunk.first
-	  outer: do {
-	    for (var i$1 = 0; i$1 < chunk.children.length; ++i$1) {
-	      var child = chunk.children[i$1], ch = child.height
-	      if (h < ch) { chunk = child; continue outer }
-	      h -= ch
-	      n += child.chunkSize()
-	    }
-	    return n
-	  } while (!chunk.lines)
-	  var i = 0
-	  for (; i < chunk.lines.length; ++i) {
-	    var line = chunk.lines[i], lh = line.height
-	    if (h < lh) { break }
-	    h -= lh
-	  }
-	  return n + i
-	}
-
-	function isLine(doc, l) {return l >= doc.first && l < doc.first + doc.size}
-
-	function lineNumberFor(options, i) {
-	  return String(options.lineNumberFormatter(i + options.firstLineNumber))
-	}
-
-	// A Pos instance represents a position within the text.
-	function Pos (line, ch) {
-	  if (!(this instanceof Pos)) { return new Pos(line, ch) }
-	  this.line = line; this.ch = ch
-	}
-
-	// Compare two positions, return 0 if they are the same, a negative
-	// number when a is less, and a positive number otherwise.
-	function cmp(a, b) { return a.line - b.line || a.ch - b.ch }
-
-	function copyPos(x) {return Pos(x.line, x.ch)}
-	function maxPos(a, b) { return cmp(a, b) < 0 ? b : a }
-	function minPos(a, b) { return cmp(a, b) < 0 ? a : b }
-
-	// Most of the external API clips given positions to make sure they
-	// actually exist within the document.
-	function clipLine(doc, n) {return Math.max(doc.first, Math.min(n, doc.first + doc.size - 1))}
-	function clipPos(doc, pos) {
-	  if (pos.line < doc.first) { return Pos(doc.first, 0) }
-	  var last = doc.first + doc.size - 1
-	  if (pos.line > last) { return Pos(last, getLine(doc, last).text.length) }
-	  return clipToLen(pos, getLine(doc, pos.line).text.length)
-	}
-	function clipToLen(pos, linelen) {
-	  var ch = pos.ch
-	  if (ch == null || ch > linelen) { return Pos(pos.line, linelen) }
-	  else if (ch < 0) { return Pos(pos.line, 0) }
-	  else { return pos }
-	}
-	function clipPosArray(doc, array) {
-	  var out = []
-	  for (var i = 0; i < array.length; i++) { out[i] = clipPos(doc, array[i]) }
-	  return out
-	}
-
-	// Optimize some code when these features are not used.
-	var sawReadOnlySpans = false;
-	var sawCollapsedSpans = false;
-	function seeReadOnlySpans() {
-	  sawReadOnlySpans = true
-	}
-
-	function seeCollapsedSpans() {
-	  sawCollapsedSpans = true
-	}
-
-	// TEXTMARKER SPANS
-
-	function MarkedSpan(marker, from, to) {
-	  this.marker = marker
-	  this.from = from; this.to = to
-	}
-
-	// Search an array of spans for a span matching the given marker.
-	function getMarkedSpanFor(spans, marker) {
-	  if (spans) { for (var i = 0; i < spans.length; ++i) {
-	    var span = spans[i]
-	    if (span.marker == marker) { return span }
-	  } }
-	}
-	// Remove a span from an array, returning undefined if no spans are
-	// left (we don't store arrays for lines without spans).
-	function removeMarkedSpan(spans, span) {
-	  var r
-	  for (var i = 0; i < spans.length; ++i)
-	    { if (spans[i] != span) { (r || (r = [])).push(spans[i]) } }
-	  return r
-	}
-	// Add a span to a line.
-	function addMarkedSpan(line, span) {
-	  line.markedSpans = line.markedSpans ? line.markedSpans.concat([span]) : [span]
-	  span.marker.attachLine(line)
-	}
-
-	// Used for the algorithm that adjusts markers for a change in the
-	// document. These functions cut an array of spans at a given
-	// character position, returning an array of remaining chunks (or
-	// undefined if nothing remains).
-	function markedSpansBefore(old, startCh, isInsert) {
-	  var nw
-	  if (old) { for (var i = 0; i < old.length; ++i) {
-	    var span = old[i], marker = span.marker
-	    var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= startCh : span.from < startCh)
-	    if (startsBefore || span.from == startCh && marker.type == "bookmark" && (!isInsert || !span.marker.insertLeft)) {
-	      var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= startCh : span.to > startCh)
-	      ;(nw || (nw = [])).push(new MarkedSpan(marker, span.from, endsAfter ? null : span.to))
-	    }
-	  } }
-	  return nw
-	}
-	function markedSpansAfter(old, endCh, isInsert) {
-	  var nw
-	  if (old) { for (var i = 0; i < old.length; ++i) {
-	    var span = old[i], marker = span.marker
-	    var endsAfter = span.to == null || (marker.inclusiveRight ? span.to >= endCh : span.to > endCh)
-	    if (endsAfter || span.from == endCh && marker.type == "bookmark" && (!isInsert || span.marker.insertLeft)) {
-	      var startsBefore = span.from == null || (marker.inclusiveLeft ? span.from <= endCh : span.from < endCh)
-	      ;(nw || (nw = [])).push(new MarkedSpan(marker, startsBefore ? null : span.from - endCh,
-	                                            span.to == null ? null : span.to - endCh))
-	    }
-	  } }
-	  return nw
-	}
-
-	// Given a change object, compute the new set of marker spans that
-	// cover the line in which the change took place. Removes spans
-	// entirely within the change, reconnects spans belonging to the
-	// same marker that appear on both sides of the change, and cuts off
-	// spans partially within the change. Returns an array of span
-	// arrays with one element for each line in (after) the change.
-	function stretchSpansOverChange(doc, change) {
-	  if (change.full) { return null }
-	  var oldFirst = isLine(doc, change.from.line) && getLine(doc, change.from.line).markedSpans
-	  var oldLast = isLine(doc, change.to.line) && getLine(doc, change.to.line).markedSpans
-	  if (!oldFirst && !oldLast) { return null }
-
-	  var startCh = change.from.ch, endCh = change.to.ch, isInsert = cmp(change.from, change.to) == 0
-	  // Get the spans that 'stick out' on both sides
-	  var first = markedSpansBefore(oldFirst, startCh, isInsert)
-	  var last = markedSpansAfter(oldLast, endCh, isInsert)
-
-	  // Next, merge those two ends
-	  var sameLine = change.text.length == 1, offset = lst(change.text).length + (sameLine ? startCh : 0)
-	  if (first) {
-	    // Fix up .to properties of first
-	    for (var i = 0; i < first.length; ++i) {
-	      var span = first[i]
-	      if (span.to == null) {
-	        var found = getMarkedSpanFor(last, span.marker)
-	        if (!found) { span.to = startCh }
-	        else if (sameLine) { span.to = found.to == null ? null : found.to + offset }
-	      }
-	    }
-	  }
-	  if (last) {
-	    // Fix up .from in last (or move them into first in case of sameLine)
-	    for (var i$1 = 0; i$1 < last.length; ++i$1) {
-	      var span$1 = last[i$1]
-	      if (span$1.to != null) { span$1.to += offset }
-	      if (span$1.from == null) {
-	        var found$1 = getMarkedSpanFor(first, span$1.marker)
-	        if (!found$1) {
-	          span$1.from = offset
-	          if (sameLine) { (first || (first = [])).push(span$1) }
-	        }
-	      } else {
-	        span$1.from += offset
-	        if (sameLine) { (first || (first = [])).push(span$1) }
-	      }
-	    }
-	  }
-	  // Make sure we didn't create any zero-length spans
-	  if (first) { first = clearEmptySpans(first) }
-	  if (last && last != first) { last = clearEmptySpans(last) }
-
-	  var newMarkers = [first]
-	  if (!sameLine) {
-	    // Fill gap with whole-line-spans
-	    var gap = change.text.length - 2, gapMarkers
-	    if (gap > 0 && first)
-	      { for (var i$2 = 0; i$2 < first.length; ++i$2)
-	        { if (first[i$2].to == null)
-	          { (gapMarkers || (gapMarkers = [])).push(new MarkedSpan(first[i$2].marker, null, null)) } } }
-	    for (var i$3 = 0; i$3 < gap; ++i$3)
-	      { newMarkers.push(gapMarkers) }
-	    newMarkers.push(last)
-	  }
-	  return newMarkers
-	}
-
-	// Remove spans that are empty and don't have a clearWhenEmpty
-	// option of false.
-	function clearEmptySpans(spans) {
-	  for (var i = 0; i < spans.length; ++i) {
-	    var span = spans[i]
-	    if (span.from != null && span.from == span.to && span.marker.clearWhenEmpty !== false)
-	      { spans.splice(i--, 1) }
-	  }
-	  if (!spans.length) { return null }
-	  return spans
-	}
-
-	// Used to 'clip' out readOnly ranges when making a change.
-	function removeReadOnlyRanges(doc, from, to) {
-	  var markers = null
-	  doc.iter(from.line, to.line + 1, function (line) {
-	    if (line.markedSpans) { for (var i = 0; i < line.markedSpans.length; ++i) {
-	      var mark = line.markedSpans[i].marker
-	      if (mark.readOnly && (!markers || indexOf(markers, mark) == -1))
-	        { (markers || (markers = [])).push(mark) }
-	    } }
-	  })
-	  if (!markers) { return null }
-	  var parts = [{from: from, to: to}]
-	  for (var i = 0; i < markers.length; ++i) {
-	    var mk = markers[i], m = mk.find(0)
-	    for (var j = 0; j < parts.length; ++j) {
-	      var p = parts[j]
-	      if (cmp(p.to, m.from) < 0 || cmp(p.from, m.to) > 0) { continue }
-	      var newParts = [j, 1], dfrom = cmp(p.from, m.from), dto = cmp(p.to, m.to)
-	      if (dfrom < 0 || !mk.inclusiveLeft && !dfrom)
-	        { newParts.push({from: p.from, to: m.from}) }
-	      if (dto > 0 || !mk.inclusiveRight && !dto)
-	        { newParts.push({from: m.to, to: p.to}) }
-	      parts.splice.apply(parts, newParts)
-	      j += newParts.length - 1
-	    }
-	  }
-	  return parts
-	}
-
-	// Connect or disconnect spans from a line.
-	function detachMarkedSpans(line) {
-	  var spans = line.markedSpans
-	  if (!spans) { return }
-	  for (var i = 0; i < spans.length; ++i)
-	    { spans[i].marker.detachLine(line) }
-	  line.markedSpans = null
-	}
-	function attachMarkedSpans(line, spans) {
-	  if (!spans) { return }
-	  for (var i = 0; i < spans.length; ++i)
-	    { spans[i].marker.attachLine(line) }
-	  line.markedSpans = spans
-	}
-
-	// Helpers used when computing which overlapping collapsed span
-	// counts as the larger one.
-	function extraLeft(marker) { return marker.inclusiveLeft ? -1 : 0 }
-	function extraRight(marker) { return marker.inclusiveRight ? 1 : 0 }
-
-	// Returns a number indicating which of two overlapping collapsed
-	// spans is larger (and thus includes the other). Falls back to
-	// comparing ids when the spans cover exactly the same range.
-	function compareCollapsedMarkers(a, b) {
-	  var lenDiff = a.lines.length - b.lines.length
-	  if (lenDiff != 0) { return lenDiff }
-	  var aPos = a.find(), bPos = b.find()
-	  var fromCmp = cmp(aPos.from, bPos.from) || extraLeft(a) - extraLeft(b)
-	  if (fromCmp) { return -fromCmp }
-	  var toCmp = cmp(aPos.to, bPos.to) || extraRight(a) - extraRight(b)
-	  if (toCmp) { return toCmp }
-	  return b.id - a.id
-	}
-
-	// Find out whether a line ends or starts in a collapsed span. If
-	// so, return the marker for that span.
-	function collapsedSpanAtSide(line, start) {
-	  var sps = sawCollapsedSpans && line.markedSpans, found
-	  if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) {
-	    sp = sps[i]
-	    if (sp.marker.collapsed && (start ? sp.from : sp.to) == null &&
-	        (!found || compareCollapsedMarkers(found, sp.marker) < 0))
-	      { found = sp.marker }
-	  } }
-	  return found
-	}
-	function collapsedSpanAtStart(line) { return collapsedSpanAtSide(line, true) }
-	function collapsedSpanAtEnd(line) { return collapsedSpanAtSide(line, false) }
-
-	// Test whether there exists a collapsed span that partially
-	// overlaps (covers the start or end, but not both) of a new span.
-	// Such overlap is not allowed.
-	function conflictingCollapsedRange(doc, lineNo, from, to, marker) {
-	  var line = getLine(doc, lineNo)
-	  var sps = sawCollapsedSpans && line.markedSpans
-	  if (sps) { for (var i = 0; i < sps.length; ++i) {
-	    var sp = sps[i]
-	    if (!sp.marker.collapsed) { continue }
-	    var found = sp.marker.find(0)
-	    var fromCmp = cmp(found.from, from) || extraLeft(sp.marker) - extraLeft(marker)
-	    var toCmp = cmp(found.to, to) || extraRight(sp.marker) - extraRight(marker)
-	    if (fromCmp >= 0 && toCmp <= 0 || fromCmp <= 0 && toCmp >= 0) { continue }
-	    if (fromCmp <= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.to, from) >= 0 : cmp(found.to, from) > 0) ||
-	        fromCmp >= 0 && (sp.marker.inclusiveRight && marker.inclusiveLeft ? cmp(found.from, to) <= 0 : cmp(found.from, to) < 0))
-	      { return true }
-	  } }
-	}
-
-	// A visual line is a line as drawn on the screen. Folding, for
-	// example, can cause multiple logical lines to appear on the same
-	// visual line. This finds the start of the visual line that the
-	// given line is part of (usually that is the line itself).
-	function visualLine(line) {
-	  var merged
-	  while (merged = collapsedSpanAtStart(line))
-	    { line = merged.find(-1, true).line }
-	  return line
-	}
-
-	// Returns an array of logical lines that continue the visual line
-	// started by the argument, or undefined if there are no such lines.
-	function visualLineContinued(line) {
-	  var merged, lines
-	  while (merged = collapsedSpanAtEnd(line)) {
-	    line = merged.find(1, true).line
-	    ;(lines || (lines = [])).push(line)
-	  }
-	  return lines
-	}
-
-	// Get the line number of the start of the visual line that the
-	// given line number is part of.
-	function visualLineNo(doc, lineN) {
-	  var line = getLine(doc, lineN), vis = visualLine(line)
-	  if (line == vis) { return lineN }
-	  return lineNo(vis)
-	}
-
-	// Get the line number of the start of the next visual line after
-	// the given line.
-	function visualLineEndNo(doc, lineN) {
-	  if (lineN > doc.lastLine()) { return lineN }
-	  var line = getLine(doc, lineN), merged
-	  if (!lineIsHidden(doc, line)) { return lineN }
-	  while (merged = collapsedSpanAtEnd(line))
-	    { line = merged.find(1, true).line }
-	  return lineNo(line) + 1
-	}
-
-	// Compute whether a line is hidden. Lines count as hidden when they
-	// are part of a visual line that starts with another line, or when
-	// they are entirely covered by collapsed, non-widget span.
-	function lineIsHidden(doc, line) {
-	  var sps = sawCollapsedSpans && line.markedSpans
-	  if (sps) { for (var sp = (void 0), i = 0; i < sps.length; ++i) {
-	    sp = sps[i]
-	    if (!sp.marker.collapsed) { continue }
-	    if (sp.from == null) { return true }
-	    if (sp.marker.widgetNode) { continue }
-	    if (sp.from == 0 && sp.marker.inclusiveLeft && lineIsHiddenInner(doc, line, sp))
-	      { return true }
-	  } }
-	}
-	function lineIsHiddenInner(doc, line, span) {
-	  if (span.to == null) {
-	    var end = span.marker.find(1, true)
-	    return lineIsHiddenInner(doc, end.line, getMarkedSpanFor(end.line.markedSpans, span.marker))
-	  }
-	  if (span.marker.inclusiveRight && span.to == line.text.length)
-	    { return true }
-	  for (var sp = (void 0), i = 0; i < line.markedSpans.length; ++i) {
-	    sp = line.markedSpans[i]
-	    if (sp.marker.collapsed && !sp.marker.widgetNode && sp.from == span.to &&
-	        (sp.to == null || sp.to != span.from) &&
-	        (sp.marker.inclusiveLeft || span.marker.inclusiveRight) &&
-	        lineIsHiddenInner(doc, line, sp)) { return true }
-	  }
-	}
-
-	// Find the height above the given line.
-	function heightAtLine(lineObj) {
-	  lineObj = visualLine(lineObj)
-
-	  var h = 0, chunk = lineObj.parent
-	  for (var i = 0; i < chunk.lines.length; ++i) {
-	    var line = chunk.lines[i]
-	    if (line == lineObj) { break }
-	    else { h += line.height }
-	  }
-	  for (var p = chunk.parent; p; chunk = p, p = chunk.parent) {
-	    for (var i$1 = 0; i$1 < p.children.length; ++i$1) {
-	      var cur = p.children[i$1]
-	      if (cur == chunk) { break }
-	      else { h += cur.height }
-	    }
-	  }
-	  return h
-	}
-
-	// Compute the character length of a line, taking into account
-	// collapsed ranges (see markText) that might hide parts, and join
-	// other lines onto it.
-	function lineLength(line) {
-	  if (line.height == 0) { return 0 }
-	  var len = line.text.length, merged, cur = line
-	  while (merged = collapsedSpanAtStart(cur)) {
-	    var found = merged.find(0, true)
-	    cur = found.from.line
-	    len += found.from.ch - found.to.ch
-	  }
-	  cur = line
-	  while (merged = collapsedSpanAtEnd(cur)) {
-	    var found$1 = merged.find(0, true)
-	    len -= cur.text.length - found$1.from.ch
-	    cur = found$1.to.line
-	    len += cur.text.length - found$1.to.ch
-	  }
-	  return len
-	}
-
-	// Find the longest line in the document.
-	function findMaxLine(cm) {
-	  var d = cm.display, doc = cm.doc
-	  d.maxLine = getLine(doc, doc.first)
-	  d.maxLineLength = lineLength(d.maxLine)
-	  d.maxLineChanged = true
-	  doc.iter(function (line) {
-	    var len = lineLength(line)
-	    if (len > d.maxLineLength) {
-	      d.maxLineLength = len
-	      d.maxLine = line
-	    }
-	  })
-	}
-
-	// BIDI HELPERS
-
-	function iterateBidiSections(order, from, to, f) {
-	  if (!order) { return f(from, to, "ltr") }
-	  var found = false
-	  for (var i = 0; i < order.length; ++i) {
-	    var part = order[i]
-	    if (part.from < to && part.to > from || from == to && part.to == from) {
-	      f(Math.max(part.from, from), Math.min(part.to, to), part.level == 1 ? "rtl" : "ltr")
-	      found = true
-	    }
-	  }
-	  if (!found) { f(from, to, "ltr") }
-	}
-
-	function bidiLeft(part) { return part.level % 2 ? part.to : part.from }
-	function bidiRight(part) { return part.level % 2 ? part.from : part.to }
-
-	function lineLeft(line) { var order = getOrder(line); return order ? bidiLeft(order[0]) : 0 }
-	function lineRight(line) {
-	  var order = getOrder(line)
-	  if (!order) { return line.text.length }
-	  return bidiRight(lst(order))
-	}
-
-	function compareBidiLevel(order, a, b) {
-	  var linedir = order[0].level
-	  if (a == linedir) { return true }
-	  if (b == linedir) { return false }
-	  return a < b
-	}
-
-	var bidiOther = null
-	function getBidiPartAt(order, pos) {
-	  var found
-	  bidiOther = null
-	  for (var i = 0; i < order.length; ++i) {
-	    var cur = order[i]
-	    if (cur.from < pos && cur.to > pos) { return i }
-	    if ((cur.from == pos || cur.to == pos)) {
-	      if (found == null) {
-	        found = i
-	      } else if (compareBidiLevel(order, cur.level, order[found].level)) {
-	        if (cur.from != cur.to) { bidiOther = found }
-	        return i
-	      } else {
-	        if (cur.from != cur.to) { bidiOther = i }
-	        return found
-	      }
-	    }
-	  }
-	  return found
-	}
-
-	function moveInLine(line, pos, dir, byUnit) {
-	  if (!byUnit) { return pos + dir }
-	  do { pos += dir }
-	  while (pos > 0 && isExtendingChar(line.text.charAt(pos)))
-	  return pos
-	}
-
-	// This is needed in order to move 'visually' through bi-directional
-	// text -- i.e., pressing left should make the cursor go left, even
-	// when in RTL text. The tricky part is the 'jumps', where RTL and
-	// LTR text touch each other. This often requires the cursor offset
-	// to move more than one unit, in order to visually move one unit.
-	function moveVisually(line, start, dir, byUnit) {
-	  var bidi = getOrder(line)
-	  if (!bidi) { return moveLogically(line, start, dir, byUnit) }
-	  var pos = getBidiPartAt(bidi, start), part = bidi[pos]
-	  var target = moveInLine(line, start, part.level % 2 ? -dir : dir, byUnit)
-
-	  for (;;) {
-	    if (target > part.from && target < part.to) { return target }
-	    if (target == part.from || target == part.to) {
-	      if (getBidiPartAt(bidi, target) == pos) { return target }
-	      part = bidi[pos += dir]
-	      return (dir > 0) == part.level % 2 ? part.to : part.from
-	    } else {
-	      part = bidi[pos += dir]
-	      if (!part) { return null }
-	      if ((dir > 0) == part.level % 2)
-	        { target = moveInLine(line, part.to, -1, byUnit) }
-	      else
-	        { target = moveInLine(line, part.from, 1, byUnit) }
-	    }
-	  }
-	}
-
-	function moveLogically(line, start, dir, byUnit) {
-	  var target = start + dir
-	  if (byUnit) { while (target > 0 && isExtendingChar(line.text.charAt(target))) { target += dir } }
-	  return target < 0 || target > line.text.length ? null : target
-	}
-
-	// Bidirectional ordering algorithm
-	// See http://unicode.org/reports/tr9/tr9-13.html for the algorithm
-	// that this (partially) implements.
-
-	// One-char codes used for character types:
-	// L (L):   Left-to-Right
-	// R (R):   Right-to-Left
-	// r (AL):  Right-to-Left Arabic
-	// 1 (EN):  European Number
-	// + (ES):  European Number Separator
-	// % (ET):  European Number Terminator
-	// n (AN):  Arabic Number
-	// , (CS):  Common Number Separator
-	// m (NSM): Non-Spacing Mark
-	// b (BN):  Boundary Neutral
-	// s (B):   Paragraph Separator
-	// t (S):   Segment Separator
-	// w (WS):  Whitespace
-	// N (ON):  Other Neutrals
-
-	// Returns null if characters are ordered as they appear
-	// (left-to-right), or an array of sections ({from, to, level}
-	// objects) in the order in which they occur visually.
-	var bidiOrdering = (function() {
-	  // Character types for codepoints 0 to 0xff
-	  var lowTypes = "bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLN"
-	  // Character types for codepoints 0x600 to 0x6ff
-	  var arabicTypes = "rrrrrrrrrrrr,rNNmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmrrrrrrrnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmNmmmm"
-	  function charType(code) {
-	    if (code <= 0xf7) { return lowTypes.charAt(code) }
-	    else if (0x590 <= code && code <= 0x5f4) { return "R" }
-	    else if (0x600 <= code && code <= 0x6ed) { return arabicTypes.charAt(code - 0x600) }
-	    else if (0x6ee <= code && code <= 0x8ac) { return "r" }
-	    else if (0x2000 <= code && code <= 0x200b) { return "w" }
-	    else if (code == 0x200c) { return "b" }
-	    else { return "L" }
-	  }
-
-	  var bidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac]/
-	  var isNeutral = /[stwN]/, isStrong = /[LRr]/, countsAsLeft = /[Lb1n]/, countsAsNum = /[1n]/
-	  // Browsers seem to always treat the boundaries of block elements as being L.
-	  var outerType = "L"
-
-	  function BidiSpan(level, from, to) {
-	    this.level = level
-	    this.from = from; this.to = to
-	  }
-
-	  return function(str) {
-	    if (!bidiRE.test(str)) { return false }
-	    var len = str.length, types = []
-	    for (var i = 0; i < len; ++i)
-	      { types.push(charType(str.charCodeAt(i))) }
-
-	    // W1. Examine each non-spacing mark (NSM) in the level run, and
-	    // change the type of the NSM to the type of the previous
-	    // character. If the NSM is at the start of the level run, it will
-	    // get the type of sor.
-	    for (var i$1 = 0, prev = outerType; i$1 < len; ++i$1) {
-	      var type = types[i$1]
-	      if (type == "m") { types[i$1] = prev }
-	      else { prev = type }
-	    }
-
-	    // W2. Search backwards from each instance of a European number
-	    // until the first strong type (R, L, AL, or sor) is found. If an
-	    // AL is found, change the type of the European number to Arabic
-	    // number.
-	    // W3. Change all ALs to R.
-	    for (var i$2 = 0, cur = outerType; i$2 < len; ++i$2) {
-	      var type$1 = types[i$2]
-	      if (type$1 == "1" && cur == "r") { types[i$2] = "n" }
-	      else if (isStrong.test(type$1)) { cur = type$1; if (type$1 == "r") { types[i$2] = "R" } }
-	    }
-
-	    // W4. A single European separator between two European numbers
-	    // changes to a European number. A single common separator between
-	    // two numbers of the same type changes to that type.
-	    for (var i$3 = 1, prev$1 = types[0]; i$3 < len - 1; ++i$3) {
-	      var type$2 = types[i$3]
-	      if (type$2 == "+" && prev$1 == "1" && types[i$3+1] == "1") { types[i$3] = "1" }
-	      else if (type$2 == "," && prev$1 == types[i$3+1] &&
-	               (prev$1 == "1" || prev$1 == "n")) { types[i$3] = prev$1 }
-	      prev$1 = type$2
-	    }
-
-	    // W5. A sequence of European terminators adjacent to European
-	    // numbers changes to all European numbers.
-	    // W6. Otherwise, separators and terminators change to Other
-	    // Neutral.
-	    for (var i$4 = 0; i$4 < len; ++i$4) {
-	      var type$3 = types[i$4]
-	      if (type$3 == ",") { types[i$4] = "N" }
-	      else if (type$3 == "%") {
-	        var end = (void 0)
-	        for (end = i$4 + 1; end < len && types[end] == "%"; ++end) {}
-	        var replace = (i$4 && types[i$4-1] == "!") || (end < len && types[end] == "1") ? "1" : "N"
-	        for (var j = i$4; j < end; ++j) { types[j] = replace }
-	        i$4 = end - 1
-	      }
-	    }
-
-	    // W7. Search backwards from each instance of a European number
-	    // until the first strong type (R, L, or sor) is found. If an L is
-	    // found, then change the type of the European number to L.
-	    for (var i$5 = 0, cur$1 = outerType; i$5 < len; ++i$5) {
-	      var type$4 = types[i$5]
-	      if (cur$1 == "L" && type$4 == "1") { types[i$5] = "L" }
-	      else if (isStrong.test(type$4)) { cur$1 = type$4 }
-	    }
-
-	    // N1. A sequence of neutrals takes the direction of the
-	    // surrounding strong text if the text on both sides has the same
-	    // direction. European and Arabic numbers act as if they were R in
-	    // terms of their influence on neutrals. Start-of-level-run (sor)
-	    // and end-of-level-run (eor) are used at level run boundaries.
-	    // N2. Any remaining neutrals take the embedding direction.
-	    for (var i$6 = 0; i$6 < len; ++i$6) {
-	      if (isNeutral.test(types[i$6])) {
-	        var end$1 = (void 0)
-	        for (end$1 = i$6 + 1; end$1 < len && isNeutral.test(types[end$1]); ++end$1) {}
-	        var before = (i$6 ? types[i$6-1] : outerType) == "L"
-	        var after = (end$1 < len ? types[end$1] : outerType) == "L"
-	        var replace$1 = before || after ? "L" : "R"
-	        for (var j$1 = i$6; j$1 < end$1; ++j$1) { types[j$1] = replace$1 }
-	        i$6 = end$1 - 1
-	      }
-	    }
-
-	    // Here we depart from the documented algorithm, in order to avoid
-	    // building up an actual levels array. Since there are only three
-	    // levels (0, 1, 2) in an implementation that doesn't take
-	    // explicit embedding into account, we can build up the order on
-	    // the fly, without following the level-based algorithm.
-	    var order = [], m
-	    for (var i$7 = 0; i$7 < len;) {
-	      if (countsAsLeft.test(types[i$7])) {
-	        var start = i$7
-	        for (++i$7; i$7 < len && countsAsLeft.test(types[i$7]); ++i$7) {}
-	        order.push(new BidiSpan(0, start, i$7))
-	      } else {
-	        var pos = i$7, at = order.length
-	        for (++i$7; i$7 < len && types[i$7] != "L"; ++i$7) {}
-	        for (var j$2 = pos; j$2 < i$7;) {
-	          if (countsAsNum.test(types[j$2])) {
-	            if (pos < j$2) { order.splice(at, 0, new BidiSpan(1, pos, j$2)) }
-	            var nstart = j$2
-	            for (++j$2; j$2 < i$7 && countsAsNum.test(types[j$2]); ++j$2) {}
-	            order.splice(at, 0, new BidiSpan(2, nstart, j$2))
-	            pos = j$2
-	          } else { ++j$2 }
-	        }
-	        if (pos < i$7) { order.splice(at, 0, new BidiSpan(1, pos, i$7)) }
-	      }
-	    }
-	    if (order[0].level == 1 && (m = str.match(/^\s+/))) {
-	      order[0].from = m[0].length
-	      order.unshift(new BidiSpan(0, 0, m[0].length))
-	    }
-	    if (lst(order).level == 1 && (m = str.match(/\s+$/))) {
-	      lst(order).to -= m[0].length
-	      order.push(new BidiSpan(0, len - m[0].length, len))
-	    }
-	    if (order[0].level == 2)
-	      { order.unshift(new BidiSpan(1, order[0].to, order[0].to)) }
-	    if (order[0].level != lst(order).level)
-	      { order.push(new BidiSpan(order[0].level, len, len)) }
-
-	    return order
-	  }
-	})()
-
-	// Get the bidi ordering for the given line (and cache it). Returns
-	// false for lines that are fully left-to-right, and an array of
-	// BidiSpan objects otherwise.
-	function getOrder(line) {
-	  var order = line.order
-	  if (order == null) { order = line.order = bidiOrdering(line.text) }
-	  return order
-	}
-
-	// EVENT HANDLING
-
-	// Lightweight event framework. on/off also work on DOM nodes,
-	// registering native DOM handlers.
-
-	var noHandlers = []
-
-	var on = function(emitter, type, f) {
-	  if (emitter.addEventListener) {
-	    emitter.addEventListener(type, f, false)
-	  } else if (emitter.attachEvent) {
-	    emitter.attachEvent("on" + type, f)
-	  } else {
-	    var map = emitter._handlers || (emitter._handlers = {})
-	    map[type] = (map[type] || noHandlers).concat(f)
-	  }
-	}
-
-	function getHandlers(emitter, type) {
-	  return emitter._handlers && emitter._handlers[type] || noHandlers
-	}
-
-	function off(emitter, type, f) {
-	  if (emitter.removeEventListener) {
-	    emitter.removeEventListener(type, f, false)
-	  } else if (emitter.detachEvent) {
-	    emitter.detachEvent("on" + type, f)
-	  } else {
-	    var map = emitter._handlers, arr = map && map[type]
-	    if (arr) {
-	      var index = indexOf(arr, f)
-	      if (index > -1)
-	        { map[type] = arr.slice(0, index).concat(arr.slice(index + 1)) }
-	    }
-	  }
-	}
-
-	function signal(emitter, type /*, values...*/) {
-	  var handlers = getHandlers(emitter, type)
-	  if (!handlers.length) { return }
-	  var args = Array.prototype.slice.call(arguments, 2)
-	  for (var i = 0; i < handlers.length; ++i) { handlers[i].apply(null, args) }
-	}
-
-	// The DOM events that CodeMirror handles can be overridden by
-	// registering a (non-DOM) handler on the editor for the event name,
-	// and preventDefault-ing the event in that handler.
-	function signalDOMEvent(cm, e, override) {
-	  if (typeof e == "string")
-	    { e = {type: e, preventDefault: function() { this.defaultPrevented = true }} }
-	  signal(cm, override || e.type, cm, e)
-	  return e_defaultPrevented(e) || e.codemirrorIgnore
-	}
-
-	function signalCursorActivity(cm) {
-	  var arr = cm._handlers && cm._handlers.cursorActivity
-	  if (!arr) { return }
-	  var set = cm.curOp.cursorActivityHandlers || (cm.curOp.cursorActivityHandlers = [])
-	  for (var i = 0; i < arr.length; ++i) { if (indexOf(set, arr[i]) == -1)
-	    { set.push(arr[i]) } }
-	}
-
-	function hasHandler(emitter, type) {
-	  return getHandlers(emitter, type).length > 0
-	}
-
-	// Add on and off methods to a constructor's prototype, to make
-	// registering events on such objects more convenient.
-	function eventMixin(ctor) {
-	  ctor.prototype.on = function(type, f) {on(this, type, f)}
-	  ctor.prototype.off = function(type, f) {off(this, type, f)}
-	}
-
-	// Due to the fact that we still support jurassic IE versions, some
-	// compatibility wrappers are needed.
-
-	function e_preventDefault(e) {
-	  if (e.preventDefault) { e.preventDefault() }
-	  else { e.returnValue = false }
-	}
-	function e_stopPropagation(e) {
-	  if (e.stopPropagation) { e.stopPropagation() }
-	  else { e.cancelBubble = true }
-	}
-	function e_defaultPrevented(e) {
-	  return e.defaultPrevented != null ? e.defaultPrevented : e.returnValue == false
-	}
-	function e_stop(e) {e_preventDefault(e); e_stopPropagation(e)}
-
-	function e_target(e) {return e.target || e.srcElement}
-	function e_button(e) {
-	  var b = e.which
-	  if (b == null) {
-	    if (e.button & 1) { b = 1 }
-	    else if (e.button & 2) { b = 3 }
-	    else if (e.button & 4) { b = 2 }
-	  }
-	  if (mac && e.ctrlKey && b == 1) { b = 3 }
-	  return b
-	}
-
-	// Detect drag-and-drop
-	var dragAndDrop = function() {
-	  // There is *some* kind of drag-and-drop support in IE6-8, but I
-	  // couldn't get it to work yet.
-	  if (ie && ie_version < 9) { return false }
-	  var div = elt('div')
-	  return "draggable" in div || "dragDrop" in div
-	}()
-
-	var zwspSupported
-	function zeroWidthElement(measure) {
-	  if (zwspSupported == null) {
-	    var test = elt("span", "\u200b")
-	    removeChildrenAndAdd(measure, elt("span", [test, document.createTextNode("x")]))
-	    if (measure.firstChild.offsetHeight != 0)
-	      { zwspSupported = test.offsetWidth <= 1 && test.offsetHeight > 2 && !(ie && ie_version < 8) }
-	  }
-	  var node = zwspSupported ? elt("span", "\u200b") :
-	    elt("span", "\u00a0", null, "display: inline-block; width: 1px; margin-right: -1px")
-	  node.setAttribute("cm-text", "")
-	  return node
-	}
-
-	// Feature-detect IE's crummy client rect reporting for bidi text
-	var badBidiRects
-	function hasBadBidiRects(measure) {
-	  if (badBidiRects != null) { return badBidiRects }
-	  var txt = removeChildrenAndAdd(measure, document.createTextNode("A\u062eA"))
-	  var r0 = range(txt, 0, 1).getBoundingClientRect()
-	  var r1 = range(txt, 1, 2).getBoundingClientRect()
-	  removeChildren(measure)
-	  if (!r0 || r0.left == r0.right) { return false } // Safari returns null in some cases (#2780)
-	  return badBidiRects = (r1.right - r0.right < 3)
-	}
-
-	// See if "".split is the broken IE version, if so, provide an
-	// alternative way to split lines.
-	var splitLinesAuto = "\n\nb".split(/\n/).length != 3 ? function (string) {
-	  var pos = 0, result = [], l = string.length
-	  while (pos <= l) {
-	    var nl = string.indexOf("\n", pos)
-	    if (nl == -1) { nl = string.length }
-	    var line = string.slice(pos, string.charAt(nl - 1) == "\r" ? nl - 1 : nl)
-	    var rt = line.indexOf("\r")
-	    if (rt != -1) {
-	      result.push(line.slice(0, rt))
-	      pos += rt + 1
-	    } else {
-	      result.push(line)
-	      pos = nl + 1
-	    }
-	  }
-	  return result
-	} : function (string) { return string.split(/\r\n?|\n/); }
-
-	var hasSelection = window.getSelection ? function (te) {
-	  try { return te.selectionStart != te.selectionEnd }
-	  catch(e) { return false }
-	} : function (te) {
-	  var range
-	  try {range = te.ownerDocument.selection.createRange()}
-	  catch(e) {}
-	  if (!range || range.parentElement() != te) { return false }
-	  return range.compareEndPoints("StartToEnd", range) != 0
-	}
-
-	var hasCopyEvent = (function () {
-	  var e = elt("div")
-	  if ("oncopy" in e) { return true }
-	  e.setAttribute("oncopy", "return;")
-	  return typeof e.oncopy == "function"
-	})()
-
-	var badZoomedRects = null
-	function hasBadZoomedRects(measure) {
-	  if (badZoomedRects != null) { return badZoomedRects }
-	  var node = removeChildrenAndAdd(measure, elt("span", "x"))
-	  var normal = node.getBoundingClientRect()
-	  var fromRange = range(node, 0, 1).getBoundingClientRect()
-	  return badZoomedRects = Math.abs(normal.left - fromRange.left) > 1
-	}
-
-	var modes = {};
-	var mimeModes = {};
-	// Extra arguments are stored as the mode's dependencies, which is
-	// used by (legacy) mechanisms like loadmode.js to automatically
-	// load a mode. (Preferred mechanism is the require/define calls.)
-	function defineMode(name, mode) {
-	  if (arguments.length > 2)
-	    { mode.dependencies = Array.prototype.slice.call(arguments, 2) }
-	  modes[name] = mode
-	}
-
-	function defineMIME(mime, spec) {
-	  mimeModes[mime] = spec
-	}
-
-	// Given a MIME type, a {name, ...options} config object, or a name
-	// string, return a mode config object.
-	function resolveMode(spec) {
-	  if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) {
-	    spec = mimeModes[spec]
-	  } else if (spec && typeof spec.name == "string" && mimeModes.hasOwnProperty(spec.name)) {
-	    var found = mimeModes[spec.name]
-	    if (typeof found == "string") { found = {name: found} }
-	    spec = createObj(found, spec)
-	    spec.name = found.name
-	  } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+xml$/.test(spec)) {
-	    return resolveMode("application/xml")
-	  } else if (typeof spec == "string" && /^[\w\-]+\/[\w\-]+\+json$/.test(spec)) {
-	    return resolveMode("application/json")
-	  }
-	  if (typeof spec == "string") { return {name: spec} }
-	  else { return spec || {name: "null"} }
-	}
-
-	// Given a mode spec (anything that resolveMode accepts), find and
-	// initialize an actual mode object.
-	function getMode(options, spec) {
-	  spec = resolveMode(spec)
-	  var mfactory = modes[spec.name]
-	  if (!mfactory) { return getMode(options, "text/plain") }
-	  var modeObj = mfactory(options, spec)
-	  if (modeExtensions.hasOwnProperty(spec.name)) {
-	    var exts = modeExtensions[spec.name]
-	    for (var prop in exts) {
-	      if (!exts.hasOwnProperty(prop)) { continue }
-	      if (modeObj.hasOwnProperty(prop)) { modeObj["_" + prop] = modeObj[prop] }
-	      modeObj[prop] = exts[prop]
-	    }
-	  }
-	  modeObj.name = spec.name
-	  if (spec.helperType) { modeObj.helperType = spec.helperType }
-	  if (spec.modeProps) { for (var prop$1 in spec.modeProps)
-	    { modeObj[prop$1] = spec.modeProps[prop$1] } }
-
-	  return modeObj
-	}
-
-	// This can be used to attach properties to mode objects from
-	// outside the actual mode definition.
-	var modeExtensions = {}
-	function extendMode(mode, properties) {
-	  var exts = modeExtensions.hasOwnProperty(mode) ? modeExtensions[mode] : (modeExtensions[mode] = {})
-	  copyObj(properties, exts)
-	}
-
-	function copyState(mode, state) {
-	  if (state === true) { return state }
-	  if (mode.copyState) { return mode.copyState(state) }
-	  var nstate = {}
-	  for (var n in state) {
-	    var val = state[n]
-	    if (val instanceof Array) { val = val.concat([]) }
-	    nstate[n] = val
-	  }
-	  return nstate
-	}
-
-	// Given a mode and a state (for that mode), find the inner mode and
-	// state at the position that the state refers to.
-	function innerMode(mode, state) {
-	  var info
-	  while (mode.innerMode) {
-	    info = mode.innerMode(state)
-	    if (!info || info.mode == mode) { break }
-	    state = info.state
-	    mode = info.mode
-	  }
-	  return info || {mode: mode, state: state}
-	}
-
-	function startState(mode, a1, a2) {
-	  return mode.startState ? mode.startState(a1, a2) : true
-	}
-
-	// STRING STREAM
-
-	// Fed to the mode parsers, provides helper functions to make
-	// parsers more succinct.
-
-	var StringStream = function(string, tabSize) {
-	  this.pos = this.start = 0
-	  this.string = string
-	  this.tabSize = tabSize || 8
-	  this.lastColumnPos = this.lastColumnValue = 0
-	  this.lineStart = 0
-	}
-
-	StringStream.prototype = {
-	  eol: function() {return this.pos >= this.string.length},
-	  sol: function() {return this.pos == this.lineStart},
-	  peek: function() {return this.string.charAt(this.pos) || undefined},
-	  next: function() {
-	    if (this.pos < this.string.length)
-	      { return this.string.charAt(this.pos++) }
-	  },
-	  eat: function(match) {
-	    var ch = this.string.charAt(this.pos)
-	    var ok
-	    if (typeof match == "string") { ok = ch == match }
-	    else { ok = ch && (match.test ? match.test(ch) : match(ch)) }
-	    if (ok) {++this.pos; return ch}
-	  },
-	  eatWhile: function(match) {
-	    var start = this.pos
-	    while (this.eat(match)){}
-	    return this.pos > start
-	  },
-	  eatSpace: function() {
-	    var this$1 = this;
-
-	    var start = this.pos
-	    while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) { ++this$1.pos }
-	    return this.pos > start
-	  },
-	  skipToEnd: function() {this.pos = this.string.length},
-	  skipTo: function(ch) {
-	    var found = this.string.indexOf(ch, this.pos)
-	    if (found > -1) {this.pos = found; return true}
-	  },
-	  backUp: function(n) {this.pos -= n},
-	  column: function() {
-	    if (this.lastColumnPos < this.start) {
-	      this.lastColumnValue = countColumn(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue)
-	      this.lastColumnPos = this.start
-	    }
-	    return this.lastColumnValue - (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0)
-	  },
-	  indentation: function() {
-	    return countColumn(this.string, null, this.tabSize) -
-	      (this.lineStart ? countColumn(this.string, this.lineStart, this.tabSize) : 0)
-	  },
-	  match: function(pattern, consume, caseInsensitive) {
-	    if (typeof pattern == "string") {
-	      var cased = function (str) { return caseInsensitive ? str.toLowerCase() : str; }
-	      var substr = this.string.substr(this.pos, pattern.length)
-	      if (cased(substr) == cased(pattern)) {
-	        if (consume !== false) { this.pos += pattern.length }
-	        return true
-	      }
-	    } else {
-	      var match = this.string.slice(this.pos).match(pattern)
-	      if (match && match.index > 0) { return null }
-	      if (match && consume !== false) { this.pos += match[0].length }
-	      return match
-	    }
-	  },
-	  current: function(){return this.string.slice(this.start, this.pos)},
-	  hideFirstChars: function(n, inner) {
-	    this.lineStart += n
-	    try { return inner() }
-	    finally { this.lineStart -= n }
-	  }
-	}
-
-	// Compute a style array (an array starting with a mode generation
-	// -- for invalidation -- followed by pairs of end positions and
-	// style strings), which is used to highlight the tokens on the
-	// line.
-	function highlightLine(cm, line, state, forceToEnd) {
-	  // A styles array always starts with a number identifying the
-	  // mode/overlays that it is based on (for easy invalidation).
-	  var st = [cm.state.modeGen], lineClasses = {}
-	  // Compute the base array of styles
-	  runMode(cm, line.text, cm.doc.mode, state, function (end, style) { return st.push(end, style); },
-	    lineClasses, forceToEnd)
-
-	  // Run overlays, adjust style array.
-	  var loop = function ( o ) {
-	    var overlay = cm.state.overlays[o], i = 1, at = 0
-	    runMode(cm, line.text, overlay.mode, true, function (end, style) {
-	      var start = i
-	      // Ensure there's a token end at the current position, and that i points at it
-	      while (at < end) {
-	        var i_end = st[i]
-	        if (i_end > end)
-	          { st.splice(i, 1, end, st[i+1], i_end) }
-	        i += 2
-	        at = Math.min(end, i_end)
-	      }
-	      if (!style) { return }
-	      if (overlay.opaque) {
-	        st.splice(start, i - start, end, "overlay " + style)
-	        i = start + 2
-	      } else {
-	        for (; start < i; start += 2) {
-	          var cur = st[start+1]
-	          st[start+1] = (cur ? cur + " " : "") + "overlay " + style
-	        }
-	      }
-	    }, lineClasses)
-	  };
-
-	  for (var o = 0; o < cm.state.overlays.length; ++o) loop( o );
-
-	  return {styles: st, classes: lineClasses.bgClass || lineClasses.textClass ? lineClasses : null}
-	}
-
-	function getLineStyles(cm, line, updateFrontier) {
-	  if (!line.styles || line.styles[0] != cm.state.modeGen) {
-	    var state = getStateBefore(cm, lineNo(line))
-	    var result = highlightLine(cm, line, line.text.length > cm.options.maxHighlightLength ? copyState(cm.doc.mode, state) : state)
-	    line.stateAfter = state
-	    line.styles = result.styles
-	    if (result.classes) { line.styleClasses = result.classes }
-	    else if (line.styleClasses) { line.styleClasses = null }
-	    if (updateFrontier === cm.doc.frontier) { cm.doc.frontier++ }
-	  }
-	  return line.styles
-	}
-
-	function getStateBefore(cm, n, precise) {
-	  var doc = cm.doc, display = cm.display
-	  if (!doc.mode.startState) { return true }
-	  var pos = findStartLine(cm, n, precise), state = pos > doc.first && getLine(doc, pos-1).stateAfter
-	  if (!state) { state = startState(doc.mode) }
-	  else { state = copyState(doc.mode, state) }
-	  doc.iter(pos, n, function (line) {
-	    processLine(cm, line.text, state)
-	    var save = pos == n - 1 || pos % 5 == 0 || pos >= display.viewFrom && pos < display.viewTo
-	    line.stateAfter = save ? copyState(doc.mode, state) : null
-	    ++pos
-	  })
-	  if (precise) { doc.frontier = pos }
-	  return state
-	}
-
-	// Lightweight form of highlight -- proceed over this line and
-	// update state, but don't save a style array. Used for lines that
-	// aren't currently visible.
-	function processLine(cm, text, state, startAt) {
-	  var mode = cm.doc.mode
-	  var stream = new StringStream(text, cm.options.tabSize)
-	  stream.start = stream.pos = startAt || 0
-	  if (text == "") { callBlankLine(mode, state) }
-	  while (!stream.eol()) {
-	    readToken(mode, stream, state)
-	    stream.start = stream.pos
-	  }
-	}
-
-	function callBlankLine(mode, state) {
-	  if (mode.blankLine) { return mode.blankLine(state) }
-	  if (!mode.innerMode) { return }
-	  var inner = innerMode(mode, state)
-	  if (inner.mode.blankLine) { return inner.mode.blankLine(inner.state) }
-	}
-
-	function readToken(mode, stream, state, inner) {
-	  for (var i = 0; i < 10; i++) {
-	    if (inner) { inner[0] = innerMode(mode, state).mode }
-	    var style = mode.token(stream, state)
-	    if (stream.pos > stream.start) { return style }
-	  }
-	  throw new Error("Mode " + mode.name + " failed to advance stream.")
-	}
-
-	// Utility for getTokenAt and getLineTokens
-	function takeToken(cm, pos, precise, asArray) {
-	  var getObj = function (copy) { return ({
-	    start: stream.start, end: stream.pos,
-	    string: stream.current(),
-	    type: style || null,
-	    state: copy ? copyState(doc.mode, state) : state
-	  }); }
-
-	  var doc = cm.doc, mode = doc.mode, style
-	  pos = clipPos(doc, pos)
-	  var line = getLine(doc, pos.line), state = getStateBefore(cm, pos.line, precise)
-	  var stream = new StringStream(line.text, cm.options.tabSize), tokens
-	  if (asArray) { tokens = [] }
-	  while ((asArray || stream.pos < pos.ch) && !stream.eol()) {
-	    stream.start = stream.pos
-	    style = readToken(mode, stream, state)
-	    if (asArray) { tokens.push(getObj(true)) }
-	  }
-	  return asArray ? tokens : getObj()
-	}
-
-	function extractLineClasses(type, output) {
-	  if (type) { for (;;) {
-	    var lineClass = type.match(/(?:^|\s+)line-(background-)?(\S+)/)
-	    if (!lineClass) { break }
-	    type = type.slice(0, lineClass.index) + type.slice(lineClass.index + lineClass[0].length)
-	    var prop = lineClass[1] ? "bgClass" : "textClass"
-	    if (output[prop] == null)
-	      { output[prop] = lineClass[2] }
-	    else if (!(new RegExp("(?:^|\s)" + lineClass[2] + "(?:$|\s)")).test(output[prop]))
-	      { output[prop] += " " + lineClass[2] }
-	  } }
-	  return type
-	}
-
-	// Run the given mode's parser over a line, calling f for each token.
-	function runMode(cm, text, mode, state, f, lineClasses, forceToEnd) {
-	  var flattenSpans = mode.flattenSpans
-	  if (flattenSpans == null) { flattenSpans = cm.options.flattenSpans }
-	  var curStart = 0, curStyle = null
-	  var stream = new StringStream(text, cm.options.tabSize), style
-	  var inner = cm.options.addModeClass && [null]
-	  if (text == "") { extractLineClasses(callBlankLine(mode, state), lineClasses) }
-	  while (!stream.eol()) {
-	    if (stream.pos > cm.options.maxHighlightLength) {
-	      flattenSpans = false
-	      if (forceToEnd) { processLine(cm, text, state, stream.pos) }
-	      stream.pos = text.length
-	      style = null
-	    } else {
-	      style = extractLineClasses(readToken(mode, stream, state, inner), lineClasses)
-	    }
-	    if (inner) {
-	      var mName = inner[0].name
-	      if (mName) { style = "m-" + (style ? mName + " " + style : mName) }
-	    }
-	    if (!flattenSpans || curStyle != style) {
-	      while (curStart < stream.start) {
-	        curStart = Math.min(stream.start, curStart + 5000)
-	        f(curStart, curStyle)
-	      }
-	      curStyle = style
-	    }
-	    stream.start = stream.pos
-	  }
-	  while (curStart < stream.pos) {
-	    // Webkit seems to refuse to render text nodes longer than 57444
-	    // characters, and returns inaccurate measurements in nodes
-	    // starting around 5000 chars.
-	    var pos = Math.min(stream.pos, curStart + 5000)
-	    f(pos, curStyle)
-	    curStart = pos
-	  }
-	}
-
-	// Finds the line to start with when starting a parse. Tries to
-	// find a line with a stateAfter, so that it can start with a
-	// valid state. If that fails, it returns the line with the
-	// smallest indentation, which tends to need the least context to
-	// parse correctly.
-	function findStartLine(cm, n, precise) {
-	  var minindent, minline, doc = cm.doc
-	  var lim = precise ? -1 : n - (cm.doc.mode.innerMode ? 1000 : 100)
-	  for (var search = n; search > lim; --search) {
-	    if (search <= doc.first) { return doc.first }
-	    var line = getLine(doc, search - 1)
-	    if (line.stateAfter && (!precise || search <= doc.frontier)) { return search }
-	    var indented = countColumn(line.text, null, cm.options.tabSize)
-	    if (minline == null || minindent > indented) {
-	      minline = search - 1
-	      minindent = indented
-	    }
-	  }
-	  return minline
-	}
-
-	// LINE DATA STRUCTURE
-
-	// Line objects. These hold state related to a line, including
-	// highlighting info (the styles array).
-	function Line(text, markedSpans, estimateHeight) {
-	  this.text = text
-	  attachMarkedSpans(this, markedSpans)
-	  this.height = estimateHeight ? estimateHeight(this) : 1
-	}
-	eventMixin(Line)
-	Line.prototype.lineNo = function() { return lineNo(this) }
-
-	// Change the content (text, markers) of a line. Automatically
-	// invalidates cached information and tries to re-estimate the
-	// line's height.
-	function updateLine(line, text, markedSpans, estimateHeight) {
-	  line.text = text
-	  if (line.stateAfter) { line.stateAfter = null }
-	  if (line.styles) { line.styles = null }
-	  if (line.order != null) { line.order = null }
-	  detachMarkedSpans(line)
-	  attachMarkedSpans(line, markedSpans)
-	  var estHeight = estimateHeight ? estimateHeight(line) : 1
-	  if (estHeight != line.height) { updateLineHeight(line, estHeight) }
-	}
-
-	// Detach a line from the document tree and its markers.
-	function cleanUpLine(line) {
-	  line.parent = null
-	  detachMarkedSpans(line)
-	}
-
-	// Convert a style as returned by a mode (either null, or a string
-	// containing one or more styles) to a CSS style. This is cached,
-	// and also looks for line-wide styles.
-	var styleToClassCache = {};
-	var styleToClassCacheWithMode = {};
-	function interpretTokenStyle(style, options) {
-	  if (!style || /^\s*$/.test(style)) { return null }
-	  var cache = options.addModeClass ? styleToClassCacheWithMode : styleToClassCache
-	  return cache[style] ||
-	    (cache[style] = style.replace(/\S+/g, "cm-$&"))
-	}
-
-	// Render the DOM representation of the text of a line. Also builds
-	// up a 'line map', which points at the DOM nodes that represent
-	// specific stretches of text, and is used by the measuring code.
-	// The returned object contains the DOM node, this map, and
-	// information about line-wide styles that were set by the mode.
-	function buildLineContent(cm, lineView) {
-	  // The padding-right forces the element to have a 'border', which
-	  // is needed on Webkit to be able to get line-level bounding
-	  // rectangles for it (in measureChar).
-	  var content = elt("span", null, null, webkit ? "padding-right: .1px" : null)
-	  var builder = {pre: elt("pre", [content], "CodeMirror-line"), content: content,
-	                 col: 0, pos: 0, cm: cm,
-	                 trailingSpace: false,
-	                 splitSpaces: (ie || webkit) && cm.getOption("lineWrapping")}
-	  lineView.measure = {}
-
-	  // Iterate over the logical lines that make up this visual line.
-	  for (var i = 0; i <= (lineView.rest ? lineView.rest.length : 0); i++) {
-	    var line = i ? lineView.rest[i - 1] : lineView.line, order = (void 0)
-	    builder.pos = 0
-	    builder.addToken = buildToken
-	    // Optionally wire in some hacks into the token-rendering
-	    // algorithm, to deal with browser quirks.
-	    if (hasBadBidiRects(cm.display.measure) && (order = getOrder(line)))
-	      { builder.addToken = buildTokenBadBidi(builder.addToken, order) }
-	    builder.map = []
-	    var allowFrontierUpdate = lineView != cm.display.externalMeasured && lineNo(line)
-	    insertLineContent(line, builder, getLineStyles(cm, line, allowFrontierUpdate))
-	    if (line.styleClasses) {
-	      if (line.styleClasses.bgClass)
-	        { builder.bgClass = joinClasses(line.styleClasses.bgClass, builder.bgClass || "") }
-	      if (line.styleClasses.textClass)
-	        { builder.textClass = joinClasses(line.styleClasses.textClass, builder.textClass || "") }
-	    }
-
-	    // Ensure at least a single node is present, for measuring.
-	    if (builder.map.length == 0)
-	      { builder.map.push(0, 0, builder.content.appendChild(zeroWidthElement(cm.display.measure))) }
-
-	    // Store the map and a cache object for the current logical line
-	    if (i == 0) {
-	      lineView.measure.map = builder.map
-	      lineView.measure.cache = {}
-	    } else {
-	      ;(lineView.measure.maps || (lineView.measure.maps = [])).push(builder.map)
-	      ;(lineView.measure.caches || (lineView.measure.caches = [])).push({})
-	    }
-	  }
-
-	  // See issue #2901
-	  if (webkit) {
-	    var last = builder.content.lastChild
-	    if (/\bcm-tab\b/.test(last.className) || (last.querySelector && last.querySelector(".cm-tab")))
-	      { builder.content.className = "cm-tab-wrap-hack" }
-	  }
-
-	  signal(cm, "renderLine", cm, lineView.line, builder.pre)
-	  if (builder.pre.className)
-	    { builder.textClass = joinClasses(builder.pre.className, builder.textClass || "") }
-
-	  return builder
-	}
-
-	function defaultSpecialCharPlaceholder(ch) {
-	  var token = elt("span", "\u2022", "cm-invalidchar")
-	  token.title = "\\u" + ch.charCodeAt(0).toString(16)
-	  token.setAttribute("aria-label", token.title)
-	  return token
-	}
-
-	// Build up the DOM representation for a single token, and add it to
-	// the line map. Takes care to render special characters separately.
-	function buildToken(builder, text, style, startStyle, endStyle, title, css) {
-	  if (!text) { return }
-	  var displayText = builder.splitSpaces ? splitSpaces(text, builder.trailingSpace) : text
-	  var special = builder.cm.state.specialChars, mustWrap = false
-	  var content
-	  if (!special.test(text)) {
-	    builder.col += text.length
-	    content = document.createTextNode(displayText)
-	    builder.map.push(builder.pos, builder.pos + text.length, content)
-	    if (ie && ie_version < 9) { mustWrap = true }
-	    builder.pos += text.length
-	  } else {
-	    content = document.createDocumentFragment()
-	    var pos = 0
-	    while (true) {
-	      special.lastIndex = pos
-	      var m = special.exec(text)
-	      var skipped = m ? m.index - pos : text.length - pos
-	      if (skipped) {
-	        var txt = document.createTextNode(displayText.slice(pos, pos + skipped))
-	        if (ie && ie_version < 9) { content.appendChild(elt("span", [txt])) }
-	        else { content.appendChild(txt) }
-	        builder.map.push(builder.pos, builder.pos + skipped, txt)
-	        builder.col += skipped
-	        builder.pos += skipped
-	      }
-	      if (!m) { break }
-	      pos += skipped + 1
-	      var txt$1 = (void 0)
-	      if (m[0] == "\t") {
-	        var tabSize = builder.cm.options.tabSize, tabWidth = tabSize - builder.col % tabSize
-	        txt$1 = content.appendChild(elt("span", spaceStr(tabWidth), "cm-tab"))
-	        txt$1.setAttribute("role", "presentation")
-	        txt$1.setAttribute("cm-text", "\t")
-	        builder.col += tabWidth
-	      } else if (m[0] == "\r" || m[0] == "\n") {
-	        txt$1 = content.appendChild(elt("span", m[0] == "\r" ? "\u240d" : "\u2424", "cm-invalidchar"))
-	        txt$1.setAttribute("cm-text", m[0])
-	        builder.col += 1
-	      } else {
-	        txt$1 = builder.cm.options.specialCharPlaceholder(m[0])
-	        txt$1.setAttribute("cm-text", m[0])
-	        if (ie && ie_version < 9) { content.appendChild(elt("span", [txt$1])) }
-	        else { content.appendChild(txt$1) }
-	        builder.col += 1
-	      }
-	      builder.map.push(builder.pos, builder.pos + 1, txt$1)
-	      builder.pos++
-	    }
-	  }
-	  builder.trailingSpace = displayText.charCodeAt(text.length - 1) == 32
-	  if (style || startStyle || endStyle || mustWrap || css) {
-	    var fullStyle = style || ""
-	    if (startStyle) { fullStyle += startStyle }
-	    if (endStyle) { fullStyle += endStyle }
-	    var token = elt("span", [content], fullStyle, css)
-	    if (title) { token.title = title }
-	    return builder.content.appendChild(token)
-	  }
-	  builder.content.appendChild(content)
-	}
-
-	function splitSpaces(text, trailingBefore) {
-	  if (text.length > 1 && !/  /.test(text)) { return text }
-	  var spaceBefore = trailingBefore, result = ""
-	  for (var i = 0; i < text.length; i++) {
-	    var ch = text.charAt(i)
-	    if (ch == " " && spaceBefore && (i == text.length - 1 || text.charCodeAt(i + 1) == 32))
-	      { ch = "\u00a0" }
-	    result += ch
-	    spaceBefore = ch == " "
-	  }
-	  return result
-	}
-
-	// Work around nonsense dimensions being reported for stretches of
-	// right-to-left text.
-	function buildTokenBadBidi(inner, order) {
-	  return function (builder, text, style, startStyle, endStyle, title, css) {
-	    style = style ? style + " cm-force-border" : "cm-force-border"
-	    var start = builder.pos, end = start + text.length
-	    for (;;) {
-	      // Find the part that overlaps with the start of this text
-	      var part = (void 0)
-	      for (var i = 0; i < order.length; i++) {
-	        part = order[i]
-	        if (part.to > start && part.from <= start) { break }
-	      }
-	      if (part.to >= end) { return inner(builder, text, style, startStyle, endStyle, title, css) }
-	      inner(builder, text.slice(0, part.to - start), style, startStyle, null, title, css)
-	      startStyle = null
-	      text = text.slice(part.to - start)
-	      start = part.to
-	    }
-	  }
-	}
-
-	function buildCollapsedSpan(builder, size, marker, ignoreWidget) {
-	  var widget = !ignoreWidget && marker.widgetNode
-	  if (widget) { builder.map.push(builder.pos, builder.pos + size, widget) }
-	  if (!ignoreWidget && builder.cm.display.input.needsContentAttribute) {
-	    if (!widget)
-	      { widget = builder.content.appendChild(document.createElement("span")) }
-	    widget.setAttribute("cm-marker", marker.id)
-	  }
-	  if (widget) {
-	    builder.cm.display.input.setUneditable(widget)
-	    builder.content.appendChild(widget)
-	  }
-	  builder.pos += size
-	  builder.trailingSpace = false
-	}
-
-	// Outputs a number of spans to make up a line, taking highlighting
-	// and marked text into account.
-	function insertLineContent(line, builder, styles) {
-	  var spans = line.markedSpans, allText = line.text, at = 0
-	  if (!spans) {
-	    for (var i$1 = 1; i$1 < styles.length; i$1+=2)
-	      { builder.addToken(builder, allText.slice(at, at = styles[i$1]), interpretTokenStyle(styles[i$1+1], builder.cm.options)) }
-	    return
-	  }
-
-	  var len = allText.length, pos = 0, i = 1, text = "", style, css
-	  var nextChange = 0, spanStyle, spanEndStyle, spanStartStyle, title, collapsed
-	  for (;;) {
-	    if (nextChange == pos) { // Update current marker set
-	      spanStyle = spanEndStyle = spanStartStyle = title = css = ""
-	      collapsed = null; nextChange = Infinity
-	      var foundBookmarks = [], endStyles = (void 0)
-	      for (var j = 0; j < spans.length; ++j) {
-	        var sp = spans[j], m = sp.marker
-	        if (m.type == "bookmark" && sp.from == pos && m.widgetNode) {
-	          foundBookmarks.push(m)
-	        } else if (sp.from <= pos && (sp.to == null || sp.to > pos || m.collapsed && sp.to == pos && sp.from == pos)) {
-	          if (sp.to != null && sp.to != pos && nextChange > sp.to) {
-	            nextChange = sp.to
-	            spanEndStyle = ""
-	          }
-	          if (m.className) { spanStyle += " " + m.className }
-	          if (m.css) { css = (css ? css + ";" : "") + m.css }
-	          if (m.startStyle && sp.from == pos) { spanStartStyle += " " + m.startStyle }
-	          if (m.endStyle && sp.to == nextChange) { (endStyles || (endStyles = [])).push(m.endStyle, sp.to) }
-	          if (m.title && !title) { title = m.title }
-	          if (m.collapsed && (!collapsed || compareCollapsedMarkers(collapsed.marker, m) < 0))
-	            { collapsed = sp }
-	        } else if (sp.from > pos && nextChange > sp.from) {
-	          nextChange = sp.from
-	        }
-	      }
-	      if (endStyles) { for (var j$1 = 0; j$1 < endStyles.length; j$1 += 2)
-	        { if (endStyles[j$1 + 1] == nextChange) { spanEndStyle += " " + endStyles[j$1] } } }
-
-	      if (!collapsed || collapsed.from == pos) { for (var j$2 = 0; j$2 < foundBookmarks.length; ++j$2)
-	        { buildCollapsedSpan(builder, 0, foundBookmarks[j$2]) } }
-	      if (collapsed && (collapsed.from || 0) == pos) {
-	        buildCollapsedSpan(builder, (collapsed.to == null ? len + 1 : collapsed.to) - pos,
-	                           collapsed.marker, collapsed.from == null)
-	        if (collapsed.to == null) { return }
-	        if (collapsed.to == pos) { collapsed = false }
-	      }
-	    }
-	    if (pos >= len) { break }
-
-	    var upto = Math.min(len, nextChange)
-	    while (true) {
-	      if (text) {
-	        var end = pos + text.length
-	        if (!collapsed) {
-	          var tokenText = end > upto ? text.slice(0, upto - pos) : text
-	          builder.addToken(builder, tokenText, style ? style + spanStyle : spanStyle,
-	                           spanStartStyle, pos + tokenText.length == nextChange ? spanEndStyle : "", title, css)
-	        }
-	        if (end >= upto) {text = text.slice(upto - pos); pos = upto; break}
-	        pos = end
-	        spanStartStyle = ""
-	      }
-	      text = allText.slice(at, at = styles[i++])
-	      style = interpretTokenStyle(styles[i++], builder.cm.options)
-	    }
-	  }
-	}
-
-
-	// These objects are used to represent the visible (currently drawn)
-	// part of the document. A LineView may correspond to multiple
-	// logical lines, if those are connected by collapsed ranges.
-	function LineView(doc, line, lineN) {
-	  // The starting line
-	  this.line = line
-	  // Continuing lines, if any
-	  this.rest = visualLineContinued(line)
-	  // Number of logical lines in this visual line
-	  this.size = this.rest ? lineNo(lst(this.rest)) - lineN + 1 : 1
-	  this.node = this.text = null
-	  this.hidden = lineIsHidden(doc, line)
-	}
-
-	// Create a range of LineView objects for the given lines.
-	function buildViewArray(cm, from, to) {
-	  var array = [], nextPos
-	  for (var pos = from; pos < to; pos = nextPos) {
-	    var view = new LineView(cm.doc, getLine(cm.doc, pos), pos)
-	    nextPos = pos + view.size
-	    array.push(view)
-	  }
-	  return array
-	}
-
-	var operationGroup = null
-
-	function pushOperation(op) {
-	  if (operationGroup) {
-	    operationGroup.ops.push(op)
-	  } else {
-	    op.ownsGroup = operationGroup = {
-	      ops: [op],
-	      delayedCallbacks: []
-	    }
-	  }
-	}
-
-	function fireCallbacksForOps(group) {
-	  // Calls delayed callbacks and cursorActivity handlers until no
-	  // new ones appear
-	  var callbacks = group.delayedCallbacks, i = 0
-	  do {
-	    for (; i < callbacks.length; i++)
-	      { callbacks[i].call(null) }
-	    for (var j = 0; j < group.ops.length; j++) {
-	      var op = group.ops[j]
-	      if (op.cursorActivityHandlers)
-	        { while (op.cursorActivityCalled < op.cursorActivityHandlers.length)
-	          { op.cursorActivityHandlers[op.cursorActivityCalled++].call(null, op.cm) } }
-	    }
-	  } while (i < callbacks.length)
-	}
-
-	function finishOperation(op, endCb) {
-	  var group = op.ownsGroup
-	  if (!group) { return }
-
-	  try { fireCallbacksForOps(group) }
-	  finally {
-	    operationGroup = null
-	    endCb(group)
-	  }
-	}
-
-	var orphanDelayedCallbacks = null
-
-	// Often, we want to signal events at a point where we are in the
-	// middle of some work, but don't want the handler to start calling
-	// other methods on the editor, which might be in an inconsistent
-	// state or simply not expect any other events to happen.
-	// signalLater looks whether there are any handlers, and schedules
-	// them to be executed when the last operation ends, or, if no
-	// operation is active, when a timeout fires.
-	function signalLater(emitter, type /*, values...*/) {
-	  var arr = getHandlers(emitter, type)
-	  if (!arr.length) { return }
-	  var args = Array.prototype.slice.call(arguments, 2), list
-	  if (operationGroup) {
-	    list = operationGroup.delayedCallbacks
-	  } else if (orphanDelayedCallbacks) {
-	    list = orphanDelayedCallbacks
-	  } else {
-	    list = orphanDelayedCallbacks = []
-	    setTimeout(fireOrphanDelayed, 0)
-	  }
-	  var loop = function ( i ) {
-	    list.push(function () { return arr[i].apply(null, args); })
-	  };
-
-	  for (var i = 0; i < arr.length; ++i)
-	    loop( i );
-	}
-
-	function fireOrphanDelayed() {
-	  var delayed = orphanDelayedCallbacks
-	  orphanDelayedCallbacks = null
-	  for (var i = 0; i < delayed.length; ++i) { delayed[i]() }
-	}
-
-	// When an aspect of a line changes, a string is added to
-	// lineView.changes. This updates the relevant part of the line's
-	// DOM structure.
-	function updateLineForChanges(cm, lineView, lineN, dims) {
-	  for (var j = 0; j < lineView.changes.length; j++) {
-	    var type = lineView.changes[j]
-	    if (type == "text") { updateLineText(cm, lineView) }
-	    else if (type == "gutter") { updateLineGutter(cm, lineView, lineN, dims) }
-	    else if (type == "class") { updateLineClasses(lineView) }
-	    else if (type == "widget") { updateLineWidgets(cm, lineView, dims) }
-	  }
-	  lineView.changes = null
-	}
-
-	// Lines with gutter elements, widgets or a background class need to
-	// be wrapped, and have the extra elements added to the wrapper div
-	function ensureLineWrapped(lineView) {
-	  if (lineView.node == lineView.text) {
-	    lineView.node = elt("div", null, null, "position: relative")
-	    if (lineView.text.parentNode)
-	      { lineView.text.parentNode.replaceChild(lineView.node, lineView.text) }
-	    lineView.node.appendChild(lineView.text)
-	    if (ie && ie_version < 8) { lineView.node.style.zIndex = 2 }
-	  }
-	  return lineView.node
-	}
-
-	function updateLineBackground(lineView) {
-	  var cls = lineView.bgClass ? lineView.bgClass + " " + (lineView.line.bgClass || "") : lineView.line.bgClass
-	  if (cls) { cls += " CodeMirror-linebackground" }
-	  if (lineView.background) {
-	    if (cls) { lineView.background.className = cls }
-	    else { lineView.background.parentNode.removeChild(lineView.background); lineView.background = null }
-	  } else if (cls) {
-	    var wrap = ensureLineWrapped(lineView)
-	    lineView.background = wrap.insertBefore(elt("div", null, cls), wrap.firstChild)
-	  }
-	}
-
-	// Wrapper around buildLineContent which will reuse the structure
-	// in display.externalMeasured when possible.
-	function getLineContent(cm, lineView) {
-	  var ext = cm.display.externalMeasured
-	  if (ext && ext.line == lineView.line) {
-	    cm.display.externalMeasured = null
-	    lineView.measure = ext.measure
-	    return ext.built
-	  }
-	  return buildLineContent(cm, lineView)
-	}
-
-	// Redraw the line's text. Interacts with the background and text
-	// classes because the mode may output tokens that influence these
-	// classes.
-	function updateLineText(cm, lineView) {
-	  var cls = lineView.text.className
-	  var built = getLineContent(cm, lineView)
-	  if (lineView.text == lineView.node) { lineView.node = built.pre }
-	  lineView.text.parentNode.replaceChild(built.pre, lineView.text)
-	  lineView.text = built.pre
-	  if (built.bgClass != lineView.bgClass || built.textClass != lineView.textClass) {
-	    lineView.bgClass = built.bgClass
-	    lineView.textClass = built.textClass
-	    updateLineClasses(lineView)
-	  } else if (cls) {
-	    lineView.text.className = cls
-	  }
-	}
-
-	function updateLineClasses(lineView) {
-	  updateLineBackground(lineView)
-	  if (lineView.line.wrapClass)
-	    { ensureLineWrapped(lineView).className = lineView.line.wrapClass }
-	  else if (lineView.node != lineView.text)
-	    { lineView.node.className = "" }
-	  var textClass = lineView.textClass ? lineView.textClass + " " + (lineView.line.textClass || "") : lineView.line.textClass
-	  lineView.text.className = textClass || ""
-	}
-
-	function updateLineGutter(cm, lineView, lineN, dims) {
-	  if (lineView.gutter) {
-	    lineView.node.removeChild(lineView.gutter)
-	    lineView.gutter = null
-	  }
-	  if (lineView.gutterBackground) {
-	    lineView.node.removeChild(lineView.gutterBackground)
-	    lineView.gutterBackground = null
-	  }
-	  if (lineView.line.gutterClass) {
-	    var wrap = ensureLineWrapped(lineView)
-	    lineView.gutterBackground = elt("div", null, "CodeMirror-gutter-background " + lineView.line.gutterClass,
-	                                    ("left: " + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + "px; width: " + (dims.gutterTotalWidth) + "px"))
-	    wrap.insertBefore(lineView.gutterBackground, lineView.text)
-	  }
-	  var markers = lineView.line.gutterMarkers
-	  if (cm.options.lineNumbers || markers) {
-	    var wrap$1 = ensureLineWrapped(lineView)
-	    var gutterWrap = lineView.gutter = elt("div", null, "CodeMirror-gutter-wrapper", ("left: " + (cm.options.fixedGutter ? dims.fixedPos : -dims.gutterTotalWidth) + "px"))
-	    cm.display.input.setUneditable(gutterWrap)
-	    wrap$1.insertBefore(gutterWrap, lineView.text)
-	    if (lineView.line.gutterClass)
-	      { gutterWrap.className += " " + lineView.line.gutterClass }
-	    if (cm.options.lineNumbers && (!markers || !markers["CodeMirror-linenumbers"]))
-	      { lineView.lineNumber = gutterWrap.appendChild(
-	        elt("div", lineNumberFor(cm.options, lineN),
-	            "CodeMirror-linenumber CodeMirror-gutter-elt",
-	            ("left: " + (dims.gutterLeft["CodeMirror-linenumbers"]) + "px; width: " + (cm.display.lineNumInnerWidth) + "px"))) }
-	    if (markers) { for (var k = 0; k < cm.options.gutters.length; ++k) {
-	      var id = cm.options.gutters[k], found = markers.hasOwnProperty(id) && markers[id]
-	      if (found)
-	        { gutterWrap.appendChild(elt("div", [found], "CodeMirror-gutter-elt",
-	                                   ("left: " + (dims.gutterLeft[id]) + "px; width: " + (dims.gutterWidth[id]) + "px"))) }
-	    } }
-	  }
-	}
-
-	function updateLineWidgets(cm, lineView, dims) {
-	  if (lineView.alignable) { lineView.alignable = null }
-	  for (var node = lineView.node.firstChild, next = (void 0); node; node = next) {
-	    next = node.nextSibling
-	    if (node.className == "CodeMirror-linewidget")
-	      { lineView.node.removeChild(node) }
-	  }
-	  insertLineWidgets(cm, lineView, dims)
-	}
-
-	// Build a line's DOM representation from scratch
-	function buildLineElement(cm, lineView, lineN, dims) {
-	  var built = getLineContent(cm, lineView)
-	  lineView.text = lineView.node = built.pre
-	  if (built.bgClass) { lineView.bgClass = built.bgClass }
-	  if (built.textClass) { lineView.textClass = built.textClass }
-
-	  updateLineClasses(lineView)
-	  updateLineGutter(cm, lineView, lineN, dims)
-	  insertLineWidgets(cm, lineView, dims)
-	  return lineView.node
-	}
-
-	// A lineView may contain multiple logical lines (when merged by
-	// collapsed spans). The widgets for all of them need to be drawn.
-	function insertLineWidgets(cm, lineView, dims) {
-	  insertLineWidgetsFor(cm, lineView.line, lineView, dims, true)
-	  if (lineView.rest) { for (var i = 0; i < lineView.rest.length; i++)
-	    { insertLineWidgetsFor(cm, lineView.rest[i], lineView, dims, false) } }
-	}
-
-	function insertLineWidgetsFor(cm, line, lineView, dims, allowAbove) {
-	  if (!line.widgets) { return }
-	  var wrap = ensureLineWrapped(lineView)
-	  for (var i = 0, ws = line.widgets; i < ws.length; ++i) {
-	    var widget = ws[i], node = elt("div", [widget.node], "CodeMirror-linewidget")
-	    if (!widget.handleMouseEvents) { node.setAttribute("cm-ignore-events", "true") }
-	    positionLineWidget(widget, node, lineView, dims)
-	    cm.display.input.setUneditable(node)
-	    if (allowAbove && widget.above)
-	      { wrap.insertBefore(node, lineView.gutter || lineView.text) }
-	    else
-	      { wrap.appendChild(node) }
-	    signalLater(widget, "redraw")
-	  }
-	}
-
-	function positionLineWidget(widget, node, lineView, dims) {
-	  if (widget.noHScroll) {
-	    ;(lineView.alignable || (lineView.alignable = [])).push(node)
-	    var width = dims.wrapperWidth
-	    node.style.left = dims.fixedPos + "px"
-	    if (!widget.coverGutter) {
-	      width -= dims.gutterTotalWidth
-	      node.style.paddingLeft = dims.gutterTotalWidth + "px"
-	    }
-	    node.style.width = width + "px"
-	  }
-	  if (widget.coverGutter) {
-	    node.style.zIndex = 5
-	    node.style.position = "relative"
-	    if (!widget.noHScroll) { node.style.marginLeft = -dims.gutterTotalWidth + "px" }
-	  }
-	}
-
-	function widgetHeight(widget) {
-	  if (widget.height != null) { return widget.height }
-	  var cm = widget.doc.cm
-	  if (!cm) { return 0 }
-	  if (!contains(document.body, widget.node)) {
-	    var parentStyle = "position: relative;"
-	    if (widget.coverGutter)
-	      { parentStyle += "margin-left: -" + cm.display.gutters.offsetWidth + "px;" }
-	    if (widget.noHScroll)
-	      { parentStyle += "width: " + cm.display.wrapper.clientWidth + "px;" }
-	    removeChildrenAndAdd(cm.display.measure, elt("div", [widget.node], null, parentStyle))
-	  }
-	  return widget.height = widget.node.parentNode.offsetHeight
-	}
-
-	// Return true when the given mouse event happened in a widget
-	function eventInWidget(display, e) {
-	  for (var n = e_target(e); n != display.wrapper; n = n.parentNode) {
-	    if (!n || (n.nodeType == 1 && n.getAttribute("cm-ignore-events") == "true") ||
-	        (n.parentNode == display.sizer && n != display.mover))
-	      { return true }
-	  }
-	}
-
-	// POSITION MEASUREMENT
-
-	function paddingTop(display) {return display.lineSpace.offsetTop}
-	function paddingVert(display) {return display.mover.offsetHeight - display.lineSpace.offsetHeight}
-	function paddingH(display) {
-	  if (display.cachedPaddingH) { return display.cachedPaddingH }
-	  var e = removeChildrenAndAdd(display.measure, elt("pre", "x"))
-	  var style = window.getComputedStyle ? window.getComputedStyle(e) : e.currentStyle
-	  var data = {left: parseInt(style.paddingLeft), right: parseInt(style.paddingRight)}
-	  if (!isNaN(data.left) && !isNaN(data.right)) { display.cachedPaddingH = data }
-	  return data
-	}
-
-	function scrollGap(cm) { return scrollerGap - cm.display.nativeBarWidth }
-	function displayWidth(cm) {
-	  return cm.display.scroller.clientWidth - scrollGap(cm) - cm.display.barWidth
-	}
-	function displayHeight(cm) {
-	  return cm.display.scroller.clientHeight - scrollGap(cm) - cm.display.barHeight
-	}
-
-	// Ensure the lineView.wrapping.heights array is populated. This is
-	// an array of bottom offsets for the lines that make up a drawn
-	// line. When lineWrapping is on, there might be more than one
-	// height.
-	function ensureLineHeights(cm, lineView, rect) {
-	  var wrapping = cm.options.lineWrapping
-	  var curWidth = wrapping && displayWidth(cm)
-	  if (!lineView.measure.heights || wrapping && lineView.measure.width != curWidth) {
-	    var heights = lineView.measure.heights = []
-	    if (wrapping) {
-	      lineView.measure.width = curWidth
-	      var rects = lineView.text.firstChild.getClientRects()
-	      for (var i = 0; i < rects.length - 1; i++) {
-	        var cur = rects[i], next = rects[i + 1]
-	        if (Math.abs(cur.bottom - next.bottom) > 2)
-	          { heights.push((cur.bottom + next.top) / 2 - rect.top) }
-	      }
-	    }
-	    heights.push(rect.bottom - rect.top)
-	  }
-	}
-
-	// Find a line map (mapping character offsets to text nodes) and a
-	// measurement cache for the given line number. (A line view might
-	// contain multiple lines when collapsed ranges are present.)
-	function mapFromLineView(lineView, line, lineN) {
-	  if (lineView.line == line)
-	    { return {map: lineView.measure.map, cache: lineView.measure.cache} }
-	  for (var i = 0; i < lineView.rest.length; i++)
-	    { if (lineView.rest[i] == line)
-	      { return {map: lineView.measure.maps[i], cache: lineView.measure.caches[i]} } }
-	  for (var i$1 = 0; i$1 < lineView.rest.length; i$1++)
-	    { if (lineNo(lineView.rest[i$1]) > lineN)
-	      { return {map: lineView.measure.maps[i$1], cache: lineView.measure.caches[i$1], before: true} } }
-	}
-
-	// Render a line into the hidden node display.externalMeasured. Used
-	// when measurement is needed for a line that's not in the viewport.
-	function updateExternalMeasurement(cm, line) {
-	  line = visualLine(line)
-	  var lineN = lineNo(line)
-	  var view = cm.display.externalMeasured = new LineView(cm.doc, line, lineN)
-	  view.lineN = lineN
-	  var built = view.built = buildLineContent(cm, view)
-	  view.text = built.pre
-	  removeChildrenAndAdd(cm.display.lineMeasure, built.pre)
-	  return view
-	}
-
-	// Get a {top, bottom, left, right} box (in line-local coordinates)
-	// for a given character.
-	function measureChar(cm, line, ch, bias) {
-	  return measureCharPrepared(cm, prepareMeasureForLine(cm, line), ch, bias)
-	}
-
-	// Find a line view that corresponds to the given line number.
-	function findViewForLine(cm, lineN) {
-	  if (lineN >= cm.display.viewFrom && lineN < cm.display.viewTo)
-	    { return cm.display.view[findViewIndex(cm, lineN)] }
-	  var ext = cm.display.externalMeasured
-	  if (ext && lineN >= ext.lineN && lineN < ext.lineN + ext.size)
-	    { return ext }
-	}
-
-	// Measurement can be split in two steps, the set-up work that
-	// applies to the whole line, and the measurement of the actual
-	// character. Functions like coordsChar, that need to do a lot of
-	// measurements in a row, can thus ensure that the set-up work is
-	// only done once.
-	function prepareMeasureForLine(cm, line) {
-	  var lineN = lineNo(line)
-	  var view = findViewForLine(cm, lineN)
-	  if (view && !view.text) {
-	    view = null
-	  } else if (view && view.changes) {
-	    updateLineForChanges(cm, view, lineN, getDimensions(cm))
-	    cm.curOp.forceUpdate = true
-	  }
-	  if (!view)
-	    { view = updateExternalMeasurement(cm, line) }
-
-	  var info = mapFromLineView(view, line, lineN)
-	  return {
-	    line: line, view: view, rect: null,
-	    map: info.map, cache: info.cache, before: info.before,
-	    hasHeights: false
-	  }
-	}
-
-	// Given a prepared measurement object, measures the position of an
-	// actual character (or fetches it from the cache).
-	function measureCharPrepared(cm, prepared, ch, bias, varHeight) {
-	  if (prepared.before) { ch = -1 }
-	  var key = ch + (bias || ""), found
-	  if (prepared.cache.hasOwnProperty(key)) {
-	    found = prepared.cache[key]
-	  } else {
-	    if (!prepared.rect)
-	      { prepared.rect = prepared.view.text.getBoundingClientRect() }
-	    if (!prepared.hasHeights) {
-	      ensureLineHeights(cm, prepared.view, prepared.rect)
-	      prepared.hasHeights = true
-	    }
-	    found = measureCharInner(cm, prepared, ch, bias)
-	    if (!found.bogus) { prepared.cache[key] = found }
-	  }
-	  return {left: found.left, right: found.right,
-	          top: varHeight ? found.rtop : found.top,
-	          bottom: varHeight ? found.rbottom : found.bottom}
-	}
-
-	var nullRect = {left: 0, right: 0, top: 0, bottom: 0}
-
-	function nodeAndOffsetInLineMap(map, ch, bias) {
-	  var node, start, end, collapse, mStart, mEnd
-	  // First, search the line map for the text node corresponding to,
-	  // or closest to, the target character.
-	  for (var i = 0; i < map.length; i += 3) {
-	    mStart = map[i]
-	    mEnd = map[i + 1]
-	    if (ch < mStart) {
-	      start = 0; end = 1
-	      collapse = "left"
-	    } else if (ch < mEnd) {
-	      start = ch - mStart
-	      end = start + 1
-	    } else if (i == map.length - 3 || ch == mEnd && map[i + 3] > ch) {
-	      end = mEnd - mStart
-	      start = end - 1
-	      if (ch >= mEnd) { collapse = "right" }
-	    }
-	    if (start != null) {
-	      node = map[i + 2]
-	      if (mStart == mEnd && bias == (node.insertLeft ? "left" : "right"))
-	        { collapse = bias }
-	      if (bias == "left" && start == 0)
-	        { while (i && map[i - 2] == map[i - 3] && map[i - 1].insertLeft) {
-	          node = map[(i -= 3) + 2]
-	          collapse = "left"
-	        } }
-	      if (bias == "right" && start == mEnd - mStart)
-	        { while (i < map.length - 3 && map[i + 3] == map[i + 4] && !map[i + 5].insertLeft) {
-	          node = map[(i += 3) + 2]
-	          collapse = "right"
-	        } }
-	      break
-	    }
-	  }
-	  return {node: node, start: start, end: end, collapse: collapse, coverStart: mStart, coverEnd: mEnd}
-	}
-
-	function getUsefulRect(rects, bias) {
-	  var rect = nullRect
-	  if (bias == "left") { for (var i = 0; i < rects.length; i++) {
-	    if ((rect = rects[i]).left != rect.right) { break }
-	  } } else { for (var i$1 = rects.length - 1; i$1 >= 0; i$1--) {
-	    if ((rect = rects[i$1]).left != rect.right) { break }
-	  } }
-	  return rect
-	}
-
-	function measureCharInner(cm, prepared, ch, bias) {
-	  var place = nodeAndOffsetInLineMap(prepared.map, ch, bias)
-	  var node = place.node, start = place.start, end = place.end, collapse = place.collapse
-
-	  var rect
-	  if (node.nodeType == 3) { // If it is a text node, use a range to retrieve the coordinates.
-	    for (var i$1 = 0; i$1 < 4; i$1++) { // Retry a maximum of 4 times when nonsense rectangles are returned
-	      while (start && isExtendingChar(prepared.line.text.charAt(place.coverStart + start))) { --start }
-	      while (place.coverStart + end < place.coverEnd && isExtendingChar(prepared.line.text.charAt(place.coverStart + end))) { ++end }
-	      if (ie && ie_version < 9 && start == 0 && end == place.coverEnd - place.coverStart)
-	        { rect = node.parentNode.getBoundingClientRect() }
-	      else
-	        { rect = getUsefulRect(range(node, start, end).getClientRects(), bias) }
-	      if (rect.left || rect.right || start == 0) { break }
-	      end = start
-	      start = start - 1
-	      collapse = "right"
-	    }
-	    if (ie && ie_version < 11) { rect = maybeUpdateRectForZooming(cm.display.measure, rect) }
-	  } else { // If it is a widget, simply get the box for the whole widget.
-	    if (start > 0) { collapse = bias = "right" }
-	    var rects
-	    if (cm.options.lineWrapping && (rects = node.getClientRects()).length > 1)
-	      { rect = rects[bias == "right" ? rects.length - 1 : 0] }
-	    else
-	      { rect = node.getBoundingClientRect() }
-	  }
-	  if (ie && ie_version < 9 && !start && (!rect || !rect.left && !rect.right)) {
-	    var rSpan = node.parentNode.getClientRects()[0]
-	    if (rSpan)
-	      { rect = {left: rSpan.left, right: rSpan.left + charWidth(cm.display), top: rSpan.top, bottom: rSpan.bottom} }
-	    else
-	      { rect = nullRect }
-	  }
-
-	  var rtop = rect.top - prepared.rect.top, rbot = rect.bottom - prepared.rect.top
-	  var mid = (rtop + rbot) / 2
-	  var heights = prepared.view.measure.heights
-	  var i = 0
-	  for (; i < heights.length - 1; i++)
-	    { if (mid < heights[i]) { break } }
-	  var top = i ? heights[i - 1] : 0, bot = heights[i]
-	  var result = {left: (collapse == "right" ? rect.right : rect.left) - prepared.rect.left,
-	                right: (collapse == "left" ? rect.left : rect.right) - prepared.rect.left,
-	                top: top, bottom: bot}
-	  if (!rect.left && !rect.right) { result.bogus = true }
-	  if (!cm.options.singleCursorHeightPerLine) { result.rtop = rtop; result.rbottom = rbot }
-
-	  return result
-	}
-
-	// Work around problem with bounding client rects on ranges being
-	// returned incorrectly when zoomed on IE10 and below.
-	function maybeUpdateRectForZooming(measure, rect) {
-	  if (!window.screen || screen.logicalXDPI == null ||
-	      screen.logicalXDPI == screen.deviceXDPI || !hasBadZoomedRects(measure))
-	    { return rect }
-	  var scaleX = screen.logicalXDPI / screen.deviceXDPI
-	  var scaleY = screen.logicalYDPI / screen.deviceYDPI
-	  return {left: rect.left * scaleX, right: rect.right * scaleX,
-	          top: rect.top * scaleY, bottom: rect.bottom * scaleY}
-	}
-
-	function clearLineMeasurementCacheFor(lineView) {
-	  if (lineView.measure) {
-	    lineView.measure.cache = {}
-	    lineView.measure.heights = null
-	    if (lineView.rest) { for (var i = 0; i < lineView.rest.length; i++)
-	      { lineView.measure.caches[i] = {} } }
-	  }
-	}
-
-	function clearLineMeasurementCache(cm) {
-	  cm.display.externalMeasure = null
-	  removeChildren(cm.display.lineMeasure)
-	  for (var i = 0; i < cm.display.view.length; i++)
-	    { clearLineMeasurementCacheFor(cm.display.view[i]) }
-	}
-
-	function clearCaches(cm) {
-	  clearLineMeasurementCache(cm)
-	  cm.display.cachedCharWidth = cm.display.cachedTextHeight = cm.display.cachedPaddingH = null
-	  if (!cm.options.lineWrapping) { cm.display.maxLineChanged = true }
-	  cm.display.lineNumChars = null
-	}
-
-	function pageScrollX() { return window.pageXOffset || (document.documentElement || document.body).scrollLeft }
-	function pageScrollY() { return window.pageYOffset || (document.documentElement || document.body).scrollTop }
-
-	// Converts a {top, bottom, left, right} box from line-local
-	// coordinates into another coordinate system. Context may be one of
-	// "line", "div" (display.lineDiv), "local"./null (editor), "window",
-	// or "page".
-	function intoCoordSystem(cm, lineObj, rect, context, includeWidgets) {
-	  if (!includeWidgets && lineObj.widgets) { for (var i = 0; i < lineObj.widgets.length; ++i) { if (lineObj.widgets[i].above) {
-	    var size = widgetHeight(lineObj.widgets[i])
-	    rect.top += size; rect.bottom += size
-	  } } }
-	  if (context == "line") { return rect }
-	  if (!context) { context = "local" }
-	  var yOff = heightAtLine(lineObj)
-	  if (context == "local") { yOff += paddingTop(cm.display) }
-	  else { yOff -= cm.display.viewOffset }
-	  if (context == "page" || context == "window") {
-	    var lOff = cm.display.lineSpace.getBoundingClientRect()
-	    yOff += lOff.top + (context == "window" ? 0 : pageScrollY())
-	    var xOff = lOff.left + (context == "window" ? 0 : pageScrollX())
-	    rect.left += xOff; rect.right += xOff
-	  }
-	  rect.top += yOff; rect.bottom += yOff
-	  return rect
-	}
-
-	// Coverts a box from "div" coords to another coordinate system.
-	// Context may be "window", "page", "div", or "local"./null.
-	function fromCoordSystem(cm, coords, context) {
-	  if (context == "div") { return coords }
-	  var left = coords.left, top = coords.top
-	  // First move into "page" coordinate system
-	  if (context == "page") {
-	    left -= pageScrollX()
-	    top -= pageScrollY()
-	  } else if (context == "local" || !context) {
-	    var localBox = cm.display.sizer.getBoundingClientRect()
-	    left += localBox.left
-	    top += localBox.top
-	  }
-
-	  var lineSpaceBox = cm.display.lineSpace.getBoundingClientRect()
-	  return {left: left - lineSpaceBox.left, top: top - lineSpaceBox.top}
-	}
-
-	function charCoords(cm, pos, context, lineObj, bias) {
-	  if (!lineObj) { lineObj = getLine(cm.doc, pos.line) }
-	  return intoCoordSystem(cm, lineObj, measureChar(cm, lineObj, pos.ch, bias), context)
-	}
-
-	// Returns a box for a given cursor position, which may have an
-	// 'other' property containing the position of the secondary cursor
-	// on a bidi boundary.
-	function cursorCoords(cm, pos, context, lineObj, preparedMeasure, varHeight) {
-	  lineObj = lineObj || getLine(cm.doc, pos.line)
-	  if (!preparedMeasure) { preparedMeasure = prepareMeasureForLine(cm, lineObj) }
-	  function get(ch, right) {
-	    var m = measureCharPrepared(cm, preparedMeasure, ch, right ? "right" : "left", varHeight)
-	    if (right) { m.left = m.right; } else { m.right = m.left }
-	    return intoCoordSystem(cm, lineObj, m, context)
-	  }
-	  function getBidi(ch, partPos) {
-	    var part = order[partPos], right = part.level % 2
-	    if (ch == bidiLeft(part) && partPos && part.level < order[partPos - 1].level) {
-	      part = order[--partPos]
-	      ch = bidiRight(part) - (part.level % 2 ? 0 : 1)
-	      right = true
-	    } else if (ch == bidiRight(part) && partPos < order.length - 1 && part.level < order[partPos + 1].level) {
-	      part = order[++partPos]
-	      ch = bidiLeft(part) - part.level % 2
-	      right = false
-	    }
-	    if (right && ch == part.to && ch > part.from) { return get(ch - 1) }
-	    return get(ch, right)
-	  }
-	  var order = getOrder(lineObj), ch = pos.ch
-	  if (!order) { return get(ch) }
-	  var partPos = getBidiPartAt(order, ch)
-	  var val = getBidi(ch, partPos)
-	  if (bidiOther != null) { val.other = getBidi(ch, bidiOther) }
-	  return val
-	}
-
-	// Used to cheaply estimate the coordinates for a position. Used for
-	// intermediate scroll updates.
-	function estimateCoords(cm, pos) {
-	  var left = 0
-	  pos = clipPos(cm.doc, pos)
-	  if (!cm.options.lineWrapping) { left = charWidth(cm.display) * pos.ch }
-	  var lineObj = getLine(cm.doc, pos.line)
-	  var top = heightAtLine(lineObj) + paddingTop(cm.display)
-	  return {left: left, right: left, top: top, bottom: top + lineObj.height}
-	}
-
-	// Positions returned by coordsChar contain some extra information.
-	// xRel is the relative x position of the input coordinates compared
-	// to the found position (so xRel > 0 means the coordinates are to
-	// the right of the character position, for example). When outside
-	// is true, that means the coordinates lie outside the line's
-	// vertical range.
-	function PosWithInfo(line, ch, outside, xRel) {
-	  var pos = Pos(line, ch)
-	  pos.xRel = xRel
-	  if (outside) { pos.outside = true }
-	  return pos
-	}
-
-	// Compute the character position closest to the given coordinates.
-	// Input must be lineSpace-local ("div" coordinate system).
-	function coordsChar(cm, x, y) {
-	  var doc = cm.doc
-	  y += cm.display.viewOffset
-	  if (y < 0) { return PosWithInfo(doc.first, 0, true, -1) }
-	  var lineN = lineAtHeight(doc, y), last = doc.first + doc.size - 1
-	  if (lineN > last)
-	    { return PosWithInfo(doc.first + doc.size - 1, getLine(doc, last).text.length, true, 1) }
-	  if (x < 0) { x = 0 }
-
-	  var lineObj = getLine(doc, lineN)
-	  for (;;) {
-	    var found = coordsCharInner(cm, lineObj, lineN, x, y)
-	    var merged = collapsedSpanAtEnd(lineObj)
-	    var mergedPos = merged && merged.find(0, true)
-	    if (merged && (found.ch > mergedPos.from.ch || found.ch == mergedPos.from.ch && found.xRel > 0))
-	      { lineN = lineNo(lineObj = mergedPos.to.line) }
-	    else
-	      { return found }
-	  }
-	}
-
-	function coordsCharInner(cm, lineObj, lineNo, x, y) {
-	  var innerOff = y - heightAtLine(lineObj)
-	  var wrongLine = false, adjust = 2 * cm.display.wrapper.clientWidth
-	  var preparedMeasure = prepareMeasureForLine(cm, lineObj)
-
-	  function getX(ch) {
-	    var sp = cursorCoords(cm, Pos(lineNo, ch), "line", lineObj, preparedMeasure)
-	    wrongLine = true
-	    if (innerOff > sp.bottom) { return sp.left - adjust }
-	    else if (innerOff < sp.top) { return sp.left + adjust }
-	    else { wrongLine = false }
-	    return sp.left
-	  }
-
-	  var bidi = getOrder(lineObj), dist = lineObj.text.length
-	  var from = lineLeft(lineObj), to = lineRight(lineObj)
-	  var fromX = getX(from), fromOutside = wrongLine, toX = getX(to), toOutside = wrongLine
-
-	  if (x > toX) { return PosWithInfo(lineNo, to, toOutside, 1) }
-	  // Do a binary search between these bounds.
-	  for (;;) {
-	    if (bidi ? to == from || to == moveVisually(lineObj, from, 1) : to - from <= 1) {
-	      var ch = x < fromX || x - fromX <= toX - x ? from : to
-	      var outside = ch == from ? fromOutside : toOutside
-	      var xDiff = x - (ch == from ? fromX : toX)
-	      // This is a kludge to handle the case where the coordinates
-	      // are after a line-wrapped line. We should replace it with a
-	      // more general handling of cursor positions around line
-	      // breaks. (Issue #4078)
-	      if (toOutside && !bidi && !/\s/.test(lineObj.text.charAt(ch)) && xDiff > 0 &&
-	          ch < lineObj.text.length && preparedMeasure.view.measure.heights.length > 1) {
-	        var charSize = measureCharPrepared(cm, preparedMeasure, ch, "right")
-	        if (innerOff <= charSize.bottom && innerOff >= charSize.top && Math.abs(x - charSize.right) < xDiff) {
-	          outside = false
-	          ch++
-	          xDiff = x - charSize.right
-	        }
-	      }
-	      while (isExtendingChar(lineObj.text.charAt(ch))) { ++ch }
-	      var pos = PosWithInfo(lineNo, ch, outside, xDiff < -1 ? -1 : xDiff > 1 ? 1 : 0)
-	      return pos
-	    }
-	    var step = Math.ceil(dist / 2), middle = from + step
-	    if (bidi) {
-	      middle = from
-	      for (var i = 0; i < step; ++i) { middle = moveVisually(lineObj, middle, 1) }
-	    }
-	    var middleX = getX(middle)
-	    if (middleX > x) {to = middle; toX = middleX; if (toOutside = wrongLine) { toX += 1000; } dist = step}
-	    else {from = middle; fromX = middleX; fromOutside = wrongLine; dist -= step}
-	  }
-	}
-
-	var measureText
-	// Compute the default text height.
-	function textHeight(display) {
-	  if (display.cachedTextHeight != null) { return display.cachedTextHeight }
-	  if (measureText == null) {
-	    measureText = elt("pre")
-	    // Measure a bunch of lines, for browsers that compute
-	    // fractional heights.
-	    for (var i = 0; i < 49; ++i) {
-	      measureText.appendChild(document.createTextNode("x"))
-	      measureText.appendChild(elt("br"))
-	    }
-	    measureText.appendChild(document.createTextNode("x"))
-	  }
-	  removeChildrenAndAdd(display.measure, measureText)
-	  var height = measureText.offsetHeight / 50
-	  if (height > 3) { display.cachedTextHeight = height }
-	  removeChildren(display.measure)
-	  return height || 1
-	}
-
-	// Compute the default character width.
-	function charWidth(display) {
-	  if (display.cachedCharWidth != null) { return display.cachedCharWidth }
-	  var anchor = elt("span", "xxxxxxxxxx")
-	  var pre = elt("pre", [anchor])
-	  removeChildrenAndAdd(display.measure, pre)
-	  var rect = anchor.getBoundingClientRect(), width = (rect.right - rect.left) / 10
-	  if (width > 2) { display.cachedCharWidth = width }
-	  return width || 10
-	}
-
-	// Do a bulk-read of the DOM positions and sizes needed to draw the
-	// view, so that we don't interleave reading and writing to the DOM.
-	function getDimensions(cm) {
-	  var d = cm.display, left = {}, width = {}
-	  var gutterLeft = d.gutters.clientLeft
-	  for (var n = d.gutters.firstChild, i = 0; n; n = n.nextSibling, ++i) {
-	    left[cm.options.gutters[i]] = n.offsetLeft + n.clientLeft + gutterLeft
-	    width[cm.options.gutters[i]] = n.clientWidth
-	  }
-	  return {fixedPos: compensateForHScroll(d),
-	          gutterTotalWidth: d.gutters.offsetWidth,
-	          gutterLeft: left,
-	          gutterWidth: width,
-	          wrapperWidth: d.wrapper.clientWidth}
-	}
-
-	// Computes display.scroller.scrollLeft + display.gutters.offsetWidth,
-	// but using getBoundingClientRect to get a sub-pixel-accurate
-	// result.
-	function compensateForHScroll(display) {
-	  return display.scroller.getBoundingClientRect().left - display.sizer.getBoundingClientRect().left
-	}
-
-	// Returns a function that estimates the height of a line, to use as
-	// first approximation until the line becomes visible (and is thus
-	// properly measurable).
-	function estimateHeight(cm) {
-	  var th = textHeight(cm.display), wrapping = cm.options.lineWrapping
-	  var perLine = wrapping && Math.max(5, cm.display.scroller.clientWidth / charWidth(cm.display) - 3)
-	  return function (line) {
-	    if (lineIsHidden(cm.doc, line)) { return 0 }
-
-	    var widgetsHeight = 0
-	    if (line.widgets) { for (var i = 0; i < line.widgets.length; i++) {
-	      if (line.widgets[i].height) { widgetsHeight += line.widgets[i].height }
-	    } }
-
-	    if (wrapping)
-	      { return widgetsHeight + (Math.ceil(line.text.length / perLine) || 1) * th }
-	    else
-	      { return widgetsHeight + th }
-	  }
-	}
-
-	function estimateLineHeights(cm) {
-	  var doc = cm.doc, est = estimateHeight(cm)
-	  doc.iter(function (line) {
-	    var estHeight = est(line)
-	    if (estHeight != line.height) { updateLineHeight(line, estHeight) }
-	  })
-	}
-
-	// Given a mouse event, find the corresponding position. If liberal
-	// is false, it checks whether a gutter or scrollbar was clicked,
-	// and returns null if it was. forRect is used by rectangular
-	// selections, and tries to estimate a character position even for
-	// coordinates beyond the right of the text.
-	function posFromMouse(cm, e, liberal, forRect) {
-	  var display = cm.display
-	  if (!liberal && e_target(e).getAttribute("cm-not-content") == "true") { return null }
-
-	  var x, y, space = display.lineSpace.getBoundingClientRect()
-	  // Fails unpredictably on IE[67] when mouse is dragged around quickly.
-	  try { x = e.clientX - space.left; y = e.clientY - space.top }
-	  catch (e) { return null }
-	  var coords = coordsChar(cm, x, y), line
-	  if (forRect && coords.xRel == 1 && (line = getLine(cm.doc, coords.line).text).length == coords.ch) {
-	    var colDiff = countColumn(line, line.length, cm.options.tabSize) - line.length
-	    coords = Pos(coords.line, Math.max(0, Math.round((x - paddingH(cm.display).left) / charWidth(cm.display)) - colDiff))
-	  }
-	  return coords
-	}
-
-	// Find the view element corresponding to a given line. Return null
-	// when the line isn't visible.
-	function findViewIndex(cm, n) {
-	  if (n >= cm.display.viewTo) { return null }
-	  n -= cm.display.viewFrom
-	  if (n < 0) { return null }
-	  var view = cm.display.view
-	  for (var i = 0; i < view.length; i++) {
-	    n -= view[i].size
-	    if (n < 0) { return i }
-	  }
-	}
-
-	function updateSelection(cm) {
-	  cm.display.input.showSelection(cm.display.input.prepareSelection())
-	}
-
-	function prepareSelection(cm, primary) {
-	  var doc = cm.doc, result = {}
-	  var curFragment = result.cursors = document.createDocumentFragment()
-	  var selFragment = result.selection = document.createDocumentFragment()
-
-	  for (var i = 0; i < doc.sel.ranges.length; i++) {
-	    if (primary === false && i == doc.sel.primIndex) { continue }
-	    var range = doc.sel.ranges[i]
-	    if (range.from().line >= cm.display.viewTo || range.to().line < cm.display.viewFrom) { continue }
-	    var collapsed = range.empty()
-	    if (collapsed || cm.options.showCursorWhenSelecting)
-	      { drawSelectionCursor(cm, range.head, curFragment) }
-	    if (!collapsed)
-	      { drawSelectionRange(cm, range, selFragment) }
-	  }
-	  return result
-	}
-
-	// Draws a cursor for the given range
-	function drawSelectionCursor(cm, head, output) {
-	  var pos = cursorCoords(cm, head, "div", null, null, !cm.options.singleCursorHeightPerLine)
-
-	  var cursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor"))
-	  cursor.style.left = pos.left + "px"
-	  cursor.style.top = pos.top + "px"
-	  cursor.style.height = Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight + "px"
-
-	  if (pos.other) {
-	    // Secondary cursor, shown when on a 'jump' in bi-directional text
-	    var otherCursor = output.appendChild(elt("div", "\u00a0", "CodeMirror-cursor CodeMirror-secondarycursor"))
-	    otherCursor.style.display = ""
-	    otherCursor.style.left = pos.other.left + "px"
-	    otherCursor.style.top = pos.other.top + "px"
-	    otherCursor.style.height = (pos.other.bottom - pos.other.top) * .85 + "px"
-	  }
-	}
-
-	// Draws the given range as a highlighted selection
-	function drawSelectionRange(cm, range, output) {
-	  var display = cm.display, doc = cm.doc
-	  var fragment = document.createDocumentFragment()
-	  var padding = paddingH(cm.display), leftSide = padding.left
-	  var rightSide = Math.max(display.sizerWidth, displayWidth(cm) - display.sizer.offsetLeft) - padding.right
-
-	  function add(left, top, width, bottom) {
-	    if (top < 0) { top = 0 }
-	    top = Math.round(top)
-	    bottom = Math.round(bottom)
-	    fragment.appendChild(elt("div", null, "CodeMirror-selected", ("position: absolute; left: " + left + "px;\n                             top: " + top + "px; width: " + (width == null ? rightSide - left : width) + "px;\n                             height: " + (bottom - top) + "px")))
-	  }
-
-	  function drawForLine(line, fromArg, toArg) {
-	    var lineObj = getLine(doc, line)
-	    var lineLen = lineObj.text.length
-	    var start, end
-	    function coords(ch, bias) {
-	      return charCoords(cm, Pos(line, ch), "div", lineObj, bias)
-	    }
-
-	    iterateBidiSections(getOrder(lineObj), fromArg || 0, toArg == null ? lineLen : toArg, function (from, to, dir) {
-	      var leftPos = coords(from, "left"), rightPos, left, right
-	      if (from == to) {
-	        rightPos = leftPos
-	        left = right = leftPos.left
-	      } else {
-	        rightPos = coords(to - 1, "right")
-	        if (dir == "rtl") { var tmp = leftPos; leftPos = rightPos; rightPos = tmp }
-	        left = leftPos.left
-	        right = rightPos.right
-	      }
-	      if (fromArg == null && from == 0) { left = leftSide }
-	      if (rightPos.top - leftPos.top > 3) { // Different lines, draw top part
-	        add(left, leftPos.top, null, leftPos.bottom)
-	        left = leftSide
-	        if (leftPos.bottom < rightPos.top) { add(left, leftPos.bottom, null, rightPos.top) }
-	      }
-	      if (toArg == null && to == lineLen) { right = rightSide }
-	      if (!start || leftPos.top < start.top || leftPos.top == start.top && leftPos.left < start.left)
-	        { start = leftPos }
-	      if (!end || rightPos.bottom > end.bottom || rightPos.bottom == end.bottom && rightPos.right > end.right)
-	        { end = rightPos }
-	      if (left < leftSide + 1) { left = leftSide }
-	      add(left, rightPos.top, right - left, rightPos.bottom)
-	    })
-	    return {start: start, end: end}
-	  }
-
-	  var sFrom = range.from(), sTo = range.to()
-	  if (sFrom.line == sTo.line) {
-	    drawForLine(sFrom.line, sFrom.ch, sTo.ch)
-	  } else {
-	    var fromLine = getLine(doc, sFrom.line), toLine = getLine(doc, sTo.line)
-	    var singleVLine = visualLine(fromLine) == visualLine(toLine)
-	    var leftEnd = drawForLine(sFrom.line, sFrom.ch, singleVLine ? fromLine.text.length + 1 : null).end
-	    var rightStart = drawForLine(sTo.line, singleVLine ? 0 : null, sTo.ch).start
-	    if (singleVLine) {
-	      if (leftEnd.top < rightStart.top - 2) {
-	        add(leftEnd.right, leftEnd.top, null, leftEnd.bottom)
-	        add(leftSide, rightStart.top, rightStart.left, rightStart.bottom)
-	      } else {
-	        add(leftEnd.right, leftEnd.top, rightStart.left - leftEnd.right, leftEnd.bottom)
-	      }
-	    }
-	    if (leftEnd.bottom < rightStart.top)
-	      { add(leftSide, leftEnd.bottom, null, rightStart.top) }
-	  }
-
-	  output.appendChild(fragment)
-	}
-
-	// Cursor-blinking
-	function restartBlink(cm) {
-	  if (!cm.state.focused) { return }
-	  var display = cm.display
-	  clearInterval(display.blinker)
-	  var on = true
-	  display.cursorDiv.style.visibility = ""
-	  if (cm.options.cursorBlinkRate > 0)
-	    { display.blinker = setInterval(function () { return display.cursorDiv.style.visibility = (on = !on) ? "" : "hidden"; },
-	      cm.options.cursorBlinkRate) }
-	  else if (cm.options.cursorBlinkRate < 0)
-	    { display.cursorDiv.style.visibility = "hidden" }
-	}
-
-	function ensureFocus(cm) {
-	  if (!cm.state.focused) { cm.display.input.focus(); onFocus(cm) }
-	}
-
-	function delayBlurEvent(cm) {
-	  cm.state.delayingBlurEvent = true
-	  setTimeout(function () { if (cm.state.delayingBlurEvent) {
-	    cm.state.delayingBlurEvent = false
-	    onBlur(cm)
-	  } }, 100)
-	}
-
-	function onFocus(cm, e) {
-	  if (cm.state.delayingBlurEvent) { cm.state.delayingBlurEvent = false }
-
-	  if (cm.options.readOnly == "nocursor") { return }
-	  if (!cm.state.focused) {
-	    signal(cm, "focus", cm, e)
-	    cm.state.focused = true
-	    addClass(cm.display.wrapper, "CodeMirror-focused")
-	    // This test prevents this from firing when a context
-	    // menu is closed (since the input reset would kill the
-	    // select-all detection hack)
-	    if (!cm.curOp && cm.display.selForContextMenu != cm.doc.sel) {
-	      cm.display.input.reset()
-	      if (webkit) { setTimeout(function () { return cm.display.input.reset(true); }, 20) } // Issue #1730
-	    }
-	    cm.display.input.receivedFocus()
-	  }
-	  restartBlink(cm)
-	}
-	function onBlur(cm, e) {
-	  if (cm.state.delayingBlurEvent) { return }
-
-	  if (cm.state.focused) {
-	    signal(cm, "blur", cm, e)
-	    cm.state.focused = false
-	    rmClass(cm.display.wrapper, "CodeMirror-focused")
-	  }
-	  clearInterval(cm.display.blinker)
-	  setTimeout(function () { if (!cm.state.focused) { cm.display.shift = false } }, 150)
-	}
-
-	// Re-align line numbers and gutter marks to compensate for
-	// horizontal scrolling.
-	function alignHorizontally(cm) {
-	  var display = cm.display, view = display.view
-	  if (!display.alignWidgets && (!display.gutters.firstChild || !cm.options.fixedGutter)) { return }
-	  var comp = compensateForHScroll(display) - display.scroller.scrollLeft + cm.doc.scrollLeft
-	  var gutterW = display.gutters.offsetWidth, left = comp + "px"
-	  for (var i = 0; i < view.length; i++) { if (!view[i].hidden) {
-	    if (cm.options.fixedGutter) {
-	      if (view[i].gutter)
-	        { view[i].gutter.style.left = left }
-	      if (view[i].gutterBackground)
-	        { view[i].gutterBackground.style.left = left }
-	    }
-	    var align = view[i].alignable
-	    if (align) { for (var j = 0; j < align.length; j++)
-	      { align[j].style.left = left } }
-	  } }
-	  if (cm.options.fixedGutter)
-	    { display.gutters.style.left = (comp + gutterW) + "px" }
-	}
-
-	// Used to ensure that the line number gutter is still the right
-	// size for the current document size. Returns true when an update
-	// is needed.
-	function maybeUpdateLineNumberWidth(cm) {
-	  if (!cm.options.lineNumbers) { return false }
-	  var doc = cm.doc, last = lineNumberFor(cm.options, doc.first + doc.size - 1), display = cm.display
-	  if (last.length != display.lineNumChars) {
-	    var test = display.measure.appendChild(elt("div", [elt("div", last)],
-	                                               "CodeMirror-linenumber CodeMirror-gutter-elt"))
-	    var innerW = test.firstChild.offsetWidth, padding = test.offsetWidth - innerW
-	    display.lineGutter.style.width = ""
-	    display.lineNumInnerWidth = Math.max(innerW, display.lineGutter.offsetWidth - padding) + 1
-	    display.lineNumWidth = display.lineNumInnerWidth + padding
-	    display.lineNumChars = display.lineNumInnerWidth ? last.length : -1
-	    display.lineGutter.style.width = display.lineNumWidth + "px"
-	    updateGutterSpace(cm)
-	    return true
-	  }
-	  return false
-	}
-
-	// Read the actual heights of the rendered lines, and update their
-	// stored heights to match.
-	function updateHeightsInViewport(cm) {
-	  var display = cm.display
-	  var prevBottom = display.lineDiv.offsetTop
-	  for (var i = 0; i < display.view.length; i++) {
-	    var cur = display.view[i], height = (void 0)
-	    if (cur.hidden) { continue }
-	    if (ie && ie_version < 8) {
-	      var bot = cur.node.offsetTop + cur.node.offsetHeight
-	      height = bot - prevBottom
-	      prevBottom = bot
-	    } else {
-	      var box = cur.node.getBoundingClientRect()
-	      height = box.bottom - box.top
-	    }
-	    var diff = cur.line.height - height
-	    if (height < 2) { height = textHeight(display) }
-	    if (diff > .001 || diff < -.001) {
-	      updateLineHeight(cur.line, height)
-	      updateWidgetHeight(cur.line)
-	      if (cur.rest) { for (var j = 0; j < cur.rest.length; j++)
-	        { updateWidgetHeight(cur.rest[j]) } }
-	    }
-	  }
-	}
-
-	// Read and store the height of line widgets associated with the
-	// given line.
-	function updateWidgetHeight(line) {
-	  if (line.widgets) { for (var i = 0; i < line.widgets.length; ++i)
-	    { line.widgets[i].height = line.widgets[i].node.parentNode.offsetHeight } }
-	}
-
-	// Compute the lines that are visible in a given viewport (defaults
-	// the the current scroll position). viewport may contain top,
-	// height, and ensure (see op.scrollToPos) properties.
-	function visibleLines(display, doc, viewport) {
-	  var top = viewport && viewport.top != null ? Math.max(0, viewport.top) : display.scroller.scrollTop
-	  top = Math.floor(top - paddingTop(display))
-	  var bottom = viewport && viewport.bottom != null ? viewport.bottom : top + display.wrapper.clientHeight
-
-	  var from = lineAtHeight(doc, top), to = lineAtHeight(doc, bottom)
-	  // Ensure is a {from: {line, ch}, to: {line, ch}} object, and
-	  // forces those lines into the viewport (if possible).
-	  if (viewport && viewport.ensure) {
-	    var ensureFrom = viewport.ensure.from.line, ensureTo = viewport.ensure.to.line
-	    if (ensureFrom < from) {
-	      from = ensureFrom
-	      to = lineAtHeight(doc, heightAtLine(getLine(doc, ensureFrom)) + display.wrapper.clientHeight)
-	    } else if (Math.min(ensureTo, doc.lastLine()) >= to) {
-	      from = lineAtHeight(doc, heightAtLine(getLine(doc, ensureTo)) - display.wrapper.clientHeight)
-	      to = ensureTo
-	    }
-	  }
-	  return {from: from, to: Math.max(to, from + 1)}
-	}
-
-	// Sync the scrollable area and scrollbars, ensure the viewport
-	// covers the visible area.
-	function setScrollTop(cm, val) {
-	  if (Math.abs(cm.doc.scrollTop - val) < 2) { return }
-	  cm.doc.scrollTop = val
-	  if (!gecko) { updateDisplaySimple(cm, {top: val}) }
-	  if (cm.display.scroller.scrollTop != val) { cm.display.scroller.scrollTop = val }
-	  cm.display.scrollbars.setScrollTop(val)
-	  if (gecko) { updateDisplaySimple(cm) }
-	  startWorker(cm, 100)
-	}
-	// Sync scroller and scrollbar, ensure the gutter elements are
-	// aligned.
-	function setScrollLeft(cm, val, isScroller) {
-	  if (isScroller ? val == cm.doc.scrollLeft : Math.abs(cm.doc.scrollLeft - val) < 2) { return }
-	  val = Math.min(val, cm.display.scroller.scrollWidth - cm.display.scroller.clientWidth)
-	  cm.doc.scrollLeft = val
-	  alignHorizontally(cm)
-	  if (cm.display.scroller.scrollLeft != val) { cm.display.scroller.scrollLeft = val }
-	  cm.display.scrollbars.setScrollLeft(val)
-	}
-
-	// Since the delta values reported on mouse wheel events are
-	// unstandardized between browsers and even browser versions, and
-	// generally horribly unpredictable, this code starts by measuring
-	// the scroll effect that the first few mouse wheel events have,
-	// and, from that, detects the way it can convert deltas to pixel
-	// offsets afterwards.
-	//
-	// The reason we want to know the amount a wheel event will scroll
-	// is that it gives us a chance to update the display before the
-	// actual scrolling happens, reducing flickering.
-
-	var wheelSamples = 0;
-	var wheelPixelsPerUnit = null;
-	// Fill in a browser-detected starting value on browsers where we
-	// know one. These don't have to be accurate -- the result of them
-	// being wrong would just be a slight flicker on the first wheel
-	// scroll (if it is large enough).
-	if (ie) { wheelPixelsPerUnit = -.53 }
-	else if (gecko) { wheelPixelsPerUnit = 15 }
-	else if (chrome) { wheelPixelsPerUnit = -.7 }
-	else if (safari) { wheelPixelsPerUnit = -1/3 }
-
-	function wheelEventDelta(e) {
-	  var dx = e.wheelDeltaX, dy = e.wheelDeltaY
-	  if (dx == null && e.detail && e.axis == e.HORIZONTAL_AXIS) { dx = e.detail }
-	  if (dy == null && e.detail && e.axis == e.VERTICAL_AXIS) { dy = e.detail }
-	  else if (dy == null) { dy = e.wheelDelta }
-	  return {x: dx, y: dy}
-	}
-	function wheelEventPixels(e) {
-	  var delta = wheelEventDelta(e)
-	  delta.x *= wheelPixelsPerUnit
-	  delta.y *= wheelPixelsPerUnit
-	  return delta
-	}
-
-	function onScrollWheel(cm, e) {
-	  var delta = wheelEventDelta(e), dx = delta.x, dy = delta.y
-
-	  var display = cm.display, scroll = display.scroller
-	  // Quit if there's nothing to scroll here
-	  var canScrollX = scroll.scrollWidth > scroll.clientWidth
-	  var canScrollY = scroll.scrollHeight > scroll.clientHeight
-	  if (!(dx && canScrollX || dy && canScrollY)) { return }
-
-	  // Webkit browsers on OS X abort momentum scrolls when the target
-	  // of the scroll event is removed from the scrollable element.
-	  // This hack (see related code in patchDisplay) makes sure the
-	  // element is kept around.
-	  if (dy && mac && webkit) {
-	    outer: for (var cur = e.target, view = display.view; cur != scroll; cur = cur.parentNode) {
-	      for (var i = 0; i < view.length; i++) {
-	        if (view[i].node == cur) {
-	          cm.display.currentWheelTarget = cur
-	          break outer
-	        }
-	      }
-	    }
-	  }
-
-	  // On some browsers, horizontal scrolling will cause redraws to
-	  // happen before the gutter has been realigned, causing it to
-	  // wriggle around in a most unseemly way. When we have an
-	  // estimated pixels/delta value, we just handle horizontal
-	  // scrolling entirely here. It'll be slightly off from native, but
-	  // better than glitching out.
-	  if (dx && !gecko && !presto && wheelPixelsPerUnit != null) {
-	    if (dy && canScrollY)
-	      { setScrollTop(cm, Math.max(0, Math.min(scroll.scrollTop + dy * wheelPixelsPerUnit, scroll.scrollHeight - scroll.clientHeight))) }
-	    setScrollLeft(cm, Math.max(0, Math.min(scroll.scrollLeft + dx * wheelPixelsPerUnit, scroll.scrollWidth - scroll.clientWidth)))
-	    // Only prevent default scrolling if vertical scrolling is
-	    // actually possible. Otherwise, it causes vertical scroll
-	    // jitter on OSX trackpads when deltaX is small and deltaY
-	    // is large (issue #3579)
-	    if (!dy || (dy && canScrollY))
-	      { e_preventDefault(e) }
-	    display.wheelStartX = null // Abort measurement, if in progress
-	    return
-	  }
-
-	  // 'Project' the visible viewport to cover the area that is being
-	  // scrolled into view (if we know enough to estimate it).
-	  if (dy && wheelPixelsPerUnit != null) {
-	    var pixels = dy * wheelPixelsPerUnit
-	    var top = cm.doc.scrollTop, bot = top + display.wrapper.clientHeight
-	    if (pixels < 0) { top = Math.max(0, top + pixels - 50) }
-	    else { bot = Math.min(cm.doc.height, bot + pixels + 50) }
-	    updateDisplaySimple(cm, {top: top, bottom: bot})
-	  }
-
-	  if (wheelSamples < 20) {
-	    if (display.wheelStartX == null) {
-	      display.wheelStartX = scroll.scrollLeft; display.wheelStartY = scroll.scrollTop
-	      display.wheelDX = dx; display.wheelDY = dy
-	      setTimeout(function () {
-	        if (display.wheelStartX == null) { return }
-	        var movedX = scroll.scrollLeft - display.wheelStartX
-	        var movedY = scroll.scrollTop - display.wheelStartY
-	        var sample = (movedY && display.wheelDY && movedY / display.wheelDY) ||
-	          (movedX && display.wheelDX && movedX / display.wheelDX)
-	        display.wheelStartX = display.wheelStartY = null
-	        if (!sample) { return }
-	        wheelPixelsPerUnit = (wheelPixelsPerUnit * wheelSamples + sample) / (wheelSamples + 1)
-	        ++wheelSamples
-	      }, 200)
-	    } else {
-	      display.wheelDX += dx; display.wheelDY += dy
-	    }
-	  }
-	}
-
-	// SCROLLBARS
-
-	// Prepare DOM reads needed to update the scrollbars. Done in one
-	// shot to minimize update/measure roundtrips.
-	function measureForScrollbars(cm) {
-	  var d = cm.display, gutterW = d.gutters.offsetWidth
-	  var docH = Math.round(cm.doc.height + paddingVert(cm.display))
-	  return {
-	    clientHeight: d.scroller.clientHeight,
-	    viewHeight: d.wrapper.clientHeight,
-	    scrollWidth: d.scroller.scrollWidth, clientWidth: d.scroller.clientWidth,
-	    viewWidth: d.wrapper.clientWidth,
-	    barLeft: cm.options.fixedGutter ? gutterW : 0,
-	    docHeight: docH,
-	    scrollHeight: docH + scrollGap(cm) + d.barHeight,
-	    nativeBarWidth: d.nativeBarWidth,
-	    gutterWidth: gutterW
-	  }
-	}
-
-	function NativeScrollbars(place, scroll, cm) {
-	  this.cm = cm
-	  var vert = this.vert = elt("div", [elt("div", null, null, "min-width: 1px")], "CodeMirror-vscrollbar")
-	  var horiz = this.horiz = elt("div", [elt("div", null, null, "height: 100%; min-height: 1px")], "CodeMirror-hscrollbar")
-	  place(vert); place(horiz)
-
-	  on(vert, "scroll", function () {
-	    if (vert.clientHeight) { scroll(vert.scrollTop, "vertical") }
-	  })
-	  on(horiz, "scroll", function () {
-	    if (horiz.clientWidth) { scroll(horiz.scrollLeft, "horizontal") }
-	  })
-
-	  this.checkedZeroWidth = false
-	  // Need to set a minimum width to see the scrollbar on IE7 (but must not set it on IE8).
-	  if (ie && ie_version < 8) { this.horiz.style.minHeight = this.vert.style.minWidth = "18px" }
-	}
-
-	NativeScrollbars.prototype = copyObj({
-	  update: function(measure) {
-	    var needsH = measure.scrollWidth > measure.clientWidth + 1
-	    var needsV = measure.scrollHeight > measure.clientHeight + 1
-	    var sWidth = measure.nativeBarWidth
-
-	    if (needsV) {
-	      this.vert.style.display = "block"
-	      this.vert.style.bottom = needsH ? sWidth + "px" : "0"
-	      var totalHeight = measure.viewHeight - (needsH ? sWidth : 0)
-	      // A bug in IE8 can cause this value to be negative, so guard it.
-	      this.vert.firstChild.style.height =
-	        Math.max(0, measure.scrollHeight - measure.clientHeight + totalHeight) + "px"
-	    } else {
-	      this.vert.style.display = ""
-	      this.vert.firstChild.style.height = "0"
-	    }
-
-	    if (needsH) {
-	      this.horiz.style.display = "block"
-	      this.horiz.style.right = needsV ? sWidth + "px" : "0"
-	      this.horiz.style.left = measure.barLeft + "px"
-	      var totalWidth = measure.viewWidth - measure.barLeft - (needsV ? sWidth : 0)
-	      this.horiz.firstChild.style.width =
-	        (measure.scrollWidth - measure.clientWidth + totalWidth) + "px"
-	    } else {
-	      this.horiz.style.display = ""
-	      this.horiz.firstChild.style.width = "0"
-	    }
-
-	    if (!this.checkedZeroWidth && measure.clientHeight > 0) {
-	      if (sWidth == 0) { this.zeroWidthHack() }
-	      this.checkedZeroWidth = true
-	    }
-
-	    return {right: needsV ? sWidth : 0, bottom: needsH ? sWidth : 0}
-	  },
-	  setScrollLeft: function(pos) {
-	    if (this.horiz.scrollLeft != pos) { this.horiz.scrollLeft = pos }
-	    if (this.disableHoriz) { this.enableZeroWidthBar(this.horiz, this.disableHoriz) }
-	  },
-	  setScrollTop: function(pos) {
-	    if (this.vert.scrollTop != pos) { this.vert.scrollTop = pos }
-	    if (this.disableVert) { this.enableZeroWidthBar(this.vert, this.disableVert) }
-	  },
-	  zeroWidthHack: function() {
-	    var w = mac && !mac_geMountainLion ? "12px" : "18px"
-	    this.horiz.style.height = this.vert.style.width = w
-	    this.horiz.style.pointerEvents = this.vert.style.pointerEvents = "none"
-	    this.disableHoriz = new Delayed
-	    this.disableVert = new Delayed
-	  },
-	  enableZeroWidthBar: function(bar, delay) {
-	    bar.style.pointerEvents = "auto"
-	    function maybeDisable() {
-	      // To find out whether the scrollbar is still visible, we
-	      // check whether the element under the pixel in the bottom
-	      // left corner of the scrollbar box is the scrollbar box
-	      // itself (when the bar is still visible) or its filler child
-	      // (when the bar is hidden). If it is still visible, we keep
-	      // it enabled, if it's hidden, we disable pointer events.
-	      var box = bar.getBoundingClientRect()
-	      var elt = document.elementFromPoint(box.left + 1, box.bottom - 1)
-	      if (elt != bar) { bar.style.pointerEvents = "none" }
-	      else { delay.set(1000, maybeDisable) }
-	    }
-	    delay.set(1000, maybeDisable)
-	  },
-	  clear: function() {
-	    var parent = this.horiz.parentNode
-	    parent.removeChild(this.horiz)
-	    parent.removeChild(this.vert)
-	  }
-	}, NativeScrollbars.prototype)
-
-	function NullScrollbars() {}
-
-	NullScrollbars.prototype = copyObj({
-	  update: function() { return {bottom: 0, right: 0} },
-	  setScrollLeft: function() {},
-	  setScrollTop: function() {},
-	  clear: function() {}
-	}, NullScrollbars.prototype)
-
-	function updateScrollbars(cm, measure) {
-	  if (!measure) { measure = measureForScrollbars(cm) }
-	  var startWidth = cm.display.barWidth, startHeight = cm.display.barHeight
-	  updateScrollbarsInner(cm, measure)
-	  for (var i = 0; i < 4 && startWidth != cm.display.barWidth || startHeight != cm.display.barHeight; i++) {
-	    if (startWidth != cm.display.barWidth && cm.options.lineWrapping)
-	      { updateHeightsInViewport(cm) }
-	    updateScrollbarsInner(cm, measureForScrollbars(cm))
-	    startWidth = cm.display.barWidth; startHeight = cm.display.barHeight
-	  }
-	}
-
-	// Re-synchronize the fake scrollbars with the actual size of the
-	// content.
-	function updateScrollbarsInner(cm, measure) {
-	  var d = cm.display
-	  var sizes = d.scrollbars.update(measure)
-
-	  d.sizer.style.paddingRight = (d.barWidth = sizes.right) + "px"
-	  d.sizer.style.paddingBottom = (d.barHeight = sizes.bottom) + "px"
-	  d.heightForcer.style.borderBottom = sizes.bottom + "px solid transparent"
-
-	  if (sizes.right && sizes.bottom) {
-	    d.scrollbarFiller.style.display = "block"
-	    d.scrollbarFiller.style.height = sizes.bottom + "px"
-	    d.scrollbarFiller.style.width = sizes.right + "px"
-	  } else { d.scrollbarFiller.style.display = "" }
-	  if (sizes.bottom && cm.options.coverGutterNextToScrollbar && cm.options.fixedGutter) {
-	    d.gutterFiller.style.display = "block"
-	    d.gutterFiller.style.height = sizes.bottom + "px"
-	    d.gutterFiller.style.width = measure.gutterWidth + "px"
-	  } else { d.gutterFiller.style.display = "" }
-	}
-
-	var scrollbarModel = {"native": NativeScrollbars, "null": NullScrollbars}
-
-	function initScrollbars(cm) {
-	  if (cm.display.scrollbars) {
-	    cm.display.scrollbars.clear()
-	    if (cm.display.scrollbars.addClass)
-	      { rmClass(cm.display.wrapper, cm.display.scrollbars.addClass) }
-	  }
-
-	  cm.display.scrollbars = new scrollbarModel[cm.options.scrollbarStyle](function (node) {
-	    cm.display.wrapper.insertBefore(node, cm.display.scrollbarFiller)
-	    // Prevent clicks in the scrollbars from killing focus
-	    on(node, "mousedown", function () {
-	      if (cm.state.focused) { setTimeout(function () { return cm.display.input.focus(); }, 0) }
-	    })
-	    node.setAttribute("cm-not-content", "true")
-	  }, function (pos, axis) {
-	    if (axis == "horizontal") { setScrollLeft(cm, pos) }
-	    else { setScrollTop(cm, pos) }
-	  }, cm)
-	  if (cm.display.scrollbars.addClass)
-	    { addClass(cm.display.wrapper, cm.display.scrollbars.addClass) }
-	}
-
-	// SCROLLING THINGS INTO VIEW
-
-	// If an editor sits on the top or bottom of the window, partially
-	// scrolled out of view, this ensures that the cursor is visible.
-	function maybeScrollWindow(cm, coords) {
-	  if (signalDOMEvent(cm, "scrollCursorIntoView")) { return }
-
-	  var display = cm.display, box = display.sizer.getBoundingClientRect(), doScroll = null
-	  if (coords.top + box.top < 0) { doScroll = true }
-	  else if (coords.bottom + box.top > (window.innerHeight || document.documentElement.clientHeight)) { doScroll = false }
-	  if (doScroll != null && !phantom) {
-	    var scrollNode = elt("div", "\u200b", null, ("position: absolute;\n                         top: " + (coords.top - display.viewOffset - paddingTop(cm.display)) + "px;\n                         height: " + (coords.bottom - coords.top + scrollGap(cm) + display.barHeight) + "px;\n                         left: " + (coords.left) + "px; width: 2px;"))
-	    cm.display.lineSpace.appendChild(scrollNode)
-	    scrollNode.scrollIntoView(doScroll)
-	    cm.display.lineSpace.removeChild(scrollNode)
-	  }
-	}
-
-	// Scroll a given position into view (immediately), verifying that
-	// it actually became visible (as line heights are accurately
-	// measured, the position of something may 'drift' during drawing).
-	function scrollPosIntoView(cm, pos, end, margin) {
-	  if (margin == null) { margin = 0 }
-	  var coords
-	  for (var limit = 0; limit < 5; limit++) {
-	    var changed = false
-	    coords = cursorCoords(cm, pos)
-	    var endCoords = !end || end == pos ? coords : cursorCoords(cm, end)
-	    var scrollPos = calculateScrollPos(cm, Math.min(coords.left, endCoords.left),
-	                                       Math.min(coords.top, endCoords.top) - margin,
-	                                       Math.max(coords.left, endCoords.left),
-	                                       Math.max(coords.bottom, endCoords.bottom) + margin)
-	    var startTop = cm.doc.scrollTop, startLeft = cm.doc.scrollLeft
-	    if (scrollPos.scrollTop != null) {
-	      setScrollTop(cm, scrollPos.scrollTop)
-	      if (Math.abs(cm.doc.scrollTop - startTop) > 1) { changed = true }
-	    }
-	    if (scrollPos.scrollLeft != null) {
-	      setScrollLeft(cm, scrollPos.scrollLeft)
-	      if (Math.abs(cm.doc.scrollLeft - startLeft) > 1) { changed = true }
-	    }
-	    if (!changed) { break }
-	  }
-	  return coords
-	}
-
-	// Scroll a given set of coordinates into view (immediately).
-	function scrollIntoView(cm, x1, y1, x2, y2) {
-	  var scrollPos = calculateScrollPos(cm, x1, y1, x2, y2)
-	  if (scrollPos.scrollTop != null) { setScrollTop(cm, scrollPos.scrollTop) }
-	  if (scrollPos.scrollLeft != null) { setScrollLeft(cm, scrollPos.scrollLeft) }
-	}
-
-	// Calculate a new scroll position needed to scroll the given
-	// rectangle into view. Returns an object with scrollTop and
-	// scrollLeft properties. When these are undefined, the
-	// vertical/horizontal position does not need to be adjusted.
-	function calculateScrollPos(cm, x1, y1, x2, y2) {
-	  var display = cm.display, snapMargin = textHeight(cm.display)
-	  if (y1 < 0) { y1 = 0 }
-	  var screentop = cm.curOp && cm.curOp.scrollTop != null ? cm.curOp.scrollTop : display.scroller.scrollTop
-	  var screen = displayHeight(cm), result = {}
-	  if (y2 - y1 > screen) { y2 = y1 + screen }
-	  var docBottom = cm.doc.height + paddingVert(display)
-	  var atTop = y1 < snapMargin, atBottom = y2 > docBottom - snapMargin
-	  if (y1 < screentop) {
-	    result.scrollTop = atTop ? 0 : y1
-	  } else if (y2 > screentop + screen) {
-	    var newTop = Math.min(y1, (atBottom ? docBottom : y2) - screen)
-	    if (newTop != screentop) { result.scrollTop = newTop }
-	  }
-
-	  var screenleft = cm.curOp && cm.curOp.scrollLeft != null ? cm.curOp.scrollLeft : display.scroller.scrollLeft
-	  var screenw = displayWidth(cm) - (cm.options.fixedGutter ? display.gutters.offsetWidth : 0)
-	  var tooWide = x2 - x1 > screenw
-	  if (tooWide) { x2 = x1 + screenw }
-	  if (x1 < 10)
-	    { result.scrollLeft = 0 }
-	  else if (x1 < screenleft)
-	    { result.scrollLeft = Math.max(0, x1 - (tooWide ? 0 : 10)) }
-	  else if (x2 > screenw + screenleft - 3)
-	    { result.scrollLeft = x2 + (tooWide ? 0 : 10) - screenw }
-	  return result
-	}
-
-	// Store a relative adjustment to the scroll position in the current
-	// operation (to be applied when the operation finishes).
-	function addToScrollPos(cm, left, top) {
-	  if (left != null || top != null) { resolveScrollToPos(cm) }
-	  if (left != null)
-	    { cm.curOp.scrollLeft = (cm.curOp.scrollLeft == null ? cm.doc.scrollLeft : cm.curOp.scrollLeft) + left }
-	  if (top != null)
-	    { cm.curOp.scrollTop = (cm.curOp.scrollTop == null ? cm.doc.scrollTop : cm.curOp.scrollTop) + top }
-	}
-
-	// Make sure that at the end of the operation the current cursor is
-	// shown.
-	function ensureCursorVisible(cm) {
-	  resolveScrollToPos(cm)
-	  var cur = cm.getCursor(), from = cur, to = cur
-	  if (!cm.options.lineWrapping) {
-	    from = cur.ch ? Pos(cur.line, cur.ch - 1) : cur
-	    to = Pos(cur.line, cur.ch + 1)
-	  }
-	  cm.curOp.scrollToPos = {from: from, to: to, margin: cm.options.cursorScrollMargin, isCursor: true}
-	}
-
-	// When an operation has its scrollToPos property set, and another
-	// scroll action is applied before the end of the operation, this
-	// 'simulates' scrolling that position into view in a cheap way, so
-	// that the effect of intermediate scroll commands is not ignored.
-	function resolveScrollToPos(cm) {
-	  var range = cm.curOp.scrollToPos
-	  if (range) {
-	    cm.curOp.scrollToPos = null
-	    var from = estimateCoords(cm, range.from), to = estimateCoords(cm, range.to)
-	    var sPos = calculateScrollPos(cm, Math.min(from.left, to.left),
-	                                  Math.min(from.top, to.top) - range.margin,
-	                                  Math.max(from.right, to.right),
-	                                  Math.max(from.bottom, to.bottom) + range.margin)
-	    cm.scrollTo(sPos.scrollLeft, sPos.scrollTop)
-	  }
-	}
-
-	// Operations are used to wrap a series of changes to the editor
-	// state in such a way that each change won't have to update the
-	// cursor and display (which would be awkward, slow, and
-	// error-prone). Instead, display updates are batched and then all
-	// combined and executed at once.
-
-	var nextOpId = 0
-	// Start a new operation.
-	function startOperation(cm) {
-	  cm.curOp = {
-	    cm: cm,
-	    viewChanged: false,      // Flag that indicates that lines might need to be redrawn
-	    startHeight: cm.doc.height, // Used to detect need to update scrollbar
-	    forceUpdate: false,      // Used to force a redraw
-	    updateInput: null,       // Whether to reset the input textarea
-	    typing: false,           // Whether this reset should be careful to leave existing text (for compositing)
-	    changeObjs: null,        // Accumulated changes, for firing change events
-	    cursorActivityHandlers: null, // Set of handlers to fire cursorActivity on
-	    cursorActivityCalled: 0, // Tracks which cursorActivity handlers have been called already
-	    selectionChanged: false, // Whether the selection needs to be redrawn
-	    updateMaxLine: false,    // Set when the widest line needs to be determined anew
-	    scrollLeft: null, scrollTop: null, // Intermediate scroll position, not pushed to DOM yet
-	    scrollToPos: null,       // Used to scroll to a specific position
-	    focus: false,
-	    id: ++nextOpId           // Unique ID
-	  }
-	  pushOperation(cm.curOp)
-	}
-
-	// Finish an operation, updating the display and signalling delayed events
-	function endOperation(cm) {
-	  var op = cm.curOp
-	  finishOperation(op, function (group) {
-	    for (var i = 0; i < group.ops.length; i++)
-	      { group.ops[i].cm.curOp = null }
-	    endOperations(group)
-	  })
-	}
-
-	// The DOM updates done when an operation finishes are batched so
-	// that the minimum number of relayouts are required.
-	function endOperations(group) {
-	  var ops = group.ops
-	  for (var i = 0; i < ops.length; i++) // Read DOM
-	    { endOperation_R1(ops[i]) }
-	  for (var i$1 = 0; i$1 < ops.length; i$1++) // Write DOM (maybe)
-	    { endOperation_W1(ops[i$1]) }
-	  for (var i$2 = 0; i$2 < ops.length; i$2++) // Read DOM
-	    { endOperation_R2(ops[i$2]) }
-	  for (var i$3 = 0; i$3 < ops.length; i$3++) // Write DOM (maybe)
-	    { endOperation_W2(ops[i$3]) }
-	  for (var i$4 = 0; i$4 < ops.length; i$4++) // Read DOM
-	    { endOperation_finish(ops[i$4]) }
-	}
-
-	function endOperation_R1(op) {
-	  var cm = op.cm, display = cm.display
-	  maybeClipScrollbars(cm)
-	  if (op.updateMaxLine) { findMaxLine(cm) }
-
-	  op.mustUpdate = op.viewChanged || op.forceUpdate || op.scrollTop != null ||
-	    op.scrollToPos && (op.scrollToPos.from.line < display.viewFrom ||
-	                       op.scrollToPos.to.line >= display.viewTo) ||
-	    display.maxLineChanged && cm.options.lineWrapping
-	  op.update = op.mustUpdate &&
-	    new DisplayUpdate(cm, op.mustUpdate && {top: op.scrollTop, ensure: op.scrollToPos}, op.forceUpdate)
-	}
-
-	function endOperation_W1(op) {
-	  op.updatedDisplay = op.mustUpdate && updateDisplayIfNeeded(op.cm, op.update)
-	}
-
-	function endOperation_R2(op) {
-	  var cm = op.cm, display = cm.display
-	  if (op.updatedDisplay) { updateHeightsInViewport(cm) }
-
-	  op.barMeasure = measureForScrollbars(cm)
-
-	  // If the max line changed since it was last measured, measure it,
-	  // and ensure the document's width matches it.
-	  // updateDisplay_W2 will use these properties to do the actual resizing
-	  if (display.maxLineChanged && !cm.options.lineWrapping) {
-	    op.adjustWidthTo = measureChar(cm, display.maxLine, display.maxLine.text.length).left + 3
-	    cm.display.sizerWidth = op.adjustWidthTo
-	    op.barMeasure.scrollWidth =
-	      Math.max(display.scroller.clientWidth, display.sizer.offsetLeft + op.adjustWidthTo + scrollGap(cm) + cm.display.barWidth)
-	    op.maxScrollLeft = Math.max(0, display.sizer.offsetLeft + op.adjustWidthTo - displayWidth(cm))
-	  }
-
-	  if (op.updatedDisplay || op.selectionChanged)
-	    { op.preparedSelection = display.input.prepareSelection(op.focus) }
-	}
-
-	function endOperation_W2(op) {
-	  var cm = op.cm
-
-	  if (op.adjustWidthTo != null) {
-	    cm.display.sizer.style.minWidth = op.adjustWidthTo + "px"
-	    if (op.maxScrollLeft < cm.doc.scrollLeft)
-	      { setScrollLeft(cm, Math.min(cm.display.scroller.scrollLeft, op.maxScrollLeft), true) }
-	    cm.display.maxLineChanged = false
-	  }
-
-	  var takeFocus = op.focus && op.focus == activeElt() && (!document.hasFocus || document.hasFocus())
-	  if (op.preparedSelection)
-	    { cm.display.input.showSelection(op.preparedSelection, takeFocus) }
-	  if (op.updatedDisplay || op.startHeight != cm.doc.height)
-	    { updateScrollbars(cm, op.barMeasure) }
-	  if (op.updatedDisplay)
-	    { setDocumentHeight(cm, op.barMeasure) }
-
-	  if (op.selectionChanged) { restartBlink(cm) }
-
-	  if (cm.state.focused && op.updateInput)
-	    { cm.display.input.reset(op.typing) }
-	  if (takeFocus) { ensureFocus(op.cm) }
-	}
-
-	function endOperation_finish(op) {
-	  var cm = op.cm, display = cm.display, doc = cm.doc
-
-	  if (op.updatedDisplay) { postUpdateDisplay(cm, op.update) }
-
-	  // Abort mouse wheel delta measurement, when scrolling explicitly
-	  if (display.wheelStartX != null && (op.scrollTop != null || op.scrollLeft != null || op.scrollToPos))
-	    { display.wheelStartX = display.wheelStartY = null }
-
-	  // Propagate the scroll position to the actual DOM scroller
-	  if (op.scrollTop != null && (display.scroller.scrollTop != op.scrollTop || op.forceScroll)) {
-	    doc.scrollTop = Math.max(0, Math.min(display.scroller.scrollHeight - display.scroller.clientHeight, op.scrollTop))
-	    display.scrollbars.setScrollTop(doc.scrollTop)
-	    display.scroller.scrollTop = doc.scrollTop
-	  }
-	  if (op.scrollLeft != null && (display.scroller.scrollLeft != op.scrollLeft || op.forceScroll)) {
-	    doc.scrollLeft = Math.max(0, Math.min(display.scroller.scrollWidth - display.scroller.clientWidth, op.scrollLeft))
-	    display.scrollbars.setScrollLeft(doc.scrollLeft)
-	    display.scroller.scrollLeft = doc.scrollLeft
-	    alignHorizontally(cm)
-	  }
-	  // If we need to scroll a specific position into view, do so.
-	  if (op.scrollToPos) {
-	    var coords = scrollPosIntoView(cm, clipPos(doc, op.scrollToPos.from),
-	                                   clipPos(doc, op.scrollToPos.to), op.scrollToPos.margin)
-	    if (op.scrollToPos.isCursor && cm.state.focused) { maybeScrollWindow(cm, coords) }
-	  }
-
-	  // Fire events for markers that are hidden/unidden by editing or
-	  // undoing
-	  var hidden = op.maybeHiddenMarkers, unhidden = op.maybeUnhiddenMarkers
-	  if (hidden) { for (var i = 0; i < hidden.length; ++i)
-	    { if (!hidden[i].lines.length) { signal(hidden[i], "hide") } } }
-	  if (unhidden) { for (var i$1 = 0; i$1 < unhidden.length; ++i$1)
-	    { if (unhidden[i$1].lines.length) { signal(unhidden[i$1], "unhide") } } }
-
-	  if (display.wrapper.offsetHeight)
-	    { doc.scrollTop = cm.display.scroller.scrollTop }
-
-	  // Fire change events, and delayed event handlers
-	  if (op.changeObjs)
-	    { signal(cm, "changes", cm, op.changeObjs) }
-	  if (op.update)
-	    { op.update.finish() }
-	}
-
-	// Run the given function in an operation
-	function runInOp(cm, f) {
-	  if (cm.curOp) { return f() }
-	  startOperation(cm)
-	  try { return f() }
-	  finally { endOperation(cm) }
-	}
-	// Wraps a function in an operation. Returns the wrapped function.
-	function operation(cm, f) {
-	  return function() {
-	    if (cm.curOp) { return f.apply(cm, arguments) }
-	    startOperation(cm)
-	    try { return f.apply(cm, arguments) }
-	    finally { endOperation(cm) }
-	  }
-	}
-	// Used to add methods to editor and doc instances, wrapping them in
-	// operations.
-	function methodOp(f) {
-	  return function() {
-	    if (this.curOp) { return f.apply(this, arguments) }
-	    startOperation(this)
-	    try { return f.apply(this, arguments) }
-	    finally { endOperation(this) }
-	  }
-	}
-	function docMethodOp(f) {
-	  return function() {
-	    var cm = this.cm
-	    if (!cm || cm.curOp) { return f.apply(this, arguments) }
-	    startOperation(cm)
-	    try { return f.apply(this, arguments) }
-	    finally { endOperation(cm) }
-	  }
-	}
-
-	// Updates the display.view data structure for a given change to the
-	// document. From and to are in pre-change coordinates. Lendiff is
-	// the amount of lines added or subtracted by the change. This is
-	// used for changes that span multiple lines, or change the way
-	// lines are divided into visual lines. regLineChange (below)
-	// registers single-line changes.
-	function regChange(cm, from, to, lendiff) {
-	  if (from == null) { from = cm.doc.first }
-	  if (to == null) { to = cm.doc.first + cm.doc.size }
-	  if (!lendiff) { lendiff = 0 }
-
-	  var display = cm.display
-	  if (lendiff && to < display.viewTo &&
-	      (display.updateLineNumbers == null || display.updateLineNumbers > from))
-	    { display.updateLineNumbers = from }
-
-	  cm.curOp.viewChanged = true
-
-	  if (from >= display.viewTo) { // Change after
-	    if (sawCollapsedSpans && visualLineNo(cm.doc, from) < display.viewTo)
-	      { resetView(cm) }
-	  } else if (to <= display.viewFrom) { // Change before
-	    if (sawCollapsedSpans && visualLineEndNo(cm.doc, to + lendiff) > display.viewFrom) {
-	      resetView(cm)
-	    } else {
-	      display.viewFrom += lendiff
-	      display.viewTo += lendiff
-	    }
-	  } else if (from <= display.viewFrom && to >= display.viewTo) { // Full overlap
-	    resetView(cm)
-	  } else if (from <= display.viewFrom) { // Top overlap
-	    var cut = viewCuttingPoint(cm, to, to + lendiff, 1)
-	    if (cut) {
-	      display.view = display.view.slice(cut.index)
-	      display.viewFrom = cut.lineN
-	      display.viewTo += lendiff
-	    } else {
-	      resetView(cm)
-	    }
-	  } else if (to >= display.viewTo) { // Bottom overlap
-	    var cut$1 = viewCuttingPoint(cm, from, from, -1)
-	    if (cut$1) {
-	      display.view = display.view.slice(0, cut$1.index)
-	      display.viewTo = cut$1.lineN
-	    } else {
-	      resetView(cm)
-	    }
-	  } else { // Gap in the middle
-	    var cutTop = viewCuttingPoint(cm, from, from, -1)
-	    var cutBot = viewCuttingPoint(cm, to, to + lendiff, 1)
-	    if (cutTop && cutBot) {
-	      display.view = display.view.slice(0, cutTop.index)
-	        .concat(buildViewArray(cm, cutTop.lineN, cutBot.lineN))
-	        .concat(display.view.slice(cutBot.index))
-	      display.viewTo += lendiff
-	    } else {
-	      resetView(cm)
-	    }
-	  }
-
-	  var ext = display.externalMeasured
-	  if (ext) {
-	    if (to < ext.lineN)
-	      { ext.lineN += lendiff }
-	    else if (from < ext.lineN + ext.size)
-	      { display.externalMeasured = null }
-	  }
-	}
-
-	// Register a change to a single line. Type must be one of "text",
-	// "gutter", "class", "widget"
-	function regLineChange(cm, line, type) {
-	  cm.curOp.viewChanged = true
-	  var display = cm.display, ext = cm.display.externalMeasured
-	  if (ext && line >= ext.lineN && line < ext.lineN + ext.size)
-	    { display.externalMeasured = null }
-
-	  if (line < display.viewFrom || line >= display.viewTo) { return }
-	  var lineView = display.view[findViewIndex(cm, line)]
-	  if (lineView.node == null) { return }
-	  var arr = lineView.changes || (lineView.changes = [])
-	  if (indexOf(arr, type) == -1) { arr.push(type) }
-	}
-
-	// Clear the view.
-	function resetView(cm) {
-	  cm.display.viewFrom = cm.display.viewTo = cm.doc.first
-	  cm.display.view = []
-	  cm.display.viewOffset = 0
-	}
-
-	function viewCuttingPoint(cm, oldN, newN, dir) {
-	  var index = findViewIndex(cm, oldN), diff, view = cm.display.view
-	  if (!sawCollapsedSpans || newN == cm.doc.first + cm.doc.size)
-	    { return {index: index, lineN: newN} }
-	  var n = cm.display.viewFrom
-	  for (var i = 0; i < index; i++)
-	    { n += view[i].size }
-	  if (n != oldN) {
-	    if (dir > 0) {
-	      if (index == view.length - 1) { return null }
-	      diff = (n + view[index].size) - oldN
-	      index++
-	    } else {
-	      diff = n - oldN
-	    }
-	    oldN += diff; newN += diff
-	  }
-	  while (visualLineNo(cm.doc, newN) != newN) {
-	    if (index == (dir < 0 ? 0 : view.length - 1)) { return null }
-	    newN += dir * view[index - (dir < 0 ? 1 : 0)].size
-	    index += dir
-	  }
-	  return {index: index, lineN: newN}
-	}
-
-	// Force the view to cover a given range, adding empty view element
-	// or clipping off existing ones as needed.
-	function adjustView(cm, from, to) {
-	  var display = cm.display, view = display.view
-	  if (view.length == 0 || from >= display.viewTo || to <= display.viewFrom) {
-	    display.view = buildViewArray(cm, from, to)
-	    display.viewFrom = from
-	  } else {
-	    if (display.viewFrom > from)
-	      { display.view = buildViewArray(cm, from, display.viewFrom).concat(display.view) }
-	    else if (display.viewFrom < from)
-	      { display.view = display.view.slice(findViewIndex(cm, from)) }
-	    display.viewFrom = from
-	    if (display.viewTo < to)
-	      { display.view = display.view.concat(buildViewArray(cm, display.viewTo, to)) }
-	    else if (display.viewTo > to)
-	      { display.view = display.view.slice(0, findViewIndex(cm, to)) }
-	  }
-	  display.viewTo = to
-	}
-
-	// Count the number of lines in the view whose DOM representation is
-	// out of date (or nonexistent).
-	function countDirtyView(cm) {
-	  var view = cm.display.view, dirty = 0
-	  for (var i = 0; i < view.length; i++) {
-	    var lineView = view[i]
-	    if (!lineView.hidden && (!lineView.node || lineView.changes)) { ++dirty }
-	  }
-	  return dirty
-	}
-
-	// HIGHLIGHT WORKER
-
-	function startWorker(cm, time) {
-	  if (cm.doc.mode.startState && cm.doc.frontier < cm.display.viewTo)
-	    { cm.state.highlight.set(time, bind(highlightWorker, cm)) }
-	}
-
-	function highlightWorker(cm) {
-	  var doc = cm.doc
-	  if (doc.frontier < doc.first) { doc.frontier = doc.first }
-	  if (doc.frontier >= cm.display.viewTo) { return }
-	  var end = +new Date + cm.options.workTime
-	  var state = copyState(doc.mode, getStateBefore(cm, doc.frontier))
-	  var changedLines = []
-
-	  doc.iter(doc.frontier, Math.min(doc.first + doc.size, cm.display.viewTo + 500), function (line) {
-	    if (doc.frontier >= cm.display.viewFrom) { // Visible
-	      var oldStyles = line.styles, tooLong = line.text.length > cm.options.maxHighlightLength
-	      var highlighted = highlightLine(cm, line, tooLong ? copyState(doc.mode, state) : state, true)
-	      line.styles = highlighted.styles
-	      var oldCls = line.styleClasses, newCls = highlighted.classes
-	      if (newCls) { line.styleClasses = newCls }
-	      else if (oldCls) { line.styleClasses = null }
-	      var ischange = !oldStyles || oldStyles.length != line.styles.length ||
-	        oldCls != newCls && (!oldCls || !newCls || oldCls.bgClass != newCls.bgClass || oldCls.textClass != newCls.textClass)
-	      for (var i = 0; !ischange && i < oldStyles.length; ++i) { ischange = oldStyles[i] != line.styles[i] }
-	      if (ischange) { changedLines.push(doc.frontier) }
-	      line.stateAfter = tooLong ? state : copyState(doc.mode, state)
-	    } else {
-	      if (line.text.length <= cm.options.maxHighlightLength)
-	        { processLine(cm, line.text, state) }
-	      line.stateAfter = doc.frontier % 5 == 0 ? copyState(doc.mode, state) : null
-	    }
-	    ++doc.frontier
-	    if (+new Date > end) {
-	      startWorker(cm, cm.options.workDelay)
-	      return true
-	    }
-	  })
-	  if (changedLines.length) { runInOp(cm, function () {
-	    for (var i = 0; i < changedLines.length; i++)
-	      { regLineChange(cm, changedLines[i], "text") }
-	  }) }
-	}
-
-	// DISPLAY DRAWING
-
-	function DisplayUpdate(cm, viewport, force) {
-	  var display = cm.display
-
-	  this.viewport = viewport
-	  // Store some values that we'll need later (but don't want to force a relayout for)
-	  this.visible = visibleLines(display, cm.doc, viewport)
-	  this.editorIsHidden = !display.wrapper.offsetWidth
-	  this.wrapperHeight = display.wrapper.clientHeight
-	  this.wrapperWidth = display.wrapper.clientWidth
-	  this.oldDisplayWidth = displayWidth(cm)
-	  this.force = force
-	  this.dims = getDimensions(cm)
-	  this.events = []
-	}
-
-	DisplayUpdate.prototype.signal = function(emitter, type) {
-	  if (hasHandler(emitter, type))
-	    { this.events.push(arguments) }
-	}
-	DisplayUpdate.prototype.finish = function() {
-	  var this$1 = this;
-
-	  for (var i = 0; i < this.events.length; i++)
-	    { signal.apply(null, this$1.events[i]) }
-	}
-
-	function maybeClipScrollbars(cm) {
-	  var display = cm.display
-	  if (!display.scrollbarsClipped && display.scroller.offsetWidth) {
-	    display.nativeBarWidth = display.scroller.offsetWidth - display.scroller.clientWidth
-	    display.heightForcer.style.height = scrollGap(cm) + "px"
-	    display.sizer.style.marginBottom = -display.nativeBarWidth + "px"
-	    display.sizer.style.borderRightWidth = scrollGap(cm) + "px"
-	    display.scrollbarsClipped = true
-	  }
-	}
-
-	// Does the actual updating of the line display. Bails out
-	// (returning false) when there is nothing to be done and forced is
-	// false.
-	function updateDisplayIfNeeded(cm, update) {
-	  var display = cm.display, doc = cm.doc
-
-	  if (update.editorIsHidden) {
-	    resetView(cm)
-	    return false
-	  }
-
-	  // Bail out if the visible area is already rendered and nothing changed.
-	  if (!update.force &&
-	      update.visible.from >= display.viewFrom && update.visible.to <= display.viewTo &&
-	      (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo) &&
-	      display.renderedView == display.view && countDirtyView(cm) == 0)
-	    { return false }
-
-	  if (maybeUpdateLineNumberWidth(cm)) {
-	    resetView(cm)
-	    update.dims = getDimensions(cm)
-	  }
-
-	  // Compute a suitable new viewport (from & to)
-	  var end = doc.first + doc.size
-	  var from = Math.max(update.visible.from - cm.options.viewportMargin, doc.first)
-	  var to = Math.min(end, update.visible.to + cm.options.viewportMargin)
-	  if (display.viewFrom < from && from - display.viewFrom < 20) { from = Math.max(doc.first, display.viewFrom) }
-	  if (display.viewTo > to && display.viewTo - to < 20) { to = Math.min(end, display.viewTo) }
-	  if (sawCollapsedSpans) {
-	    from = visualLineNo(cm.doc, from)
-	    to = visualLineEndNo(cm.doc, to)
-	  }
-
-	  var different = from != display.viewFrom || to != display.viewTo ||
-	    display.lastWrapHeight != update.wrapperHeight || display.lastWrapWidth != update.wrapperWidth
-	  adjustView(cm, from, to)
-
-	  display.viewOffset = heightAtLine(getLine(cm.doc, display.viewFrom))
-	  // Position the mover div to align with the current scroll position
-	  cm.display.mover.style.top = display.viewOffset + "px"
-
-	  var toUpdate = countDirtyView(cm)
-	  if (!different && toUpdate == 0 && !update.force && display.renderedView == display.view &&
-	      (display.updateLineNumbers == null || display.updateLineNumbers >= display.viewTo))
-	    { return false }
-
-	  // For big changes, we hide the enclosing element during the
-	  // update, since that speeds up the operations on most browsers.
-	  var focused = activeElt()
-	  if (toUpdate > 4) { display.lineDiv.style.display = "none" }
-	  patchDisplay(cm, display.updateLineNumbers, update.dims)
-	  if (toUpdate > 4) { display.lineDiv.style.display = "" }
-	  display.renderedView = display.view
-	  // There might have been a widget with a focused element that got
-	  // hidden or updated, if so re-focus it.
-	  if (focused && activeElt() != focused && focused.offsetHeight) { focused.focus() }
-
-	  // Prevent selection and cursors from interfering with the scroll
-	  // width and height.
-	  removeChildren(display.cursorDiv)
-	  removeChildren(display.selectionDiv)
-	  display.gutters.style.height = display.sizer.style.minHeight = 0
-
-	  if (different) {
-	    display.lastWrapHeight = update.wrapperHeight
-	    display.lastWrapWidth = update.wrapperWidth
-	    startWorker(cm, 400)
-	  }
-
-	  display.updateLineNumbers = null
-
-	  return true
-	}
-
-	function postUpdateDisplay(cm, update) {
-	  var viewport = update.viewport
-
-	  for (var first = true;; first = false) {
-	    if (!first || !cm.options.lineWrapping || update.oldDisplayWidth == displayWidth(cm)) {
-	      // Clip forced viewport to actual scrollable area.
-	      if (viewport && viewport.top != null)
-	        { viewport = {top: Math.min(cm.doc.height + paddingVert(cm.display) - displayHeight(cm), viewport.top)} }
-	      // Updated line heights might result in the drawn area not
-	      // actually covering the viewport. Keep looping until it does.
-	      update.visible = visibleLines(cm.display, cm.doc, viewport)
-	      if (update.visible.from >= cm.display.viewFrom && update.visible.to <= cm.display.viewTo)
-	        { break }
-	    }
-	    if (!updateDisplayIfNeeded(cm, update)) { break }
-	    updateHeightsInViewport(cm)
-	    var barMeasure = measureForScrollbars(cm)
-	    updateSelection(cm)
-	    updateScrollbars(cm, barMeasure)
-	    setDocumentHeight(cm, barMeasure)
-	  }
-
-	  update.signal(cm, "update", cm)
-	  if (cm.display.viewFrom != cm.display.reportedViewFrom || cm.display.viewTo != cm.display.reportedViewTo) {
-	    update.signal(cm, "viewportChange", cm, cm.display.viewFrom, cm.display.viewTo)
-	    cm.display.reportedViewFrom = cm.display.viewFrom; cm.display.reportedViewTo = cm.display.viewTo
-	  }
-	}
-
-	function updateDisplaySimple(cm, viewport) {
-	  var update = new DisplayUpdate(cm, viewport)
-	  if (updateDisplayIfNeeded(cm, update)) {
-	    updateHeightsInViewport(cm)
-	    postUpdateDisplay(cm, update)
-	    var barMeasure = measureForScrollbars(cm)
-	    updateSelection(cm)
-	    updateScrollbars(cm, barMeasure)
-	    setDocumentHeight(cm, barMeasure)
-	    update.finish()
-	  }
-	}
-
-	// Sync the actual display DOM structure with display.view, removing
-	// nodes for lines that are no longer in view, and creating the ones
-	// that are not there yet, and updating the ones that are out of
-	// date.
-	function patchDisplay(cm, updateNumbersFrom, dims) {
-	  var display = cm.display, lineNumbers = cm.options.lineNumbers
-	  var container = display.lineDiv, cur = container.firstChild
-
-	  function rm(node) {
-	    var next = node.nextSibling
-	    // Works around a throw-scroll bug in OS X Webkit
-	    if (webkit && mac && cm.display.currentWheelTarget == node)
-	      { node.style.display = "none" }
-	    else
-	      { node.parentNode.removeChild(node) }
-	    return next
-	  }
-
-	  var view = display.view, lineN = display.viewFrom
-	  // Loop over the elements in the view, syncing cur (the DOM nodes
-	  // in display.lineDiv) with the view as we go.
-	  for (var i = 0; i < view.length; i++) {
-	    var lineView = view[i]
-	    if (lineView.hidden) {
-	    } else if (!lineView.node || lineView.node.parentNode != container) { // Not drawn yet
-	      var node = buildLineElement(cm, lineView, lineN, dims)
-	      container.insertBefore(node, cur)
-	    } else { // Already drawn
-	      while (cur != lineView.node) { cur = rm(cur) }
-	      var updateNumber = lineNumbers && updateNumbersFrom != null &&
-	        updateNumbersFrom <= lineN && lineView.lineNumber
-	      if (lineView.changes) {
-	        if (indexOf(lineView.changes, "gutter") > -1) { updateNumber = false }
-	        updateLineForChanges(cm, lineView, lineN, dims)
-	      }
-	      if (updateNumber) {
-	        removeChildren(lineView.lineNumber)
-	        lineView.lineNumber.appendChild(document.createTextNode(lineNumberFor(cm.options, lineN)))
-	      }
-	      cur = lineView.node.nextSibling
-	    }
-	    lineN += lineView.size
-	  }
-	  while (cur) { cur = rm(cur) }
-	}
-
-	function updateGutterSpace(cm) {
-	  var width = cm.display.gutters.offsetWidth
-	  cm.display.sizer.style.marginLeft = width + "px"
-	}
-
-	function setDocumentHeight(cm, measure) {
-	  cm.display.sizer.style.minHeight = measure.docHeight + "px"
-	  cm.display.heightForcer.style.top = measure.docHeight + "px"
-	  cm.display.gutters.style.height = (measure.docHeight + cm.display.barHeight + scrollGap(cm)) + "px"
-	}
-
-	// Rebuild the gutter elements, ensure the margin to the left of the
-	// code matches their width.
-	function updateGutters(cm) {
-	  var gutters = cm.display.gutters, specs = cm.options.gutters
-	  removeChildren(gutters)
-	  var i = 0
-	  for (; i < specs.length; ++i) {
-	    var gutterClass = specs[i]
-	    var gElt = gutters.appendChild(elt("div", null, "CodeMirror-gutter " + gutterClass))
-	    if (gutterClass == "CodeMirror-linenumbers") {
-	      cm.display.lineGutter = gElt
-	      gElt.style.width = (cm.display.lineNumWidth || 1) + "px"
-	    }
-	  }
-	  gutters.style.display = i ? "" : "none"
-	  updateGutterSpace(cm)
-	}
-
-	// Make sure the gutters options contains the element
-	// "CodeMirror-linenumbers" when the lineNumbers option is true.
-	function setGuttersForLineNumbers(options) {
-	  var found = indexOf(options.gutters, "CodeMirror-linenumbers")
-	  if (found == -1 && options.lineNumbers) {
-	    options.gutters = options.gutters.concat(["CodeMirror-linenumbers"])
-	  } else if (found > -1 && !options.lineNumbers) {
-	    options.gutters = options.gutters.slice(0)
-	    options.gutters.splice(found, 1)
-	  }
-	}
-
-	// Selection objects are immutable. A new one is created every time
-	// the selection changes. A selection is one or more non-overlapping
-	// (and non-touching) ranges, sorted, and an integer that indicates
-	// which one is the primary selection (the one that's scrolled into
-	// view, that getCursor returns, etc).
-	function Selection(ranges, primIndex) {
-	  this.ranges = ranges
-	  this.primIndex = primIndex
-	}
-
-	Selection.prototype = {
-	  primary: function() { return this.ranges[this.primIndex] },
-	  equals: function(other) {
-	    var this$1 = this;
-
-	    if (other == this) { return true }
-	    if (other.primIndex != this.primIndex || other.ranges.length != this.ranges.length) { return false }
-	    for (var i = 0; i < this.ranges.length; i++) {
-	      var here = this$1.ranges[i], there = other.ranges[i]
-	      if (cmp(here.anchor, there.anchor) != 0 || cmp(here.head, there.head) != 0) { return false }
-	    }
-	    return true
-	  },
-	  deepCopy: function() {
-	    var this$1 = this;
-
-	    var out = []
-	    for (var i = 0; i < this.ranges.length; i++)
-	      { out[i] = new Range(copyPos(this$1.ranges[i].anchor), copyPos(this$1.ranges[i].head)) }
-	    return new Selection(out, this.primIndex)
-	  },
-	  somethingSelected: function() {
-	    var this$1 = this;
-
-	    for (var i = 0; i < this.ranges.length; i++)
-	      { if (!this$1.ranges[i].empty()) { return true } }
-	    return false
-	  },
-	  contains: function(pos, end) {
-	    var this$1 = this;
-
-	    if (!end) { end = pos }
-	    for (var i = 0; i < this.ranges.length; i++) {
-	      var range = this$1.ranges[i]
-	      if (cmp(end, range.from()) >= 0 && cmp(pos, range.to()) <= 0)
-	        { return i }
-	    }
-	    return -1
-	  }
-	}
-
-	function Range(anchor, head) {
-	  this.anchor = anchor; this.head = head
-	}
-
-	Range.prototype = {
-	  from: function() { return minPos(this.anchor, this.head) },
-	  to: function() { return maxPos(this.anchor, this.head) },
-	  empty: function() {
-	    return this.head.line == this.anchor.line && this.head.ch == this.anchor.ch
-	  }
-	}
-
-	// Take an unsorted, potentially overlapping set of ranges, and
-	// build a selection out of it. 'Consumes' ranges array (modifying
-	// it).
-	function normalizeSelection(ranges, primIndex) {
-	  var prim = ranges[primIndex]
-	  ranges.sort(function (a, b) { return cmp(a.from(), b.from()); })
-	  primIndex = indexOf(ranges, prim)
-	  for (var i = 1; i < ranges.length; i++) {
-	    var cur = ranges[i], prev = ranges[i - 1]
-	    if (cmp(prev.to(), cur.from()) >= 0) {
-	      var from = minPos(prev.from(), cur.from()), to = maxPos(prev.to(), cur.to())
-	      var inv = prev.empty() ? cur.from() == cur.head : prev.from() == prev.head
-	      if (i <= primIndex) { --primIndex }
-	      ranges.splice(--i, 2, new Range(inv ? to : from, inv ? from : to))
-	    }
-	  }
-	  return new Selection(ranges, primIndex)
-	}
-
-	function simpleSelection(anchor, head) {
-	  return new Selection([new Range(anchor, head || anchor)], 0)
-	}
-
-	// Compute the position of the end of a change (its 'to' property
-	// refers to the pre-change end).
-	function changeEnd(change) {
-	  if (!change.text) { return change.to }
-	  return Pos(change.from.line + change.text.length - 1,
-	             lst(change.text).length + (change.text.length == 1 ? change.from.ch : 0))
-	}
-
-	// Adjust a position to refer to the post-change position of the
-	// same text, or the end of the change if the change covers it.
-	function adjustForChange(pos, change) {
-	  if (cmp(pos, change.from) < 0) { return pos }
-	  if (cmp(pos, change.to) <= 0) { return changeEnd(change) }
-
-	  var line = pos.line + change.text.length - (change.to.line - change.from.line) - 1, ch = pos.ch
-	  if (pos.line == change.to.line) { ch += changeEnd(change).ch - change.to.ch }
-	  return Pos(line, ch)
-	}
-
-	function computeSelAfterChange(doc, change) {
-	  var out = []
-	  for (var i = 0; i < doc.sel.ranges.length; i++) {
-	    var range = doc.sel.ranges[i]
-	    out.push(new Range(adjustForChange(range.anchor, change),
-	                       adjustForChange(range.head, change)))
-	  }
-	  return normalizeSelection(out, doc.sel.primIndex)
-	}
-
-	function offsetPos(pos, old, nw) {
-	  if (pos.line == old.line)
-	    { return Pos(nw.line, pos.ch - old.ch + nw.ch) }
-	  else
-	    { return Pos(nw.line + (pos.line - old.line), pos.ch) }
-	}
-
-	// Used by replaceSelections to allow moving the selection to the
-	// start or around the replaced test. Hint may be "start" or "around".
-	function computeReplacedSel(doc, changes, hint) {
-	  var out = []
-	  var oldPrev = Pos(doc.first, 0), newPrev = oldPrev
-	  for (var i = 0; i < changes.length; i++) {
-	    var change = changes[i]
-	    var from = offsetPos(change.from, oldPrev, newPrev)
-	    var to = offsetPos(changeEnd(change), oldPrev, newPrev)
-	    oldPrev = change.to
-	    newPrev = to
-	    if (hint == "around") {
-	      var range = doc.sel.ranges[i], inv = cmp(range.head, range.anchor) < 0
-	      out[i] = new Range(inv ? to : from, inv ? from : to)
-	    } else {
-	      out[i] = new Range(from, from)
-	    }
-	  }
-	  return new Selection(out, doc.sel.primIndex)
-	}
-
-	// Used to get the editor into a consistent state again when options change.
-
-	function loadMode(cm) {
-	  cm.doc.mode = getMode(cm.options, cm.doc.modeOption)
-	  resetModeState(cm)
-	}
-
-	function resetModeState(cm) {
-	  cm.doc.iter(function (line) {
-	    if (line.stateAfter) { line.stateAfter = null }
-	    if (line.styles) { line.styles = null }
-	  })
-	  cm.doc.frontier = cm.doc.first
-	  startWorker(cm, 100)
-	  cm.state.modeGen++
-	  if (cm.curOp) { regChange(cm) }
-	}
-
-	// DOCUMENT DATA STRUCTURE
-
-	// By default, updates that start and end at the beginning of a line
-	// are treated specially, in order to make the association of line
-	// widgets and marker elements with the text behave more intuitive.
-	function isWholeLineUpdate(doc, change) {
-	  return change.from.ch == 0 && change.to.ch == 0 && lst(change.text) == "" &&
-	    (!doc.cm || doc.cm.options.wholeLineUpdateBefore)
-	}
-
-	// Perform a change on the document data structure.
-	function updateDoc(doc, change, markedSpans, estimateHeight) {
-	  function spansFor(n) {return markedSpans ? markedSpans[n] : null}
-	  function update(line, text, spans) {
-	    updateLine(line, text, spans, estimateHeight)
-	    signalLater(line, "change", line, change)
-	  }
-	  function linesFor(start, end) {
-	    var result = []
-	    for (var i = start; i < end; ++i)
-	      { result.push(new Line(text[i], spansFor(i), estimateHeight)) }
-	    return result
-	  }
-
-	  var from = change.from, to = change.to, text = change.text
-	  var firstLine = getLine(doc, from.line), lastLine = getLine(doc, to.line)
-	  var lastText = lst(text), lastSpans = spansFor(text.length - 1), nlines = to.line - from.line
-
-	  // Adjust the line structure
-	  if (change.full) {
-	    doc.insert(0, linesFor(0, text.length))
-	    doc.remove(text.length, doc.size - text.length)
-	  } else if (isWholeLineUpdate(doc, change)) {
-	    // This is a whole-line replace. Treated specially to make
-	    // sure line objects move the way they are supposed to.
-	    var added = linesFor(0, text.length - 1)
-	    update(lastLine, lastLine.text, lastSpans)
-	    if (nlines) { doc.remove(from.line, nlines) }
-	    if (added.length) { doc.insert(from.line, added) }
-	  } else if (firstLine == lastLine) {
-	    if (text.length == 1) {
-	      update(firstLine, firstLine.text.slice(0, from.ch) + lastText + firstLine.text.slice(to.ch), lastSpans)
-	    } else {
-	      var added$1 = linesFor(1, text.length - 1)
-	      added$1.push(new Line(lastText + firstLine.text.slice(to.ch), lastSpans, estimateHeight))
-	      update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0))
-	      doc.insert(from.line + 1, added$1)
-	    }
-	  } else if (text.length == 1) {
-	    update(firstLine, firstLine.text.slice(0, from.ch) + text[0] + lastLine.text.slice(to.ch), spansFor(0))
-	    doc.remove(from.line + 1, nlines)
-	  } else {
-	    update(firstLine, firstLine.text.slice(0, from.ch) + text[0], spansFor(0))
-	    update(lastLine, lastText + lastLine.text.slice(to.ch), lastSpans)
-	    var added$2 = linesFor(1, text.length - 1)
-	    if (nlines > 1) { doc.remove(from.line + 1, nlines - 1) }
-	    doc.insert(from.line + 1, added$2)
-	  }
-
-	  signalLater(doc, "change", doc, change)
-	}
-
-	// Call f for all linked documents.
-	function linkedDocs(doc, f, sharedHistOnly) {
-	  function propagate(doc, skip, sharedHist) {
-	    if (doc.linked) { for (var i = 0; i < doc.linked.length; ++i) {
-	      var rel = doc.linked[i]
-	      if (rel.doc == skip) { continue }
-	      var shared = sharedHist && rel.sharedHist
-	      if (sharedHistOnly && !shared) { continue }
-	      f(rel.doc, shared)
-	      propagate(rel.doc, doc, shared)
-	    } }
-	  }
-	  propagate(doc, null, true)
-	}
-
-	// Attach a document to an editor.
-	function attachDoc(cm, doc) {
-	  if (doc.cm) { throw new Error("This document is already in use.") }
-	  cm.doc = doc
-	  doc.cm = cm
-	  estimateLineHeights(cm)
-	  loadMode(cm)
-	  if (!cm.options.lineWrapping) { findMaxLine(cm) }
-	  cm.options.mode = doc.modeOption
-	  regChange(cm)
-	}
-
-	function History(startGen) {
-	  // Arrays of change events and selections. Doing something adds an
-	  // event to done and clears undo. Undoing moves events from done
-	  // to undone, redoing moves them in the other direction.
-	  this.done = []; this.undone = []
-	  this.undoDepth = Infinity
-	  // Used to track when changes can be merged into a single undo
-	  // event
-	  this.lastModTime = this.lastSelTime = 0
-	  this.lastOp = this.lastSelOp = null
-	  this.lastOrigin = this.lastSelOrigin = null
-	  // Used by the isClean() method
-	  this.generation = this.maxGeneration = startGen || 1
-	}
-
-	// Create a history change event from an updateDoc-style change
-	// object.
-	function historyChangeFromChange(doc, change) {
-	  var histChange = {from: copyPos(change.from), to: changeEnd(change), text: getBetween(doc, change.from, change.to)}
-	  attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1)
-	  linkedDocs(doc, function (doc) { return attachLocalSpans(doc, histChange, change.from.line, change.to.line + 1); }, true)
-	  return histChange
-	}
-
-	// Pop all selection events off the end of a history array. Stop at
-	// a change event.
-	function clearSelectionEvents(array) {
-	  while (array.length) {
-	    var last = lst(array)
-	    if (last.ranges) { array.pop() }
-	    else { break }
-	  }
-	}
-
-	// Find the top change event in the history. Pop off selection
-	// events that are in the way.
-	function lastChangeEvent(hist, force) {
-	  if (force) {
-	    clearSelectionEvents(hist.done)
-	    return lst(hist.done)
-	  } else if (hist.done.length && !lst(hist.done).ranges) {
-	    return lst(hist.done)
-	  } else if (hist.done.length > 1 && !hist.done[hist.done.length - 2].ranges) {
-	    hist.done.pop()
-	    return lst(hist.done)
-	  }
-	}
-
-	// Register a change in the history. Merges changes that are within
-	// a single operation, or are close together with an origin that
-	// allows merging (starting with "+") into a single event.
-	function addChangeToHistory(doc, change, selAfter, opId) {
-	  var hist = doc.history
-	  hist.undone.length = 0
-	  var time = +new Date, cur
-	  var last
-
-	  if ((hist.lastOp == opId ||
-	       hist.lastOrigin == change.origin && change.origin &&
-	       ((change.origin.charAt(0) == "+" && doc.cm && hist.lastModTime > time - doc.cm.options.historyEventDelay) ||
-	        change.origin.charAt(0) == "*")) &&
-	      (cur = lastChangeEvent(hist, hist.lastOp == opId))) {
-	    // Merge this change into the last event
-	    last = lst(cur.changes)
-	    if (cmp(change.from, change.to) == 0 && cmp(change.from, last.to) == 0) {
-	      // Optimized case for simple insertion -- don't want to add
-	      // new changesets for every character typed
-	      last.to = changeEnd(change)
-	    } else {
-	      // Add new sub-event
-	      cur.changes.push(historyChangeFromChange(doc, change))
-	    }
-	  } else {
-	    // Can not be merged, start a new event.
-	    var before = lst(hist.done)
-	    if (!before || !before.ranges)
-	      { pushSelectionToHistory(doc.sel, hist.done) }
-	    cur = {changes: [historyChangeFromChange(doc, change)],
-	           generation: hist.generation}
-	    hist.done.push(cur)
-	    while (hist.done.length > hist.undoDepth) {
-	      hist.done.shift()
-	      if (!hist.done[0].ranges) { hist.done.shift() }
-	    }
-	  }
-	  hist.done.push(selAfter)
-	  hist.generation = ++hist.maxGeneration
-	  hist.lastModTime = hist.lastSelTime = time
-	  hist.lastOp = hist.lastSelOp = opId
-	  hist.lastOrigin = hist.lastSelOrigin = change.origin
-
-	  if (!last) { signal(doc, "historyAdded") }
-	}
-
-	function selectionEventCanBeMerged(doc, origin, prev, sel) {
-	  var ch = origin.charAt(0)
-	  return ch == "*" ||
-	    ch == "+" &&
-	    prev.ranges.length == sel.ranges.length &&
-	    prev.somethingSelected() == sel.somethingSelected() &&
-	    new Date - doc.history.lastSelTime <= (doc.cm ? doc.cm.options.historyEventDelay : 500)
-	}
-
-	// Called whenever the selection changes, sets the new selection as
-	// the pending selection in the history, and pushes the old pending
-	// selection into the 'done' array when it was significantly
-	// different (in number of selected ranges, emptiness, or time).
-	function addSelectionToHistory(doc, sel, opId, options) {
-	  var hist = doc.history, origin = options && options.origin
-
-	  // A new event is started when the previous origin does not match
-	  // the current, or the origins don't allow matching. Origins
-	  // starting with * are always merged, those starting with + are
-	  // merged when similar and close together in time.
-	  if (opId == hist.lastSelOp ||
-	      (origin && hist.lastSelOrigin == origin &&
-	       (hist.lastModTime == hist.lastSelTime && hist.lastOrigin == origin ||
-	        selectionEventCanBeMerged(doc, origin, lst(hist.done), sel))))
-	    { hist.done[hist.done.length - 1] = sel }
-	  else
-	    { pushSelectionToHistory(sel, hist.done) }
-
-	  hist.lastSelTime = +new Date
-	  hist.lastSelOrigin = origin
-	  hist.lastSelOp = opId
-	  if (options && options.clearRedo !== false)
-	    { clearSelectionEvents(hist.undone) }
-	}
-
-	function pushSelectionToHistory(sel, dest) {
-	  var top = lst(dest)
-	  if (!(top && top.ranges && top.equals(sel)))
-	    { dest.push(sel) }
-	}
-
-	// Used to store marked span information in the history.
-	function attachLocalSpans(doc, change, from, to) {
-	  var existing = change["spans_" + doc.id], n = 0
-	  doc.iter(Math.max(doc.first, from), Math.min(doc.first + doc.size, to), function (line) {
-	    if (line.markedSpans)
-	      { (existing || (existing = change["spans_" + doc.id] = {}))[n] = line.markedSpans }
-	    ++n
-	  })
-	}
-
-	// When un/re-doing restores text containing marked spans, those
-	// that have been explicitly cleared should not be restored.
-	function removeClearedSpans(spans) {
-	  if (!spans) { return null }
-	  var out
-	  for (var i = 0; i < spans.length; ++i) {
-	    if (spans[i].marker.explicitlyCleared) { if (!out) { out = spans.slice(0, i) } }
-	    else if (out) { out.push(spans[i]) }
-	  }
-	  return !out ? spans : out.length ? out : null
-	}
-
-	// Retrieve and filter the old marked spans stored in a change event.
-	function getOldSpans(doc, change) {
-	  var found = change["spans_" + doc.id]
-	  if (!found) { return null }
-	  var nw = []
-	  for (var i = 0; i < change.text.length; ++i)
-	    { nw.push(removeClearedSpans(found[i])) }
-	  return nw
-	}
-
-	// Used for un/re-doing changes from the history. Combines the
-	// result of computing the existing spans with the set of spans that
-	// existed in the history (so that deleting around a span and then
-	// undoing brings back the span).
-	function mergeOldSpans(doc, change) {
-	  var old = getOldSpans(doc, change)
-	  var stretched = stretchSpansOverChange(doc, change)
-	  if (!old) { return stretched }
-	  if (!stretched) { return old }
-
-	  for (var i = 0; i < old.length; ++i) {
-	    var oldCur = old[i], stretchCur = stretched[i]
-	    if (oldCur && stretchCur) {
-	      spans: for (var j = 0; j < stretchCur.length; ++j) {
-	        var span = stretchCur[j]
-	        for (var k = 0; k < oldCur.length; ++k)
-	          { if (oldCur[k].marker == span.marker) { continue spans } }
-	        oldCur.push(span)
-	      }
-	    } else if (stretchCur) {
-	      old[i] = stretchCur
-	    }
-	  }
-	  return old
-	}
-
-	// Used both to provide a JSON-safe object in .getHistory, and, when
-	// detaching a document, to split the history in two
-	function copyHistoryArray(events, newGroup, instantiateSel) {
-	  var copy = []
-	  for (var i = 0; i < events.length; ++i) {
-	    var event = events[i]
-	    if (event.ranges) {
-	      copy.push(instantiateSel ? Selection.prototype.deepCopy.call(event) : event)
-	      continue
-	    }
-	    var changes = event.changes, newChanges = []
-	    copy.push({changes: newChanges})
-	    for (var j = 0; j < changes.length; ++j) {
-	      var change = changes[j], m = (void 0)
-	      newChanges.push({from: change.from, to: change.to, text: change.text})
-	      if (newGroup) { for (var prop in change) { if (m = prop.match(/^spans_(\d+)$/)) {
-	        if (indexOf(newGroup, Number(m[1])) > -1) {
-	          lst(newChanges)[prop] = change[prop]
-	          delete change[prop]
-	        }
-	      } } }
-	    }
-	  }
-	  return copy
-	}
-
-	// The 'scroll' parameter given to many of these indicated whether
-	// the new cursor position should be scrolled into view after
-	// modifying the selection.
-
-	// If shift is held or the extend flag is set, extends a range to
-	// include a given position (and optionally a second position).
-	// Otherwise, simply returns the range between the given positions.
-	// Used for cursor motion and such.
-	function extendRange(doc, range, head, other) {
-	  if (doc.cm && doc.cm.display.shift || doc.extend) {
-	    var anchor = range.anchor
-	    if (other) {
-	      var posBefore = cmp(head, anchor) < 0
-	      if (posBefore != (cmp(other, anchor) < 0)) {
-	        anchor = head
-	        head = other
-	      } else if (posBefore != (cmp(head, other) < 0)) {
-	        head = other
-	      }
-	    }
-	    return new Range(anchor, head)
-	  } else {
-	    return new Range(other || head, head)
-	  }
-	}
-
-	// Extend the primary selection range, discard the rest.
-	function extendSelection(doc, head, other, options) {
-	  setSelection(doc, new Selection([extendRange(doc, doc.sel.primary(), head, other)], 0), options)
-	}
-
-	// Extend all selections (pos is an array of selections with length
-	// equal the number of selections)
-	function extendSelections(doc, heads, options) {
-	  var out = []
-	  for (var i = 0; i < doc.sel.ranges.length; i++)
-	    { out[i] = extendRange(doc, doc.sel.ranges[i], heads[i], null) }
-	  var newSel = normalizeSelection(out, doc.sel.primIndex)
-	  setSelection(doc, newSel, options)
-	}
-
-	// Updates a single range in the selection.
-	function replaceOneSelection(doc, i, range, options) {
-	  var ranges = doc.sel.ranges.slice(0)
-	  ranges[i] = range
-	  setSelection(doc, normalizeSelection(ranges, doc.sel.primIndex), options)
-	}
-
-	// Reset the selection to a single range.
-	function setSimpleSelection(doc, anchor, head, options) {
-	  setSelection(doc, simpleSelection(anchor, head), options)
-	}
-
-	// Give beforeSelectionChange handlers a change to influence a
-	// selection update.
-	function filterSelectionChange(doc, sel, options) {
-	  var obj = {
-	    ranges: sel.ranges,
-	    update: function(ranges) {
-	      var this$1 = this;
-
-	      this.ranges = []
-	      for (var i = 0; i < ranges.length; i++)
-	        { this$1.ranges[i] = new Range(clipPos(doc, ranges[i].anchor),
-	                                   clipPos(doc, ranges[i].head)) }
-	    },
-	    origin: options && options.origin
-	  }
-	  signal(doc, "beforeSelectionChange", doc, obj)
-	  if (doc.cm) { signal(doc.cm, "beforeSelectionChange", doc.cm, obj) }
-	  if (obj.ranges != sel.ranges) { return normalizeSelection(obj.ranges, obj.ranges.length - 1) }
-	  else { return sel }
-	}
-
-	function setSelectionReplaceHistory(doc, sel, options) {
-	  var done = doc.history.done, last = lst(done)
-	  if (last && last.ranges) {
-	    done[done.length - 1] = sel
-	    setSelectionNoUndo(doc, sel, options)
-	  } else {
-	    setSelection(doc, sel, options)
-	  }
-	}
-
-	// Set a new selection.
-	function setSelection(doc, sel, options) {
-	  setSelectionNoUndo(doc, sel, options)
-	  addSelectionToHistory(doc, doc.sel, doc.cm ? doc.cm.curOp.id : NaN, options)
-	}
-
-	function setSelectionNoUndo(doc, sel, options) {
-	  if (hasHandler(doc, "beforeSelectionChange") || doc.cm && hasHandler(doc.cm, "beforeSelectionChange"))
-	    { sel = filterSelectionChange(doc, sel, options) }
-
-	  var bias = options && options.bias ||
-	    (cmp(sel.primary().head, doc.sel.primary().head) < 0 ? -1 : 1)
-	  setSelectionInner(doc, skipAtomicInSelection(doc, sel, bias, true))
-
-	  if (!(options && options.scroll === false) && doc.cm)
-	    { ensureCursorVisible(doc.cm) }
-	}
-
-	function setSelectionInner(doc, sel) {
-	  if (sel.equals(doc.sel)) { return }
-
-	  doc.sel = sel
-
-	  if (doc.cm) {
-	    doc.cm.curOp.updateInput = doc.cm.curOp.selectionChanged = true
-	    signalCursorActivity(doc.cm)
-	  }
-	  signalLater(doc, "cursorActivity", doc)
-	}
-
-	// Verify that the selection does not partially select any atomic
-	// marked ranges.
-	function reCheckSelection(doc) {
-	  setSelectionInner(doc, skipAtomicInSelection(doc, doc.sel, null, false), sel_dontScroll)
-	}
-
-	// Return a selection that does not partially select any atomic
-	// ranges.
-	function skipAtomicInSelection(doc, sel, bias, mayClear) {
-	  var out
-	  for (var i = 0; i < sel.ranges.length; i++) {
-	    var range = sel.ranges[i]
-	    var old = sel.ranges.length == doc.sel.ranges.length && doc.sel.ranges[i]
-	    var newAnchor = skipAtomic(doc, range.anchor, old && old.anchor, bias, mayClear)
-	    var newHead = skipAtomic(doc, range.head, old && old.head, bias, mayClear)
-	    if (out || newAnchor != range.anchor || newHead != range.head) {
-	      if (!out) { out = sel.ranges.slice(0, i) }
-	      out[i] = new Range(newAnchor, newHead)
-	    }
-	  }
-	  return out ? normalizeSelection(out, sel.primIndex) : sel
-	}
-
-	function skipAtomicInner(doc, pos, oldPos, dir, mayClear) {
-	  var line = getLine(doc, pos.line)
-	  if (line.markedSpans) { for (var i = 0; i < line.markedSpans.length; ++i) {
-	    var sp = line.markedSpans[i], m = sp.marker
-	    if ((sp.from == null || (m.inclusiveLeft ? sp.from <= pos.ch : sp.from < pos.ch)) &&
-	        (sp.to == null || (m.inclusiveRight ? sp.to >= pos.ch : sp.to > pos.ch))) {
-	      if (mayClear) {
-	        signal(m, "beforeCursorEnter")
-	        if (m.explicitlyCleared) {
-	          if (!line.markedSpans) { break }
-	          else {--i; continue}
-	        }
-	      }
-	      if (!m.atomic) { continue }
-
-	      if (oldPos) {
-	        var near = m.find(dir < 0 ? 1 : -1), diff = (void 0)
-	        if (dir < 0 ? m.inclusiveRight : m.inclusiveLeft)
-	          { near = movePos(doc, near, -dir, near && near.line == pos.line ? line : null) }
-	        if (near && near.line == pos.line && (diff = cmp(near, oldPos)) && (dir < 0 ? diff < 0 : diff > 0))
-	          { return skipAtomicInner(doc, near, pos, dir, mayClear) }
-	      }
-
-	      var far = m.find(dir < 0 ? -1 : 1)
-	      if (dir < 0 ? m.inclusiveLeft : m.inclusiveRight)
-	        { far = movePos(doc, far, dir, far.line == pos.line ? line : null) }
-	      return far ? skipAtomicInner(doc, far, pos, dir, mayClear) : null
-	    }
-	  } }
-	  return pos
-	}
-
-	// Ensure a given position is not inside an atomic range.
-	function skipAtomic(doc, pos, oldPos, bias, mayClear) {
-	  var dir = bias || 1
-	  var found = skipAtomicInner(doc, pos, oldPos, dir, mayClear) ||
-	      (!mayClear && skipAtomicInner(doc, pos, oldPos, dir, true)) ||
-	      skipAtomicInner(doc, pos, oldPos, -dir, mayClear) ||
-	      (!mayClear && skipAtomicInner(doc, pos, oldPos, -dir, true))
-	  if (!found) {
-	    doc.cantEdit = true
-	    return Pos(doc.first, 0)
-	  }
-	  return found
-	}
-
-	function movePos(doc, pos, dir, line) {
-	  if (dir < 0 && pos.ch == 0) {
-	    if (pos.line > doc.first) { return clipPos(doc, Pos(pos.line - 1)) }
-	    else { return null }
-	  } else if (dir > 0 && pos.ch == (line || getLine(doc, pos.line)).text.length) {
-	    if (pos.line < doc.first + doc.size - 1) { return Pos(pos.line + 1, 0) }
-	    else { return null }
-	  } else {
-	    return new Pos(pos.line, pos.ch + dir)
-	  }
-	}
-
-	function selectAll(cm) {
-	  cm.setSelection(Pos(cm.firstLine(), 0), Pos(cm.lastLine()), sel_dontScroll)
-	}
-
-	// UPDATING
-
-	// Allow "beforeChange" event handlers to influence a change
-	function filterChange(doc, change, update) {
-	  var obj = {
-	    canceled: false,
-	    from: change.from,
-	    to: change.to,
-	    text: change.text,
-	    origin: change.origin,
-	    cancel: function () { return obj.canceled = true; }
-	  }
-	  if (update) { obj.update = function (from, to, text, origin) {
-	    if (from) { obj.from = clipPos(doc, from) }
-	    if (to) { obj.to = clipPos(doc, to) }
-	    if (text) { obj.text = text }
-	    if (origin !== undefined) { obj.origin = origin }
-	  } }
-	  signal(doc, "beforeChange", doc, obj)
-	  if (doc.cm) { signal(doc.cm, "beforeChange", doc.cm, obj) }
-
-	  if (obj.canceled) { return null }
-	  return {from: obj.from, to: obj.to, text: obj.text, origin: obj.origin}
-	}
-
-	// Apply a change to a document, and add it to the document's
-	// history, and propagating it to all linked documents.
-	function makeChange(doc, change, ignoreReadOnly) {
-	  if (doc.cm) {
-	    if (!doc.cm.curOp) { return operation(doc.cm, makeChange)(doc, change, ignoreReadOnly) }
-	    if (doc.cm.state.suppressEdits) { return }
-	  }
-
-	  if (hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange")) {
-	    change = filterChange(doc, change, true)
-	    if (!change) { return }
-	  }
-
-	  // Possibly split or suppress the update based on the presence
-	  // of read-only spans in its range.
-	  var split = sawReadOnlySpans && !ignoreReadOnly && removeReadOnlyRanges(doc, change.from, change.to)
-	  if (split) {
-	    for (var i = split.length - 1; i >= 0; --i)
-	      { makeChangeInner(doc, {from: split[i].from, to: split[i].to, text: i ? [""] : change.text}) }
-	  } else {
-	    makeChangeInner(doc, change)
-	  }
-	}
-
-	function makeChangeInner(doc, change) {
-	  if (change.text.length == 1 && change.text[0] == "" && cmp(change.from, change.to) == 0) { return }
-	  var selAfter = computeSelAfterChange(doc, change)
-	  addChangeToHistory(doc, change, selAfter, doc.cm ? doc.cm.curOp.id : NaN)
-
-	  makeChangeSingleDoc(doc, change, selAfter, stretchSpansOverChange(doc, change))
-	  var rebased = []
-
-	  linkedDocs(doc, function (doc, sharedHist) {
-	    if (!sharedHist && indexOf(rebased, doc.history) == -1) {
-	      rebaseHist(doc.history, change)
-	      rebased.push(doc.history)
-	    }
-	    makeChangeSingleDoc(doc, change, null, stretchSpansOverChange(doc, change))
-	  })
-	}
-
-	// Revert a change stored in a document's history.
-	function makeChangeFromHistory(doc, type, allowSelectionOnly) {
-	  if (doc.cm && doc.cm.state.suppressEdits && !allowSelectionOnly) { return }
-
-	  var hist = doc.history, event, selAfter = doc.sel
-	  var source = type == "undo" ? hist.done : hist.undone, dest = type == "undo" ? hist.undone : hist.done
-
-	  // Verify that there is a useable event (so that ctrl-z won't
-	  // needlessly clear selection events)
-	  var i = 0
-	  for (; i < source.length; i++) {
-	    event = source[i]
-	    if (allowSelectionOnly ? event.ranges && !event.equals(doc.sel) : !event.ranges)
-	      { break }
-	  }
-	  if (i == source.length) { return }
-	  hist.lastOrigin = hist.lastSelOrigin = null
-
-	  for (;;) {
-	    event = source.pop()
-	    if (event.ranges) {
-	      pushSelectionToHistory(event, dest)
-	      if (allowSelectionOnly && !event.equals(doc.sel)) {
-	        setSelection(doc, event, {clearRedo: false})
-	        return
-	      }
-	      selAfter = event
-	    }
-	    else { break }
-	  }
-
-	  // Build up a reverse change object to add to the opposite history
-	  // stack (redo when undoing, and vice versa).
-	  var antiChanges = []
-	  pushSelectionToHistory(selAfter, dest)
-	  dest.push({changes: antiChanges, generation: hist.generation})
-	  hist.generation = event.generation || ++hist.maxGeneration
-
-	  var filter = hasHandler(doc, "beforeChange") || doc.cm && hasHandler(doc.cm, "beforeChange")
-
-	  var loop = function ( i ) {
-	    var change = event.changes[i]
-	    change.origin = type
-	    if (filter && !filterChange(doc, change, false)) {
-	      source.length = 0
-	      return {}
-	    }
-
-	    antiChanges.push(historyChangeFromChange(doc, change))
-
-	    var after = i ? computeSelAfterChange(doc, change) : lst(source)
-	    makeChangeSingleDoc(doc, change, after, mergeOldSpans(doc, change))
-	    if (!i && doc.cm) { doc.cm.scrollIntoView({from: change.from, to: changeEnd(change)}) }
-	    var rebased = []
-
-	    // Propagate to the linked documents
-	    linkedDocs(doc, function (doc, sharedHist) {
-	      if (!sharedHist && indexOf(rebased, doc.history) == -1) {
-	        rebaseHist(doc.history, change)
-	        rebased.push(doc.history)
-	      }
-	      makeChangeSingleDoc(doc, change, null, mergeOldSpans(doc, change))
-	    })
-	  };
-
-	  for (var i$1 = event.changes.length - 1; i$1 >= 0; --i$1) {
-	    var returned = loop( i$1 );
-
-	    if ( returned ) return returned.v;
-	  }
-	}
-
-	// Sub-views need their line numbers shifted when text is added
-	// above or below them in the parent document.
-	function shiftDoc(doc, distance) {
-	  if (distance == 0) { return }
-	  doc.first += distance
-	  doc.sel = new Selection(map(doc.sel.ranges, function (range) { return new Range(
-	    Pos(range.anchor.line + distance, range.anchor.ch),
-	    Pos(range.head.line + distance, range.head.ch)
-	  ); }), doc.sel.primIndex)
-	  if (doc.cm) {
-	    regChange(doc.cm, doc.first, doc.first - distance, distance)
-	    for (var d = doc.cm.display, l = d.viewFrom; l < d.viewTo; l++)
-	      { regLineChange(doc.cm, l, "gutter") }
-	  }
-	}
-
-	// More lower-level change function, handling only a single document
-	// (not linked ones).
-	function makeChangeSingleDoc(doc, change, selAfter, spans) {
-	  if (doc.cm && !doc.cm.curOp)
-	    { return operation(doc.cm, makeChangeSingleDoc)(doc, change, selAfter, spans) }
-
-	  if (change.to.line < doc.first) {
-	    shiftDoc(doc, change.text.length - 1 - (change.to.line - change.from.line))
-	    return
-	  }
-	  if (change.from.line > doc.lastLine()) { return }
-
-	  // Clip the change to the size of this doc
-	  if (change.from.line < doc.first) {
-	    var shift = change.text.length - 1 - (doc.first - change.from.line)
-	    shiftDoc(doc, shift)
-	    change = {from: Pos(doc.first, 0), to: Pos(change.to.line + shift, change.to.ch),
-	              text: [lst(change.text)], origin: change.origin}
-	  }
-	  var last = doc.lastLine()
-	  if (change.to.line > last) {
-	    change = {from: change.from, to: Pos(last, getLine(doc, last).text.length),
-	              text: [change.text[0]], origin: change.origin}
-	  }
-
-	  change.removed = getBetween(doc, change.from, change.to)
-
-	  if (!selAfter) { selAfter = computeSelAfterChange(doc, change) }
-	  if (doc.cm) { makeChangeSingleDocInEditor(doc.cm, change, spans) }
-	  else { updateDoc(doc, change, spans) }
-	  setSelectionNoUndo(doc, selAfter, sel_dontScroll)
-	}
-
-	// Handle the interaction of a change to a document with the editor
-	// that this document is part of.
-	function makeChangeSingleDocInEditor(cm, change, spans) {
-	  var doc = cm.doc, display = cm.display, from = change.from, to = change.to
-
-	  var recomputeMaxLength = false, checkWidthStart = from.line
-	  if (!cm.options.lineWrapping) {
-	    checkWidthStart = lineNo(visualLine(getLine(doc, from.line)))
-	    doc.iter(checkWidthStart, to.line + 1, function (line) {
-	      if (line == display.maxLine) {
-	        recomputeMaxLength = true
-	        return true
-	      }
-	    })
-	  }
-
-	  if (doc.sel.contains(change.from, change.to) > -1)
-	    { signalCursorActivity(cm) }
-
-	  updateDoc(doc, change, spans, estimateHeight(cm))
-
-	  if (!cm.options.lineWrapping) {
-	    doc.iter(checkWidthStart, from.line + change.text.length, function (line) {
-	      var len = lineLength(line)
-	      if (len > display.maxLineLength) {
-	        display.maxLine = line
-	        display.maxLineLength = len
-	        display.maxLineChanged = true
-	        recomputeMaxLength = false
-	      }
-	    })
-	    if (recomputeMaxLength) { cm.curOp.updateMaxLine = true }
-	  }
-
-	  // Adjust frontier, schedule worker
-	  doc.frontier = Math.min(doc.frontier, from.line)
-	  startWorker(cm, 400)
-
-	  var lendiff = change.text.length - (to.line - from.line) - 1
-	  // Remember that these lines changed, for updating the display
-	  if (change.full)
-	    { regChange(cm) }
-	  else if (from.line == to.line && change.text.length == 1 && !isWholeLineUpdate(cm.doc, change))
-	    { regLineChange(cm, from.line, "text") }
-	  else
-	    { regChange(cm, from.line, to.line + 1, lendiff) }
-
-	  var changesHandler = hasHandler(cm, "changes"), changeHandler = hasHandler(cm, "change")
-	  if (changeHandler || changesHandler) {
-	    var obj = {
-	      from: from, to: to,
-	      text: change.text,
-	      removed: change.removed,
-	      origin: change.origin
-	    }
-	    if (changeHandler) { signalLater(cm, "change", cm, obj) }
-	    if (changesHandler) { (cm.curOp.changeObjs || (cm.curOp.changeObjs = [])).push(obj) }
-	  }
-	  cm.display.selForContextMenu = null
-	}
-
-	function replaceRange(doc, code, from, to, origin) {
-	  if (!to) { to = from }
-	  if (cmp(to, from) < 0) { var tmp = to; to = from; from = tmp }
-	  if (typeof code == "string") { code = doc.splitLines(code) }
-	  makeChange(doc, {from: from, to: to, text: code, origin: origin})
-	}
-
-	// Rebasing/resetting history to deal with externally-sourced changes
-
-	function rebaseHistSelSingle(pos, from, to, diff) {
-	  if (to < pos.line) {
-	    pos.line += diff
-	  } else if (from < pos.line) {
-	    pos.line = from
-	    pos.ch = 0
-	  }
-	}
-
-	// Tries to rebase an array of history events given a change in the
-	// document. If the change touches the same lines as the event, the
-	// event, and everything 'behind' it, is discarded. If the change is
-	// before the event, the event's positions are updated. Uses a
-	// copy-on-write scheme for the positions, to avoid having to
-	// reallocate them all on every rebase, but also avoid problems with
-	// shared position objects being unsafely updated.
-	function rebaseHistArray(array, from, to, diff) {
-	  for (var i = 0; i < array.length; ++i) {
-	    var sub = array[i], ok = true
-	    if (sub.ranges) {
-	      if (!sub.copied) { sub = array[i] = sub.deepCopy(); sub.copied = true }
-	      for (var j = 0; j < sub.ranges.length; j++) {
-	        rebaseHistSelSingle(sub.ranges[j].anchor, from, to, diff)
-	        rebaseHistSelSingle(sub.ranges[j].head, from, to, diff)
-	      }
-	      continue
-	    }
-	    for (var j$1 = 0; j$1 < sub.changes.length; ++j$1) {
-	      var cur = sub.changes[j$1]
-	      if (to < cur.from.line) {
-	        cur.from = Pos(cur.from.line + diff, cur.from.ch)
-	        cur.to = Pos(cur.to.line + diff, cur.to.ch)
-	      } else if (from <= cur.to.line) {
-	        ok = false
-	        break
-	      }
-	    }
-	    if (!ok) {
-	      array.splice(0, i + 1)
-	      i = 0
-	    }
-	  }
-	}
-
-	function rebaseHist(hist, change) {
-	  var from = change.from.line, to = change.to.line, diff = change.text.length - (to - from) - 1
-	  rebaseHistArray(hist.done, from, to, diff)
-	  rebaseHistArray(hist.undone, from, to, diff)
-	}
-
-	// Utility for applying a change to a line by handle or number,
-	// returning the number and optionally registering the line as
-	// changed.
-	function changeLine(doc, handle, changeType, op) {
-	  var no = handle, line = handle
-	  if (typeof handle == "number") { line = getLine(doc, clipLine(doc, handle)) }
-	  else { no = lineNo(handle) }
-	  if (no == null) { return null }
-	  if (op(line, no) && doc.cm) { regLineChange(doc.cm, no, changeType) }
-	  return line
-	}
-
-	// The document is represented as a BTree consisting of leaves, with
-	// chunk of lines in them, and branches, with up to ten leaves or
-	// other branch nodes below them. The top node is always a branch
-	// node, and is the document object itself (meaning it has
-	// additional methods and properties).
-	//
-	// All nodes have parent links. The tree is used both to go from
-	// line numbers to line objects, and to go from objects to numbers.
-	// It also indexes by height, and is used to convert between height
-	// and line object, and to find the total height of the document.
-	//
-	// See also http://marijnhaverbeke.nl/blog/codemirror-line-tree.html
-
-	function LeafChunk(lines) {
-	  var this$1 = this;
-
-	  this.lines = lines
-	  this.parent = null
-	  var height = 0
-	  for (var i = 0; i < lines.length; ++i) {
-	    lines[i].parent = this$1
-	    height += lines[i].height
-	  }
-	  this.height = height
-	}
-
-	LeafChunk.prototype = {
-	  chunkSize: function() { return this.lines.length },
-	  // Remove the n lines at offset 'at'.
-	  removeInner: function(at, n) {
-	    var this$1 = this;
-
-	    for (var i = at, e = at + n; i < e; ++i) {
-	      var line = this$1.lines[i]
-	      this$1.height -= line.height
-	      cleanUpLine(line)
-	      signalLater(line, "delete")
-	    }
-	    this.lines.splice(at, n)
-	  },
-	  // Helper used to collapse a small branch into a single leaf.
-	  collapse: function(lines) {
-	    lines.push.apply(lines, this.lines)
-	  },
-	  // Insert the given array of lines at offset 'at', count them as
-	  // having the given height.
-	  insertInner: function(at, lines, height) {
-	    var this$1 = this;
-
-	    this.height += height
-	    this.lines = this.lines.slice(0, at).concat(lines).concat(this.lines.slice(at))
-	    for (var i = 0; i < lines.length; ++i) { lines[i].parent = this$1 }
-	  },
-	  // Used to iterate over a part of the tree.
-	  iterN: function(at, n, op) {
-	    var this$1 = this;
-
-	    for (var e = at + n; at < e; ++at)
-	      { if (op(this$1.lines[at])) { return true } }
-	  }
-	}
-
-	function BranchChunk(children) {
-	  var this$1 = this;
-
-	  this.children = children
-	  var size = 0, height = 0
-	  for (var i = 0; i < children.length; ++i) {
-	    var ch = children[i]
-	    size += ch.chunkSize(); height += ch.height
-	    ch.parent = this$1
-	  }
-	  this.size = size
-	  this.height = height
-	  this.parent = null
-	}
-
-	BranchChunk.prototype = {
-	  chunkSize: function() { return this.size },
-	  removeInner: function(at, n) {
-	    var this$1 = this;
-
-	    this.size -= n
-	    for (var i = 0; i < this.children.length; ++i) {
-	      var child = this$1.children[i], sz = child.chunkSize()
-	      if (at < sz) {
-	        var rm = Math.min(n, sz - at), oldHeight = child.height
-	        child.removeInner(at, rm)
-	        this$1.height -= oldHeight - child.height
-	        if (sz == rm) { this$1.children.splice(i--, 1); child.parent = null }
-	        if ((n -= rm) == 0) { break }
-	        at = 0
-	      } else { at -= sz }
-	    }
-	    // If the result is smaller than 25 lines, ensure that it is a
-	    // single leaf node.
-	    if (this.size - n < 25 &&
-	        (this.children.length > 1 || !(this.children[0] instanceof LeafChunk))) {
-	      var lines = []
-	      this.collapse(lines)
-	      this.children = [new LeafChunk(lines)]
-	      this.children[0].parent = this
-	    }
-	  },
-	  collapse: function(lines) {
-	    var this$1 = this;
-
-	    for (var i = 0; i < this.children.length; ++i) { this$1.children[i].collapse(lines) }
-	  },
-	  insertInner: function(at, lines, height) {
-	    var this$1 = this;
-
-	    this.size += lines.length
-	    this.height += height
-	    for (var i = 0; i < this.children.length; ++i) {
-	      var child = this$1.children[i], sz = child.chunkSize()
-	      if (at <= sz) {
-	        child.insertInner(at, lines, height)
-	        if (child.lines && child.lines.length > 50) {
-	          // To avoid memory thrashing when child.lines is huge (e.g. first view of a large file), it's never spliced.
-	          // Instead, small slices are taken. They're taken in order because sequential memory accesses are fastest.
-	          var remaining = child.lines.length % 25 + 25
-	          for (var pos = remaining; pos < child.lines.length;) {
-	            var leaf = new LeafChunk(child.lines.slice(pos, pos += 25))
-	            child.height -= leaf.height
-	            this$1.children.splice(++i, 0, leaf)
-	            leaf.parent = this$1
-	          }
-	          child.lines = child.lines.slice(0, remaining)
-	          this$1.maybeSpill()
-	        }
-	        break
-	      }
-	      at -= sz
-	    }
-	  },
-	  // When a node has grown, check whether it should be split.
-	  maybeSpill: function() {
-	    if (this.children.length <= 10) { return }
-	    var me = this
-	    do {
-	      var spilled = me.children.splice(me.children.length - 5, 5)
-	      var sibling = new BranchChunk(spilled)
-	      if (!me.parent) { // Become the parent node
-	        var copy = new BranchChunk(me.children)
-	        copy.parent = me
-	        me.children = [copy, sibling]
-	        me = copy
-	     } else {
-	        me.size -= sibling.size
-	        me.height -= sibling.height
-	        var myIndex = indexOf(me.parent.children, me)
-	        me.parent.children.splice(myIndex + 1, 0, sibling)
-	      }
-	      sibling.parent = me.parent
-	    } while (me.children.length > 10)
-	    me.parent.maybeSpill()
-	  },
-	  iterN: function(at, n, op) {
-	    var this$1 = this;
-
-	    for (var i = 0; i < this.children.length; ++i) {
-	      var child = this$1.children[i], sz = child.chunkSize()
-	      if (at < sz) {
-	        var used = Math.min(n, sz - at)
-	        if (child.iterN(at, used, op)) { return true }
-	        if ((n -= used) == 0) { break }
-	        at = 0
-	      } else { at -= sz }
-	    }
-	  }
-	}
-
-	// Line widgets are block elements displayed above or below a line.
-
-	function LineWidget(doc, node, options) {
-	  var this$1 = this;
-
-	  if (options) { for (var opt in options) { if (options.hasOwnProperty(opt))
-	    { this$1[opt] = options[opt] } } }
-	  this.doc = doc
-	  this.node = node
-	}
-	eventMixin(LineWidget)
-
-	function adjustScrollWhenAboveVisible(cm, line, diff) {
-	  if (heightAtLine(line) < ((cm.curOp && cm.curOp.scrollTop) || cm.doc.scrollTop))
-	    { addToScrollPos(cm, null, diff) }
-	}
-
-	LineWidget.prototype.clear = function() {
-	  var this$1 = this;
-
-	  var cm = this.doc.cm, ws = this.line.widgets, line = this.line, no = lineNo(line)
-	  if (no == null || !ws) { return }
-	  for (var i = 0; i < ws.length; ++i) { if (ws[i] == this$1) { ws.splice(i--, 1) } }
-	  if (!ws.length) { line.widgets = null }
-	  var height = widgetHeight(this)
-	  updateLineHeight(line, Math.max(0, line.height - height))
-	  if (cm) { runInOp(cm, function () {
-	    adjustScrollWhenAboveVisible(cm, line, -height)
-	    regLineChange(cm, no, "widget")
-	  }) }
-	}
-	LineWidget.prototype.changed = function() {
-	  var oldH = this.height, cm = this.doc.cm, line = this.line
-	  this.height = null
-	  var diff = widgetHeight(this) - oldH
-	  if (!diff) { return }
-	  updateLineHeight(line, line.height + diff)
-	  if (cm) { runInOp(cm, function () {
-	    cm.curOp.forceUpdate = true
-	    adjustScrollWhenAboveVisible(cm, line, diff)
-	  }) }
-	}
-
-	function addLineWidget(doc, handle, node, options) {
-	  var widget = new LineWidget(doc, node, options)
-	  var cm = doc.cm
-	  if (cm && widget.noHScroll) { cm.display.alignWidgets = true }
-	  changeLine(doc, handle, "widget", function (line) {
-	    var widgets = line.widgets || (line.widgets = [])
-	    if (widget.insertAt == null) { widgets.push(widget) }
-	    else { widgets.splice(Math.min(widgets.length - 1, Math.max(0, widget.insertAt)), 0, widget) }
-	    widget.line = line
-	    if (cm && !lineIsHidden(doc, line)) {
-	      var aboveVisible = heightAtLine(line) < doc.scrollTop
-	      updateLineHeight(line, line.height + widgetHeight(widget))
-	      if (aboveVisible) { addToScrollPos(cm, null, widget.height) }
-	      cm.curOp.forceUpdate = true
-	    }
-	    return true
-	  })
-	  return widget
-	}
-
-	// TEXTMARKERS
-
-	// Created with markText and setBookmark methods. A TextMarker is a
-	// handle that can be used to clear or find a marked position in the
-	// document. Line objects hold arrays (markedSpans) containing
-	// {from, to, marker} object pointing to such marker objects, and
-	// indicating that such a marker is present on that line. Multiple
-	// lines may point to the same marker when it spans across lines.
-	// The spans will have null for their from/to properties when the
-	// marker continues beyond the start/end of the line. Markers have
-	// links back to the lines they currently touch.
-
-	// Collapsed markers have unique ids, in order to be able to order
-	// them, which is needed for uniquely determining an outer marker
-	// when they overlap (they may nest, but not partially overlap).
-	var nextMarkerId = 0
-
-	function TextMarker(doc, type) {
-	  this.lines = []
-	  this.type = type
-	  this.doc = doc
-	  this.id = ++nextMarkerId
-	}
-	eventMixin(TextMarker)
-
-	// Clear the marker.
-	TextMarker.prototype.clear = function() {
-	  var this$1 = this;
-
-	  if (this.explicitlyCleared) { return }
-	  var cm = this.doc.cm, withOp = cm && !cm.curOp
-	  if (withOp) { startOperation(cm) }
-	  if (hasHandler(this, "clear")) {
-	    var found = this.find()
-	    if (found) { signalLater(this, "clear", found.from, found.to) }
-	  }
-	  var min = null, max = null
-	  for (var i = 0; i < this.lines.length; ++i) {
-	    var line = this$1.lines[i]
-	    var span = getMarkedSpanFor(line.markedSpans, this$1)
-	    if (cm && !this$1.collapsed) { regLineChange(cm, lineNo(line), "text") }
-	    else if (cm) {
-	      if (span.to != null) { max = lineNo(line) }
-	      if (span.from != null) { min = lineNo(line) }
-	    }
-	    line.markedSpans = removeMarkedSpan(line.markedSpans, span)
-	    if (span.from == null && this$1.collapsed && !lineIsHidden(this$1.doc, line) && cm)
-	      { updateLineHeight(line, textHeight(cm.display)) }
-	  }
-	  if (cm && this.collapsed && !cm.options.lineWrapping) { for (var i$1 = 0; i$1 < this.lines.length; ++i$1) {
-	    var visual = visualLine(this$1.lines[i$1]), len = lineLength(visual)
-	    if (len > cm.display.maxLineLength) {
-	      cm.display.maxLine = visual
-	      cm.display.maxLineLength = len
-	      cm.display.maxLineChanged = true
-	    }
-	  } }
-
-	  if (min != null && cm && this.collapsed) { regChange(cm, min, max + 1) }
-	  this.lines.length = 0
-	  this.explicitlyCleared = true
-	  if (this.atomic && this.doc.cantEdit) {
-	    this.doc.cantEdit = false
-	    if (cm) { reCheckSelection(cm.doc) }
-	  }
-	  if (cm) { signalLater(cm, "markerCleared", cm, this) }
-	  if (withOp) { endOperation(cm) }
-	  if (this.parent) { this.parent.clear() }
-	}
-
-	// Find the position of the marker in the document. Returns a {from,
-	// to} object by default. Side can be passed to get a specific side
-	// -- 0 (both), -1 (left), or 1 (right). When lineObj is true, the
-	// Pos objects returned contain a line object, rather than a line
-	// number (used to prevent looking up the same line twice).
-	TextMarker.prototype.find = function(side, lineObj) {
-	  var this$1 = this;
-
-	  if (side == null && this.type == "bookmark") { side = 1 }
-	  var from, to
-	  for (var i = 0; i < this.lines.length; ++i) {
-	    var line = this$1.lines[i]
-	    var span = getMarkedSpanFor(line.markedSpans, this$1)
-	    if (span.from != null) {
-	      from = Pos(lineObj ? line : lineNo(line), span.from)
-	      if (side == -1) { return from }
-	    }
-	    if (span.to != null) {
-	      to = Pos(lineObj ? line : lineNo(line), span.to)
-	      if (side == 1) { return to }
-	    }
-	  }
-	  return from && {from: from, to: to}
-	}
-
-	// Signals that the marker's widget changed, and surrounding layout
-	// should be recomputed.
-	TextMarker.prototype.changed = function() {
-	  var pos = this.find(-1, true), widget = this, cm = this.doc.cm
-	  if (!pos || !cm) { return }
-	  runInOp(cm, function () {
-	    var line = pos.line, lineN = lineNo(pos.line)
-	    var view = findViewForLine(cm, lineN)
-	    if (view) {
-	      clearLineMeasurementCacheFor(view)
-	      cm.curOp.selectionChanged = cm.curOp.forceUpdate = true
-	    }
-	    cm.curOp.updateMaxLine = true
-	    if (!lineIsHidden(widget.doc, line) && widget.height != null) {
-	      var oldHeight = widget.height
-	      widget.height = null
-	      var dHeight = widgetHeight(widget) - oldHeight
-	      if (dHeight)
-	        { updateLineHeight(line, line.height + dHeight) }
-	    }
-	  })
-	}
-
-	TextMarker.prototype.attachLine = function(line) {
-	  if (!this.lines.length && this.doc.cm) {
-	    var op = this.doc.cm.curOp
-	    if (!op.maybeHiddenMarkers || indexOf(op.maybeHiddenMarkers, this) == -1)
-	      { (op.maybeUnhiddenMarkers || (op.maybeUnhiddenMarkers = [])).push(this) }
-	  }
-	  this.lines.push(line)
-	}
-	TextMarker.prototype.detachLine = function(line) {
-	  this.lines.splice(indexOf(this.lines, line), 1)
-	  if (!this.lines.length && this.doc.cm) {
-	    var op = this.doc.cm.curOp
-	    ;(op.maybeHiddenMarkers || (op.maybeHiddenMarkers = [])).push(this)
-	  }
-	}
-
-	// Create a marker, wire it up to the right lines, and
-	function markText(doc, from, to, options, type) {
-	  // Shared markers (across linked documents) are handled separately
-	  // (markTextShared will call out to this again, once per
-	  // document).
-	  if (options && options.shared) { return markTextShared(doc, from, to, options, type) }
-	  // Ensure we are in an operation.
-	  if (doc.cm && !doc.cm.curOp) { return operation(doc.cm, markText)(doc, from, to, options, type) }
-
-	  var marker = new TextMarker(doc, type), diff = cmp(from, to)
-	  if (options) { copyObj(options, marker, false) }
-	  // Don't connect empty markers unless clearWhenEmpty is false
-	  if (diff > 0 || diff == 0 && marker.clearWhenEmpty !== false)
-	    { return marker }
-	  if (marker.replacedWith) {
-	    // Showing up as a widget implies collapsed (widget replaces text)
-	    marker.collapsed = true
-	    marker.widgetNode = elt("span", [marker.replacedWith], "CodeMirror-widget")
-	    if (!options.handleMouseEvents) { marker.widgetNode.setAttribute("cm-ignore-events", "true") }
-	    if (options.insertLeft) { marker.widgetNode.insertLeft = true }
-	  }
-	  if (marker.collapsed) {
-	    if (conflictingCollapsedRange(doc, from.line, from, to, marker) ||
-	        from.line != to.line && conflictingCollapsedRange(doc, to.line, from, to, marker))
-	      { throw new Error("Inserting collapsed marker partially overlapping an existing one") }
-	    seeCollapsedSpans()
-	  }
-
-	  if (marker.addToHistory)
-	    { addChangeToHistory(doc, {from: from, to: to, origin: "markText"}, doc.sel, NaN) }
-
-	  var curLine = from.line, cm = doc.cm, updateMaxLine
-	  doc.iter(curLine, to.line + 1, function (line) {
-	    if (cm && marker.collapsed && !cm.options.lineWrapping && visualLine(line) == cm.display.maxLine)
-	      { updateMaxLine = true }
-	    if (marker.collapsed && curLine != from.line) { updateLineHeight(line, 0) }
-	    addMarkedSpan(line, new MarkedSpan(marker,
-	                                       curLine == from.line ? from.ch : null,
-	                                       curLine == to.line ? to.ch : null))
-	    ++curLine
-	  })
-	  // lineIsHidden depends on the presence of the spans, so needs a second pass
-	  if (marker.collapsed) { doc.iter(from.line, to.line + 1, function (line) {
-	    if (lineIsHidden(doc, line)) { updateLineHeight(line, 0) }
-	  }) }
-
-	  if (marker.clearOnEnter) { on(marker, "beforeCursorEnter", function () { return marker.clear(); }) }
-
-	  if (marker.readOnly) {
-	    seeReadOnlySpans()
-	    if (doc.history.done.length || doc.history.undone.length)
-	      { doc.clearHistory() }
-	  }
-	  if (marker.collapsed) {
-	    marker.id = ++nextMarkerId
-	    marker.atomic = true
-	  }
-	  if (cm) {
-	    // Sync editor state
-	    if (updateMaxLine) { cm.curOp.updateMaxLine = true }
-	    if (marker.collapsed)
-	      { regChange(cm, from.line, to.line + 1) }
-	    else if (marker.className || marker.title || marker.startStyle || marker.endStyle || marker.css)
-	      { for (var i = from.line; i <= to.line; i++) { regLineChange(cm, i, "text") } }
-	    if (marker.atomic) { reCheckSelection(cm.doc) }
-	    signalLater(cm, "markerAdded", cm, marker)
-	  }
-	  return marker
-	}
-
-	// SHARED TEXTMARKERS
-
-	// A shared marker spans multiple linked documents. It is
-	// implemented as a meta-marker-object controlling multiple normal
-	// markers.
-	function SharedTextMarker(markers, primary) {
-	  var this$1 = this;
-
-	  this.markers = markers
-	  this.primary = primary
-	  for (var i = 0; i < markers.length; ++i)
-	    { markers[i].parent = this$1 }
-	}
-	eventMixin(SharedTextMarker)
-
-	SharedTextMarker.prototype.clear = function() {
-	  var this$1 = this;
-
-	  if (this.explicitlyCleared) { return }
-	  this.explicitlyCleared = true
-	  for (var i = 0; i < this.markers.length; ++i)
-	    { this$1.markers[i].clear() }
-	  signalLater(this, "clear")
-	}
-	SharedTextMarker.prototype.find = function(side, lineObj) {
-	  return this.primary.find(side, lineObj)
-	}
-
-	function markTextShared(doc, from, to, options, type) {
-	  options = copyObj(options)
-	  options.shared = false
-	  var markers = [markText(doc, from, to, options, type)], primary = markers[0]
-	  var widget = options.widgetNode
-	  linkedDocs(doc, function (doc) {
-	    if (widget) { options.widgetNode = widget.cloneNode(true) }
-	    markers.push(markText(doc, clipPos(doc, from), clipPos(doc, to), options, type))
-	    for (var i = 0; i < doc.linked.length; ++i)
-	      { if (doc.linked[i].isParent) { return } }
-	    primary = lst(markers)
-	  })
-	  return new SharedTextMarker(markers, primary)
-	}
-
-	function findSharedMarkers(doc) {
-	  return doc.findMarks(Pos(doc.first, 0), doc.clipPos(Pos(doc.lastLine())), function (m) { return m.parent; })
-	}
-
-	function copySharedMarkers(doc, markers) {
-	  for (var i = 0; i < markers.length; i++) {
-	    var marker = markers[i], pos = marker.find()
-	    var mFrom = doc.clipPos(pos.from), mTo = doc.clipPos(pos.to)
-	    if (cmp(mFrom, mTo)) {
-	      var subMark = markText(doc, mFrom, mTo, marker.primary, marker.primary.type)
-	      marker.markers.push(subMark)
-	      subMark.parent = marker
-	    }
-	  }
-	}
-
-	function detachSharedMarkers(markers) {
-	  var loop = function ( i ) {
-	    var marker = markers[i], linked = [marker.primary.doc]
-	    linkedDocs(marker.primary.doc, function (d) { return linked.push(d); })
-	    for (var j = 0; j < marker.markers.length; j++) {
-	      var subMarker = marker.markers[j]
-	      if (indexOf(linked, subMarker.doc) == -1) {
-	        subMarker.parent = null
-	        marker.markers.splice(j--, 1)
-	      }
-	    }
-	  };
-
-	  for (var i = 0; i < markers.length; i++) loop( i );
-	}
-
-	var nextDocId = 0
-	var Doc = function(text, mode, firstLine, lineSep) {
-	  if (!(this instanceof Doc)) { return new Doc(text, mode, firstLine, lineSep) }
-	  if (firstLine == null) { firstLine = 0 }
-
-	  BranchChunk.call(this, [new LeafChunk([new Line("", null)])])
-	  this.first = firstLine
-	  this.scrollTop = this.scrollLeft = 0
-	  this.cantEdit = false
-	  this.cleanGeneration = 1
-	  this.frontier = firstLine
-	  var start = Pos(firstLine, 0)
-	  this.sel = simpleSelection(start)
-	  this.history = new History(null)
-	  this.id = ++nextDocId
-	  this.modeOption = mode
-	  this.lineSep = lineSep
-	  this.extend = false
-
-	  if (typeof text == "string") { text = this.splitLines(text) }
-	  updateDoc(this, {from: start, to: start, text: text})
-	  setSelection(this, simpleSelection(start), sel_dontScroll)
-	}
-
-	Doc.prototype = createObj(BranchChunk.prototype, {
-	  constructor: Doc,
-	  // Iterate over the document. Supports two forms -- with only one
-	  // argument, it calls that for each line in the document. With
-	  // three, it iterates over the range given by the first two (with
-	  // the second being non-inclusive).
-	  iter: function(from, to, op) {
-	    if (op) { this.iterN(from - this.first, to - from, op) }
-	    else { this.iterN(this.first, this.first + this.size, from) }
-	  },
-
-	  // Non-public interface for adding and removing lines.
-	  insert: function(at, lines) {
-	    var height = 0
-	    for (var i = 0; i < lines.length; ++i) { height += lines[i].height }
-	    this.insertInner(at - this.first, lines, height)
-	  },
-	  remove: function(at, n) { this.removeInner(at - this.first, n) },
-
-	  // From here, the methods are part of the public interface. Most
-	  // are also available from CodeMirror (editor) instances.
-
-	  getValue: function(lineSep) {
-	    var lines = getLines(this, this.first, this.first + this.size)
-	    if (lineSep === false) { return lines }
-	    return lines.join(lineSep || this.lineSeparator())
-	  },
-	  setValue: docMethodOp(function(code) {
-	    var top = Pos(this.first, 0), last = this.first + this.size - 1
-	    makeChange(this, {from: top, to: Pos(last, getLine(this, last).text.length),
-	                      text: this.splitLines(code), origin: "setValue", full: true}, true)
-	    setSelection(this, simpleSelection(top))
-	  }),
-	  replaceRange: function(code, from, to, origin) {
-	    from = clipPos(this, from)
-	    to = to ? clipPos(this, to) : from
-	    replaceRange(this, code, from, to, origin)
-	  },
-	  getRange: function(from, to, lineSep) {
-	    var lines = getBetween(this, clipPos(this, from), clipPos(this, to))
-	    if (lineSep === false) { return lines }
-	    return lines.join(lineSep || this.lineSeparator())
-	  },
-
-	  getLine: function(line) {var l = this.getLineHandle(line); return l && l.text},
-
-	  getLineHandle: function(line) {if (isLine(this, line)) { return getLine(this, line) }},
-	  getLineNumber: function(line) {return lineNo(line)},
-
-	  getLineHandleVisualStart: function(line) {
-	    if (typeof line == "number") { line = getLine(this, line) }
-	    return visualLine(line)
-	  },
-
-	  lineCount: function() {return this.size},
-	  firstLine: function() {return this.first},
-	  lastLine: function() {return this.first + this.size - 1},
-
-	  clipPos: function(pos) {return clipPos(this, pos)},
-
-	  getCursor: function(start) {
-	    var range = this.sel.primary(), pos
-	    if (start == null || start == "head") { pos = range.head }
-	    else if (start == "anchor") { pos = range.anchor }
-	    else if (start == "end" || start == "to" || start === false) { pos = range.to() }
-	    else { pos = range.from() }
-	    return pos
-	  },
-	  listSelections: function() { return this.sel.ranges },
-	  somethingSelected: function() {return this.sel.somethingSelected()},
-
-	  setCursor: docMethodOp(function(line, ch, options) {
-	    setSimpleSelection(this, clipPos(this, typeof line == "number" ? Pos(line, ch || 0) : line), null, options)
-	  }),
-	  setSelection: docMethodOp(function(anchor, head, options) {
-	    setSimpleSelection(this, clipPos(this, anchor), clipPos(this, head || anchor), options)
-	  }),
-	  extendSelection: docMethodOp(function(head, other, options) {
-	    extendSelection(this, clipPos(this, head), other && clipPos(this, other), options)
-	  }),
-	  extendSelections: docMethodOp(function(heads, options) {
-	    extendSelections(this, clipPosArray(this, heads), options)
-	  }),
-	  extendSelectionsBy: docMethodOp(function(f, options) {
-	    var heads = map(this.sel.ranges, f)
-	    extendSelections(this, clipPosArray(this, heads), options)
-	  }),
-	  setSelections: docMethodOp(function(ranges, primary, options) {
-	    var this$1 = this;
-
-	    if (!ranges.length) { return }
-	    var out = []
-	    for (var i = 0; i < ranges.length; i++)
-	      { out[i] = new Range(clipPos(this$1, ranges[i].anchor),
-	                         clipPos(this$1, ranges[i].head)) }
-	    if (primary == null) { primary = Math.min(ranges.length - 1, this.sel.primIndex) }
-	    setSelection(this, normalizeSelection(out, primary), options)
-	  }),
-	  addSelection: docMethodOp(function(anchor, head, options) {
-	    var ranges = this.sel.ranges.slice(0)
-	    ranges.push(new Range(clipPos(this, anchor), clipPos(this, head || anchor)))
-	    setSelection(this, normalizeSelection(ranges, ranges.length - 1), options)
-	  }),
-
-	  getSelection: function(lineSep) {
-	    var this$1 = this;
-
-	    var ranges = this.sel.ranges, lines
-	    for (var i = 0; i < ranges.length; i++) {
-	      var sel = getBetween(this$1, ranges[i].from(), ranges[i].to())
-	      lines = lines ? lines.concat(sel) : sel
-	    }
-	    if (lineSep === false) { return lines }
-	    else { return lines.join(lineSep || this.lineSeparator()) }
-	  },
-	  getSelections: function(lineSep) {
-	    var this$1 = this;
-
-	    var parts = [], ranges = this.sel.ranges
-	    for (var i = 0; i < ranges.length; i++) {
-	      var sel = getBetween(this$1, ranges[i].from(), ranges[i].to())
-	      if (lineSep !== false) { sel = sel.join(lineSep || this$1.lineSeparator()) }
-	      parts[i] = sel
-	    }
-	    return parts
-	  },
-	  replaceSelection: function(code, collapse, origin) {
-	    var dup = []
-	    for (var i = 0; i < this.sel.ranges.length; i++)
-	      { dup[i] = code }
-	    this.replaceSelections(dup, collapse, origin || "+input")
-	  },
-	  replaceSelections: docMethodOp(function(code, collapse, origin) {
-	    var this$1 = this;
-
-	    var changes = [], sel = this.sel
-	    for (var i = 0; i < sel.ranges.length; i++) {
-	      var range = sel.ranges[i]
-	      changes[i] = {from: range.from(), to: range.to(), text: this$1.splitLines(code[i]), origin: origin}
-	    }
-	    var newSel = collapse && collapse != "end" && computeReplacedSel(this, changes, collapse)
-	    for (var i$1 = changes.length - 1; i$1 >= 0; i$1--)
-	      { makeChange(this$1, changes[i$1]) }
-	    if (newSel) { setSelectionReplaceHistory(this, newSel) }
-	    else if (this.cm) { ensureCursorVisible(this.cm) }
-	  }),
-	  undo: docMethodOp(function() {makeChangeFromHistory(this, "undo")}),
-	  redo: docMethodOp(function() {makeChangeFromHistory(this, "redo")}),
-	  undoSelection: docMethodOp(function() {makeChangeFromHistory(this, "undo", true)}),
-	  redoSelection: docMethodOp(function() {makeChangeFromHistory(this, "redo", true)}),
-
-	  setExtending: function(val) {this.extend = val},
-	  getExtending: function() {return this.extend},
-
-	  historySize: function() {
-	    var hist = this.history, done = 0, undone = 0
-	    for (var i = 0; i < hist.done.length; i++) { if (!hist.done[i].ranges) { ++done } }
-	    for (var i$1 = 0; i$1 < hist.undone.length; i$1++) { if (!hist.undone[i$1].ranges) { ++undone } }
-	    return {undo: done, redo: undone}
-	  },
-	  clearHistory: function() {this.history = new History(this.history.maxGeneration)},
-
-	  markClean: function() {
-	    this.cleanGeneration = this.changeGeneration(true)
-	  },
-	  changeGeneration: function(forceSplit) {
-	    if (forceSplit)
-	      { this.history.lastOp = this.history.lastSelOp = this.history.lastOrigin = null }
-	    return this.history.generation
-	  },
-	  isClean: function (gen) {
-	    return this.history.generation == (gen || this.cleanGeneration)
-	  },
-
-	  getHistory: function() {
-	    return {done: copyHistoryArray(this.history.done),
-	            undone: copyHistoryArray(this.history.undone)}
-	  },
-	  setHistory: function(histData) {
-	    var hist = this.history = new History(this.history.maxGeneration)
-	    hist.done = copyHistoryArray(histData.done.slice(0), null, true)
-	    hist.undone = copyHistoryArray(histData.undone.slice(0), null, true)
-	  },
-
-	  setGutterMarker: docMethodOp(function(line, gutterID, value) {
-	    return changeLine(this, line, "gutter", function (line) {
-	      var markers = line.gutterMarkers || (line.gutterMarkers = {})
-	      markers[gutterID] = value
-	      if (!value && isEmpty(markers)) { line.gutterMarkers = null }
-	      return true
-	    })
-	  }),
-
-	  clearGutter: docMethodOp(function(gutterID) {
-	    var this$1 = this;
-
-	    var i = this.first
-	    this.iter(function (line) {
-	      if (line.gutterMarkers && line.gutterMarkers[gutterID]) {
-	        changeLine(this$1, line, "gutter", function () {
-	          line.gutterMarkers[gutterID] = null
-	          if (isEmpty(line.gutterMarkers)) { line.gutterMarkers = null }
-	          return true
-	        })
-	      }
-	      ++i
-	    })
-	  }),
-
-	  lineInfo: function(line) {
-	    var n
-	    if (typeof line == "number") {
-	      if (!isLine(this, line)) { return null }
-	      n = line
-	      line = getLine(this, line)
-	      if (!line) { return null }
-	    } else {
-	      n = lineNo(line)
-	      if (n == null) { return null }
-	    }
-	    return {line: n, handle: line, text: line.text, gutterMarkers: line.gutterMarkers,
-	            textClass: line.textClass, bgClass: line.bgClass, wrapClass: line.wrapClass,
-	            widgets: line.widgets}
-	  },
-
-	  addLineClass: docMethodOp(function(handle, where, cls) {
-	    return changeLine(this, handle, where == "gutter" ? "gutter" : "class", function (line) {
-	      var prop = where == "text" ? "textClass"
-	               : where == "background" ? "bgClass"
-	               : where == "gutter" ? "gutterClass" : "wrapClass"
-	      if (!line[prop]) { line[prop] = cls }
-	      else if (classTest(cls).test(line[prop])) { return false }
-	      else { line[prop] += " " + cls }
-	      return true
-	    })
-	  }),
-	  removeLineClass: docMethodOp(function(handle, where, cls) {
-	    return changeLine(this, handle, where == "gutter" ? "gutter" : "class", function (line) {
-	      var prop = where == "text" ? "textClass"
-	               : where == "background" ? "bgClass"
-	               : where == "gutter" ? "gutterClass" : "wrapClass"
-	      var cur = line[prop]
-	      if (!cur) { return false }
-	      else if (cls == null) { line[prop] = null }
-	      else {
-	        var found = cur.match(classTest(cls))
-	        if (!found) { return false }
-	        var end = found.index + found[0].length
-	        line[prop] = cur.slice(0, found.index) + (!found.index || end == cur.length ? "" : " ") + cur.slice(end) || null
-	      }
-	      return true
-	    })
-	  }),
-
-	  addLineWidget: docMethodOp(function(handle, node, options) {
-	    return addLineWidget(this, handle, node, options)
-	  }),
-	  removeLineWidget: function(widget) { widget.clear() },
-
-	  markText: function(from, to, options) {
-	    return markText(this, clipPos(this, from), clipPos(this, to), options, options && options.type || "range")
-	  },
-	  setBookmark: function(pos, options) {
-	    var realOpts = {replacedWith: options && (options.nodeType == null ? options.widget : options),
-	                    insertLeft: options && options.insertLeft,
-	                    clearWhenEmpty: false, shared: options && options.shared,
-	                    handleMouseEvents: options && options.handleMouseEvents}
-	    pos = clipPos(this, pos)
-	    return markText(this, pos, pos, realOpts, "bookmark")
-	  },
-	  findMarksAt: function(pos) {
-	    pos = clipPos(this, pos)
-	    var markers = [], spans = getLine(this, pos.line).markedSpans
-	    if (spans) { for (var i = 0; i < spans.length; ++i) {
-	      var span = spans[i]
-	      if ((span.from == null || span.from <= pos.ch) &&
-	          (span.to == null || span.to >= pos.ch))
-	        { markers.push(span.marker.parent || span.marker) }
-	    } }
-	    return markers
-	  },
-	  findMarks: function(from, to, filter) {
-	    from = clipPos(this, from); to = clipPos(this, to)
-	    var found = [], lineNo = from.line
-	    this.iter(from.line, to.line + 1, function (line) {
-	      var spans = line.markedSpans
-	      if (spans) { for (var i = 0; i < spans.length; i++) {
-	        var span = spans[i]
-	        if (!(span.to != null && lineNo == from.line && from.ch >= span.to ||
-	              span.from == null && lineNo != from.line ||
-	              span.from != null && lineNo == to.line && span.from >= to.ch) &&
-	            (!filter || filter(span.marker)))
-	          { found.push(span.marker.parent || span.marker) }
-	      } }
-	      ++lineNo
-	    })
-	    return found
-	  },
-	  getAllMarks: function() {
-	    var markers = []
-	    this.iter(function (line) {
-	      var sps = line.markedSpans
-	      if (sps) { for (var i = 0; i < sps.length; ++i)
-	        { if (sps[i].from != null) { markers.push(sps[i].marker) } } }
-	    })
-	    return markers
-	  },
-
-	  posFromIndex: function(off) {
-	    var ch, lineNo = this.first, sepSize = this.lineSeparator().length
-	    this.iter(function (line) {
-	      var sz = line.text.length + sepSize
-	      if (sz > off) { ch = off; return true }
-	      off -= sz
-	      ++lineNo
-	    })
-	    return clipPos(this, Pos(lineNo, ch))
-	  },
-	  indexFromPos: function (coords) {
-	    coords = clipPos(this, coords)
-	    var index = coords.ch
-	    if (coords.line < this.first || coords.ch < 0) { return 0 }
-	    var sepSize = this.lineSeparator().length
-	    this.iter(this.first, coords.line, function (line) { // iter aborts when callback returns a truthy value
-	      index += line.text.length + sepSize
-	    })
-	    return index
-	  },
-
-	  copy: function(copyHistory) {
-	    var doc = new Doc(getLines(this, this.first, this.first + this.size),
-	                      this.modeOption, this.first, this.lineSep)
-	    doc.scrollTop = this.scrollTop; doc.scrollLeft = this.scrollLeft
-	    doc.sel = this.sel
-	    doc.extend = false
-	    if (copyHistory) {
-	      doc.history.undoDepth = this.history.undoDepth
-	      doc.setHistory(this.getHistory())
-	    }
-	    return doc
-	  },
-
-	  linkedDoc: function(options) {
-	    if (!options) { options = {} }
-	    var from = this.first, to = this.first + this.size
-	    if (options.from != null && options.from > from) { from = options.from }
-	    if (options.to != null && options.to < to) { to = options.to }
-	    var copy = new Doc(getLines(this, from, to), options.mode || this.modeOption, from, this.lineSep)
-	    if (options.sharedHist) { copy.history = this.history
-	    ; }(this.linked || (this.linked = [])).push({doc: copy, sharedHist: options.sharedHist})
-	    copy.linked = [{doc: this, isParent: true, sharedHist: options.sharedHist}]
-	    copySharedMarkers(copy, findSharedMarkers(this))
-	    return copy
-	  },
-	  unlinkDoc: function(other) {
-	    var this$1 = this;
-
-	    if (other instanceof CodeMirror) { other = other.doc }
-	    if (this.linked) { for (var i = 0; i < this.linked.length; ++i) {
-	      var link = this$1.linked[i]
-	      if (link.doc != other) { continue }
-	      this$1.linked.splice(i, 1)
-	      other.unlinkDoc(this$1)
-	      detachSharedMarkers(findSharedMarkers(this$1))
-	      break
-	    } }
-	    // If the histories were shared, split them again
-	    if (other.history == this.history) {
-	      var splitIds = [other.id]
-	      linkedDocs(other, function (doc) { return splitIds.push(doc.id); }, true)
-	      other.history = new History(null)
-	      other.history.done = copyHistoryArray(this.history.done, splitIds)
-	      other.history.undone = copyHistoryArray(this.history.undone, splitIds)
-	    }
-	  },
-	  iterLinkedDocs: function(f) {linkedDocs(this, f)},
-
-	  getMode: function() {return this.mode},
-	  getEditor: function() {return this.cm},
-
-	  splitLines: function(str) {
-	    if (this.lineSep) { return str.split(this.lineSep) }
-	    return splitLinesAuto(str)
-	  },
-	  lineSeparator: function() { return this.lineSep || "\n" }
-	})
-
-	// Public alias.
-	Doc.prototype.eachLine = Doc.prototype.iter
-
-	// Kludge to work around strange IE behavior where it'll sometimes
-	// re-fire a series of drag-related events right after the drop (#1551)
-	var lastDrop = 0
-
-	function onDrop(e) {
-	  var cm = this
-	  clearDragCursor(cm)
-	  if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e))
-	    { return }
-	  e_preventDefault(e)
-	  if (ie) { lastDrop = +new Date }
-	  var pos = posFromMouse(cm, e, true), files = e.dataTransfer.files
-	  if (!pos || cm.isReadOnly()) { return }
-	  // Might be a file drop, in which case we simply extract the text
-	  // and insert it.
-	  if (files && files.length && window.FileReader && window.File) {
-	    var n = files.length, text = Array(n), read = 0
-	    var loadFile = function (file, i) {
-	      if (cm.options.allowDropFileTypes &&
-	          indexOf(cm.options.allowDropFileTypes, file.type) == -1)
-	        { return }
-
-	      var reader = new FileReader
-	      reader.onload = operation(cm, function () {
-	        var content = reader.result
-	        if (/[\x00-\x08\x0e-\x1f]{2}/.test(content)) { content = "" }
-	        text[i] = content
-	        if (++read == n) {
-	          pos = clipPos(cm.doc, pos)
-	          var change = {from: pos, to: pos,
-	                        text: cm.doc.splitLines(text.join(cm.doc.lineSeparator())),
-	                        origin: "paste"}
-	          makeChange(cm.doc, change)
-	          setSelectionReplaceHistory(cm.doc, simpleSelection(pos, changeEnd(change)))
-	        }
-	      })
-	      reader.readAsText(file)
-	    }
-	    for (var i = 0; i < n; ++i) { loadFile(files[i], i) }
-	  } else { // Normal drop
-	    // Don't do a replace if the drop happened inside of the selected text.
-	    if (cm.state.draggingText && cm.doc.sel.contains(pos) > -1) {
-	      cm.state.draggingText(e)
-	      // Ensure the editor is re-focused
-	      setTimeout(function () { return cm.display.input.focus(); }, 20)
-	      return
-	    }
-	    try {
-	      var text$1 = e.dataTransfer.getData("Text")
-	      if (text$1) {
-	        var selected
-	        if (cm.state.draggingText && !cm.state.draggingText.copy)
-	          { selected = cm.listSelections() }
-	        setSelectionNoUndo(cm.doc, simpleSelection(pos, pos))
-	        if (selected) { for (var i$1 = 0; i$1 < selected.length; ++i$1)
-	          { replaceRange(cm.doc, "", selected[i$1].anchor, selected[i$1].head, "drag") } }
-	        cm.replaceSelection(text$1, "around", "paste")
-	        cm.display.input.focus()
-	      }
-	    }
-	    catch(e){}
-	  }
-	}
-
-	function onDragStart(cm, e) {
-	  if (ie && (!cm.state.draggingText || +new Date - lastDrop < 100)) { e_stop(e); return }
-	  if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) { return }
-
-	  e.dataTransfer.setData("Text", cm.getSelection())
-	  e.dataTransfer.effectAllowed = "copyMove"
-
-	  // Use dummy image instead of default browsers image.
-	  // Recent Safari (~6.0.2) have a tendency to segfault when this happens, so we don't do it there.
-	  if (e.dataTransfer.setDragImage && !safari) {
-	    var img = elt("img", null, null, "position: fixed; left: 0; top: 0;")
-	    img.src = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=="
-	    if (presto) {
-	      img.width = img.height = 1
-	      cm.display.wrapper.appendChild(img)
-	      // Force a relayout, or Opera won't use our image for some obscure reason
-	      img._top = img.offsetTop
-	    }
-	    e.dataTransfer.setDragImage(img, 0, 0)
-	    if (presto) { img.parentNode.removeChild(img) }
-	  }
-	}
-
-	function onDragOver(cm, e) {
-	  var pos = posFromMouse(cm, e)
-	  if (!pos) { return }
-	  var frag = document.createDocumentFragment()
-	  drawSelectionCursor(cm, pos, frag)
-	  if (!cm.display.dragCursor) {
-	    cm.display.dragCursor = elt("div", null, "CodeMirror-cursors CodeMirror-dragcursors")
-	    cm.display.lineSpace.insertBefore(cm.display.dragCursor, cm.display.cursorDiv)
-	  }
-	  removeChildrenAndAdd(cm.display.dragCursor, frag)
-	}
-
-	function clearDragCursor(cm) {
-	  if (cm.display.dragCursor) {
-	    cm.display.lineSpace.removeChild(cm.display.dragCursor)
-	    cm.display.dragCursor = null
-	  }
-	}
-
-	// These must be handled carefully, because naively registering a
-	// handler for each editor will cause the editors to never be
-	// garbage collected.
-
-	function forEachCodeMirror(f) {
-	  if (!document.body.getElementsByClassName) { return }
-	  var byClass = document.body.getElementsByClassName("CodeMirror")
-	  for (var i = 0; i < byClass.length; i++) {
-	    var cm = byClass[i].CodeMirror
-	    if (cm) { f(cm) }
-	  }
-	}
-
-	var globalsRegistered = false
-	function ensureGlobalHandlers() {
-	  if (globalsRegistered) { return }
-	  registerGlobalHandlers()
-	  globalsRegistered = true
-	}
-	function registerGlobalHandlers() {
-	  // When the window resizes, we need to refresh active editors.
-	  var resizeTimer
-	  on(window, "resize", function () {
-	    if (resizeTimer == null) { resizeTimer = setTimeout(function () {
-	      resizeTimer = null
-	      forEachCodeMirror(onResize)
-	    }, 100) }
-	  })
-	  // When the window loses focus, we want to show the editor as blurred
-	  on(window, "blur", function () { return forEachCodeMirror(onBlur); })
-	}
-	// Called when the window resizes
-	function onResize(cm) {
-	  var d = cm.display
-	  if (d.lastWrapHeight == d.wrapper.clientHeight && d.lastWrapWidth == d.wrapper.clientWidth)
-	    { return }
-	  // Might be a text scaling operation, clear size caches.
-	  d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null
-	  d.scrollbarsClipped = false
-	  cm.setSize()
-	}
-
-	var keyNames = {
-	  3: "Enter", 8: "Backspace", 9: "Tab", 13: "Enter", 16: "Shift", 17: "Ctrl", 18: "Alt",
-	  19: "Pause", 20: "CapsLock", 27: "Esc", 32: "Space", 33: "PageUp", 34: "PageDown", 35: "End",
-	  36: "Home", 37: "Left", 38: "Up", 39: "Right", 40: "Down", 44: "PrintScrn", 45: "Insert",
-	  46: "Delete", 59: ";", 61: "=", 91: "Mod", 92: "Mod", 93: "Mod",
-	  106: "*", 107: "=", 109: "-", 110: ".", 111: "/", 127: "Delete",
-	  173: "-", 186: ";", 187: "=", 188: ",", 189: "-", 190: ".", 191: "/", 192: "`", 219: "[", 220: "\\",
-	  221: "]", 222: "'", 63232: "Up", 63233: "Down", 63234: "Left", 63235: "Right", 63272: "Delete",
-	  63273: "Home", 63275: "End", 63276: "PageUp", 63277: "PageDown", 63302: "Insert"
-	}
-
-	// Number keys
-	for (var i = 0; i < 10; i++) { keyNames[i + 48] = keyNames[i + 96] = String(i) }
-	// Alphabetic keys
-	for (var i$1 = 65; i$1 <= 90; i$1++) { keyNames[i$1] = String.fromCharCode(i$1) }
-	// Function keys
-	for (var i$2 = 1; i$2 <= 12; i$2++) { keyNames[i$2 + 111] = keyNames[i$2 + 63235] = "F" + i$2 }
-
-	var keyMap = {}
-
-	keyMap.basic = {
-	  "Left": "goCharLeft", "Right": "goCharRight", "Up": "goLineUp", "Down": "goLineDown",
-	  "End": "goLineEnd", "Home": "goLineStartSmart", "PageUp": "goPageUp", "PageDown": "goPageDown",
-	  "Delete": "delCharAfter", "Backspace": "delCharBefore", "Shift-Backspace": "delCharBefore",
-	  "Tab": "defaultTab", "Shift-Tab": "indentAuto",
-	  "Enter": "newlineAndIndent", "Insert": "toggleOverwrite",
-	  "Esc": "singleSelection"
-	}
-	// Note that the save and find-related commands aren't defined by
-	// default. User code or addons can define them. Unknown commands
-	// are simply ignored.
-	keyMap.pcDefault = {
-	  "Ctrl-A": "selectAll", "Ctrl-D": "deleteLine", "Ctrl-Z": "undo", "Shift-Ctrl-Z": "redo", "Ctrl-Y": "redo",
-	  "Ctrl-Home": "goDocStart", "Ctrl-End": "goDocEnd", "Ctrl-Up": "goLineUp", "Ctrl-Down": "goLineDown",
-	  "Ctrl-Left": "goGroupLeft", "Ctrl-Right": "goGroupRight", "Alt-Left": "goLineStart", "Alt-Right": "goLineEnd",
-	  "Ctrl-Backspace": "delGroupBefore", "Ctrl-Delete": "delGroupAfter", "Ctrl-S": "save", "Ctrl-F": "find",
-	  "Ctrl-G": "findNext", "Shift-Ctrl-G": "findPrev", "Shift-Ctrl-F": "replace", "Shift-Ctrl-R": "replaceAll",
-	  "Ctrl-[": "indentLess", "Ctrl-]": "indentMore",
-	  "Ctrl-U": "undoSelection", "Shift-Ctrl-U": "redoSelection", "Alt-U": "redoSelection",
-	  fallthrough: "basic"
-	}
-	// Very basic readline/emacs-style bindings, which are standard on Mac.
-	keyMap.emacsy = {
-	  "Ctrl-F": "goCharRight", "Ctrl-B": "goCharLeft", "Ctrl-P": "goLineUp", "Ctrl-N": "goLineDown",
-	  "Alt-F": "goWordRight", "Alt-B": "goWordLeft", "Ctrl-A": "goLineStart", "Ctrl-E": "goLineEnd",
-	  "Ctrl-V": "goPageDown", "Shift-Ctrl-V": "goPageUp", "Ctrl-D": "delCharAfter", "Ctrl-H": "delCharBefore",
-	  "Alt-D": "delWordAfter", "Alt-Backspace": "delWordBefore", "Ctrl-K": "killLine", "Ctrl-T": "transposeChars",
-	  "Ctrl-O": "openLine"
-	}
-	keyMap.macDefault = {
-	  "Cmd-A": "selectAll", "Cmd-D": "deleteLine", "Cmd-Z": "undo", "Shift-Cmd-Z": "redo", "Cmd-Y": "redo",
-	  "Cmd-Home": "goDocStart", "Cmd-Up": "goDocStart", "Cmd-End": "goDocEnd", "Cmd-Down": "goDocEnd", "Alt-Left": "goGroupLeft",
-	  "Alt-Right": "goGroupRight", "Cmd-Left": "goLineLeft", "Cmd-Right": "goLineRight", "Alt-Backspace": "delGroupBefore",
-	  "Ctrl-Alt-Backspace": "delGroupAfter", "Alt-Delete": "delGroupAfter", "Cmd-S": "save", "Cmd-F": "find",
-	  "Cmd-G": "findNext", "Shift-Cmd-G": "findPrev", "Cmd-Alt-F": "replace", "Shift-Cmd-Alt-F": "replaceAll",
-	  "Cmd-[": "indentLess", "Cmd-]": "indentMore", "Cmd-Backspace": "delWrappedLineLeft", "Cmd-Delete": "delWrappedLineRight",
-	  "Cmd-U": "undoSelection", "Shift-Cmd-U": "redoSelection", "Ctrl-Up": "goDocStart", "Ctrl-Down": "goDocEnd",
-	  fallthrough: ["basic", "emacsy"]
-	}
-	keyMap["default"] = mac ? keyMap.macDefault : keyMap.pcDefault
-
-	// KEYMAP DISPATCH
-
-	function normalizeKeyName(name) {
-	  var parts = name.split(/-(?!$)/)
-	  name = parts[parts.length - 1]
-	  var alt, ctrl, shift, cmd
-	  for (var i = 0; i < parts.length - 1; i++) {
-	    var mod = parts[i]
-	    if (/^(cmd|meta|m)$/i.test(mod)) { cmd = true }
-	    else if (/^a(lt)?$/i.test(mod)) { alt = true }
-	    else if (/^(c|ctrl|control)$/i.test(mod)) { ctrl = true }
-	    else if (/^s(hift)?$/i.test(mod)) { shift = true }
-	    else { throw new Error("Unrecognized modifier name: " + mod) }
-	  }
-	  if (alt) { name = "Alt-" + name }
-	  if (ctrl) { name = "Ctrl-" + name }
-	  if (cmd) { name = "Cmd-" + name }
-	  if (shift) { name = "Shift-" + name }
-	  return name
-	}
-
-	// This is a kludge to keep keymaps mostly working as raw objects
-	// (backwards compatibility) while at the same time support features
-	// like normalization and multi-stroke key bindings. It compiles a
-	// new normalized keymap, and then updates the old object to reflect
-	// this.
-	function normalizeKeyMap(keymap) {
-	  var copy = {}
-	  for (var keyname in keymap) { if (keymap.hasOwnProperty(keyname)) {
-	    var value = keymap[keyname]
-	    if (/^(name|fallthrough|(de|at)tach)$/.test(keyname)) { continue }
-	    if (value == "...") { delete keymap[keyname]; continue }
-
-	    var keys = map(keyname.split(" "), normalizeKeyName)
-	    for (var i = 0; i < keys.length; i++) {
-	      var val = (void 0), name = (void 0)
-	      if (i == keys.length - 1) {
-	        name = keys.join(" ")
-	        val = value
-	      } else {
-	        name = keys.slice(0, i + 1).join(" ")
-	        val = "..."
-	      }
-	      var prev = copy[name]
-	      if (!prev) { copy[name] = val }
-	      else if (prev != val) { throw new Error("Inconsistent bindings for " + name) }
-	    }
-	    delete keymap[keyname]
-	  } }
-	  for (var prop in copy) { keymap[prop] = copy[prop] }
-	  return keymap
-	}
-
-	function lookupKey(key, map, handle, context) {
-	  map = getKeyMap(map)
-	  var found = map.call ? map.call(key, context) : map[key]
-	  if (found === false) { return "nothing" }
-	  if (found === "...") { return "multi" }
-	  if (found != null && handle(found)) { return "handled" }
-
-	  if (map.fallthrough) {
-	    if (Object.prototype.toString.call(map.fallthrough) != "[object Array]")
-	      { return lookupKey(key, map.fallthrough, handle, context) }
-	    for (var i = 0; i < map.fallthrough.length; i++) {
-	      var result = lookupKey(key, map.fallthrough[i], handle, context)
-	      if (result) { return result }
-	    }
-	  }
-	}
-
-	// Modifier key presses don't count as 'real' key presses for the
-	// purpose of keymap fallthrough.
-	function isModifierKey(value) {
-	  var name = typeof value == "string" ? value : keyNames[value.keyCode]
-	  return name == "Ctrl" || name == "Alt" || name == "Shift" || name == "Mod"
-	}
-
-	// Look up the name of a key as indicated by an event object.
-	function keyName(event, noShift) {
-	  if (presto && event.keyCode == 34 && event["char"]) { return false }
-	  var base = keyNames[event.keyCode], name = base
-	  if (name == null || event.altGraphKey) { return false }
-	  if (event.altKey && base != "Alt") { name = "Alt-" + name }
-	  if ((flipCtrlCmd ? event.metaKey : event.ctrlKey) && base != "Ctrl") { name = "Ctrl-" + name }
-	  if ((flipCtrlCmd ? event.ctrlKey : event.metaKey) && base != "Cmd") { name = "Cmd-" + name }
-	  if (!noShift && event.shiftKey && base != "Shift") { name = "Shift-" + name }
-	  return name
-	}
-
-	function getKeyMap(val) {
-	  return typeof val == "string" ? keyMap[val] : val
-	}
-
-	// Helper for deleting text near the selection(s), used to implement
-	// backspace, delete, and similar functionality.
-	function deleteNearSelection(cm, compute) {
-	  var ranges = cm.doc.sel.ranges, kill = []
-	  // Build up a set of ranges to kill first, merging overlapping
-	  // ranges.
-	  for (var i = 0; i < ranges.length; i++) {
-	    var toKill = compute(ranges[i])
-	    while (kill.length && cmp(toKill.from, lst(kill).to) <= 0) {
-	      var replaced = kill.pop()
-	      if (cmp(replaced.from, toKill.from) < 0) {
-	        toKill.from = replaced.from
-	        break
-	      }
-	    }
-	    kill.push(toKill)
-	  }
-	  // Next, remove those actual ranges.
-	  runInOp(cm, function () {
-	    for (var i = kill.length - 1; i >= 0; i--)
-	      { replaceRange(cm.doc, "", kill[i].from, kill[i].to, "+delete") }
-	    ensureCursorVisible(cm)
-	  })
-	}
-
-	// Commands are parameter-less actions that can be performed on an
-	// editor, mostly used for keybindings.
-	var commands = {
-	  selectAll: selectAll,
-	  singleSelection: function (cm) { return cm.setSelection(cm.getCursor("anchor"), cm.getCursor("head"), sel_dontScroll); },
-	  killLine: function (cm) { return deleteNearSelection(cm, function (range) {
-	    if (range.empty()) {
-	      var len = getLine(cm.doc, range.head.line).text.length
-	      if (range.head.ch == len && range.head.line < cm.lastLine())
-	        { return {from: range.head, to: Pos(range.head.line + 1, 0)} }
-	      else
-	        { return {from: range.head, to: Pos(range.head.line, len)} }
-	    } else {
-	      return {from: range.from(), to: range.to()}
-	    }
-	  }); },
-	  deleteLine: function (cm) { return deleteNearSelection(cm, function (range) { return ({
-	    from: Pos(range.from().line, 0),
-	    to: clipPos(cm.doc, Pos(range.to().line + 1, 0))
-	  }); }); },
-	  delLineLeft: function (cm) { return deleteNearSelection(cm, function (range) { return ({
-	    from: Pos(range.from().line, 0), to: range.from()
-	  }); }); },
-	  delWrappedLineLeft: function (cm) { return deleteNearSelection(cm, function (range) {
-	    var top = cm.charCoords(range.head, "div").top + 5
-	    var leftPos = cm.coordsChar({left: 0, top: top}, "div")
-	    return {from: leftPos, to: range.from()}
-	  }); },
-	  delWrappedLineRight: function (cm) { return deleteNearSelection(cm, function (range) {
-	    var top = cm.charCoords(range.head, "div").top + 5
-	    var rightPos = cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div")
-	    return {from: range.from(), to: rightPos }
-	  }); },
-	  undo: function (cm) { return cm.undo(); },
-	  redo: function (cm) { return cm.redo(); },
-	  undoSelection: function (cm) { return cm.undoSelection(); },
-	  redoSelection: function (cm) { return cm.redoSelection(); },
-	  goDocStart: function (cm) { return cm.extendSelection(Pos(cm.firstLine(), 0)); },
-	  goDocEnd: function (cm) { return cm.extendSelection(Pos(cm.lastLine())); },
-	  goLineStart: function (cm) { return cm.extendSelectionsBy(function (range) { return lineStart(cm, range.head.line); },
-	    {origin: "+move", bias: 1}
-	  ); },
-	  goLineStartSmart: function (cm) { return cm.extendSelectionsBy(function (range) { return lineStartSmart(cm, range.head); },
-	    {origin: "+move", bias: 1}
-	  ); },
-	  goLineEnd: function (cm) { return cm.extendSelectionsBy(function (range) { return lineEnd(cm, range.head.line); },
-	    {origin: "+move", bias: -1}
-	  ); },
-	  goLineRight: function (cm) { return cm.extendSelectionsBy(function (range) {
-	    var top = cm.charCoords(range.head, "div").top + 5
-	    return cm.coordsChar({left: cm.display.lineDiv.offsetWidth + 100, top: top}, "div")
-	  }, sel_move); },
-	  goLineLeft: function (cm) { return cm.extendSelectionsBy(function (range) {
-	    var top = cm.charCoords(range.head, "div").top + 5
-	    return cm.coordsChar({left: 0, top: top}, "div")
-	  }, sel_move); },
-	  goLineLeftSmart: function (cm) { return cm.extendSelectionsBy(function (range) {
-	    var top = cm.charCoords(range.head, "div").top + 5
-	    var pos = cm.coordsChar({left: 0, top: top}, "div")
-	    if (pos.ch < cm.getLine(pos.line).search(/\S/)) { return lineStartSmart(cm, range.head) }
-	    return pos
-	  }, sel_move); },
-	  goLineUp: function (cm) { return cm.moveV(-1, "line"); },
-	  goLineDown: function (cm) { return cm.moveV(1, "line"); },
-	  goPageUp: function (cm) { return cm.moveV(-1, "page"); },
-	  goPageDown: function (cm) { return cm.moveV(1, "page"); },
-	  goCharLeft: function (cm) { return cm.moveH(-1, "char"); },
-	  goCharRight: function (cm) { return cm.moveH(1, "char"); },
-	  goColumnLeft: function (cm) { return cm.moveH(-1, "column"); },
-	  goColumnRight: function (cm) { return cm.moveH(1, "column"); },
-	  goWordLeft: function (cm) { return cm.moveH(-1, "word"); },
-	  goGroupRight: function (cm) { return cm.moveH(1, "group"); },
-	  goGroupLeft: function (cm) { return cm.moveH(-1, "group"); },
-	  goWordRight: function (cm) { return cm.moveH(1, "word"); },
-	  delCharBefore: function (cm) { return cm.deleteH(-1, "char"); },
-	  delCharAfter: function (cm) { return cm.deleteH(1, "char"); },
-	  delWordBefore: function (cm) { return cm.deleteH(-1, "word"); },
-	  delWordAfter: function (cm) { return cm.deleteH(1, "word"); },
-	  delGroupBefore: function (cm) { return cm.deleteH(-1, "group"); },
-	  delGroupAfter: function (cm) { return cm.deleteH(1, "group"); },
-	  indentAuto: function (cm) { return cm.indentSelection("smart"); },
-	  indentMore: function (cm) { return cm.indentSelection("add"); },
-	  indentLess: function (cm) { return cm.indentSelection("subtract"); },
-	  insertTab: function (cm) { return cm.replaceSelection("\t"); },
-	  insertSoftTab: function (cm) {
-	    var spaces = [], ranges = cm.listSelections(), tabSize = cm.options.tabSize
-	    for (var i = 0; i < ranges.length; i++) {
-	      var pos = ranges[i].from()
-	      var col = countColumn(cm.getLine(pos.line), pos.ch, tabSize)
-	      spaces.push(spaceStr(tabSize - col % tabSize))
-	    }
-	    cm.replaceSelections(spaces)
-	  },
-	  defaultTab: function (cm) {
-	    if (cm.somethingSelected()) { cm.indentSelection("add") }
-	    else { cm.execCommand("insertTab") }
-	  },
-	  // Swap the two chars left and right of each selection's head.
-	  // Move cursor behind the two swapped characters afterwards.
-	  //
-	  // Doesn't consider line feeds a character.
-	  // Doesn't scan more than one line above to find a character.
-	  // Doesn't do anything on an empty line.
-	  // Doesn't do anything with non-empty selections.
-	  transposeChars: function (cm) { return runInOp(cm, function () {
-	    var ranges = cm.listSelections(), newSel = []
-	    for (var i = 0; i < ranges.length; i++) {
-	      if (!ranges[i].empty()) { continue }
-	      var cur = ranges[i].head, line = getLine(cm.doc, cur.line).text
-	      if (line) {
-	        if (cur.ch == line.length) { cur = new Pos(cur.line, cur.ch - 1) }
-	        if (cur.ch > 0) {
-	          cur = new Pos(cur.line, cur.ch + 1)
-	          cm.replaceRange(line.charAt(cur.ch - 1) + line.charAt(cur.ch - 2),
-	                          Pos(cur.line, cur.ch - 2), cur, "+transpose")
-	        } else if (cur.line > cm.doc.first) {
-	          var prev = getLine(cm.doc, cur.line - 1).text
-	          if (prev) {
-	            cur = new Pos(cur.line, 1)
-	            cm.replaceRange(line.charAt(0) + cm.doc.lineSeparator() +
-	                            prev.charAt(prev.length - 1),
-	                            Pos(cur.line - 1, prev.length - 1), cur, "+transpose")
-	          }
-	        }
-	      }
-	      newSel.push(new Range(cur, cur))
-	    }
-	    cm.setSelections(newSel)
-	  }); },
-	  newlineAndIndent: function (cm) { return runInOp(cm, function () {
-	    var sels = cm.listSelections()
-	    for (var i = sels.length - 1; i >= 0; i--)
-	      { cm.replaceRange(cm.doc.lineSeparator(), sels[i].anchor, sels[i].head, "+input") }
-	    sels = cm.listSelections()
-	    for (var i$1 = 0; i$1 < sels.length; i$1++)
-	      { cm.indentLine(sels[i$1].from().line, null, true) }
-	    ensureCursorVisible(cm)
-	  }); },
-	  openLine: function (cm) { return cm.replaceSelection("\n", "start"); },
-	  toggleOverwrite: function (cm) { return cm.toggleOverwrite(); }
-	}
-
-
-	function lineStart(cm, lineN) {
-	  var line = getLine(cm.doc, lineN)
-	  var visual = visualLine(line)
-	  if (visual != line) { lineN = lineNo(visual) }
-	  var order = getOrder(visual)
-	  var ch = !order ? 0 : order[0].level % 2 ? lineRight(visual) : lineLeft(visual)
-	  return Pos(lineN, ch)
-	}
-	function lineEnd(cm, lineN) {
-	  var merged, line = getLine(cm.doc, lineN)
-	  while (merged = collapsedSpanAtEnd(line)) {
-	    line = merged.find(1, true).line
-	    lineN = null
-	  }
-	  var order = getOrder(line)
-	  var ch = !order ? line.text.length : order[0].level % 2 ? lineLeft(line) : lineRight(line)
-	  return Pos(lineN == null ? lineNo(line) : lineN, ch)
-	}
-	function lineStartSmart(cm, pos) {
-	  var start = lineStart(cm, pos.line)
-	  var line = getLine(cm.doc, start.line)
-	  var order = getOrder(line)
-	  if (!order || order[0].level == 0) {
-	    var firstNonWS = Math.max(0, line.text.search(/\S/))
-	    var inWS = pos.line == start.line && pos.ch <= firstNonWS && pos.ch
-	    return Pos(start.line, inWS ? 0 : firstNonWS)
-	  }
-	  return start
-	}
-
-	// Run a handler that was bound to a key.
-	function doHandleBinding(cm, bound, dropShift) {
-	  if (typeof bound == "string") {
-	    bound = commands[bound]
-	    if (!bound) { return false }
-	  }
-	  // Ensure previous input has been read, so that the handler sees a
-	  // consistent view of the document
-	  cm.display.input.ensurePolled()
-	  var prevShift = cm.display.shift, done = false
-	  try {
-	    if (cm.isReadOnly()) { cm.state.suppressEdits = true }
-	    if (dropShift) { cm.display.shift = false }
-	    done = bound(cm) != Pass
-	  } finally {
-	    cm.display.shift = prevShift
-	    cm.state.suppressEdits = false
-	  }
-	  return done
-	}
-
-	function lookupKeyForEditor(cm, name, handle) {
-	  for (var i = 0; i < cm.state.keyMaps.length; i++) {
-	    var result = lookupKey(name, cm.state.keyMaps[i], handle, cm)
-	    if (result) { return result }
-	  }
-	  return (cm.options.extraKeys && lookupKey(name, cm.options.extraKeys, handle, cm))
-	    || lookupKey(name, cm.options.keyMap, handle, cm)
-	}
-
-	var stopSeq = new Delayed
-	function dispatchKey(cm, name, e, handle) {
-	  var seq = cm.state.keySeq
-	  if (seq) {
-	    if (isModifierKey(name)) { return "handled" }
-	    stopSeq.set(50, function () {
-	      if (cm.state.keySeq == seq) {
-	        cm.state.keySeq = null
-	        cm.display.input.reset()
-	      }
-	    })
-	    name = seq + " " + name
-	  }
-	  var result = lookupKeyForEditor(cm, name, handle)
-
-	  if (result == "multi")
-	    { cm.state.keySeq = name }
-	  if (result == "handled")
-	    { signalLater(cm, "keyHandled", cm, name, e) }
-
-	  if (result == "handled" || result == "multi") {
-	    e_preventDefault(e)
-	    restartBlink(cm)
-	  }
-
-	  if (seq && !result && /\'$/.test(name)) {
-	    e_preventDefault(e)
-	    return true
-	  }
-	  return !!result
-	}
-
-	// Handle a key from the keydown event.
-	function handleKeyBinding(cm, e) {
-	  var name = keyName(e, true)
-	  if (!name) { return false }
-
-	  if (e.shiftKey && !cm.state.keySeq) {
-	    // First try to resolve full name (including 'Shift-'). Failing
-	    // that, see if there is a cursor-motion command (starting with
-	    // 'go') bound to the keyname without 'Shift-'.
-	    return dispatchKey(cm, "Shift-" + name, e, function (b) { return doHandleBinding(cm, b, true); })
-	        || dispatchKey(cm, name, e, function (b) {
-	             if (typeof b == "string" ? /^go[A-Z]/.test(b) : b.motion)
-	               { return doHandleBinding(cm, b) }
-	           })
-	  } else {
-	    return dispatchKey(cm, name, e, function (b) { return doHandleBinding(cm, b); })
-	  }
-	}
-
-	// Handle a key from the keypress event
-	function handleCharBinding(cm, e, ch) {
-	  return dispatchKey(cm, "'" + ch + "'", e, function (b) { return doHandleBinding(cm, b, true); })
-	}
-
-	var lastStoppedKey = null
-	function onKeyDown(e) {
-	  var cm = this
-	  cm.curOp.focus = activeElt()
-	  if (signalDOMEvent(cm, e)) { return }
-	  // IE does strange things with escape.
-	  if (ie && ie_version < 11 && e.keyCode == 27) { e.returnValue = false }
-	  var code = e.keyCode
-	  cm.display.shift = code == 16 || e.shiftKey
-	  var handled = handleKeyBinding(cm, e)
-	  if (presto) {
-	    lastStoppedKey = handled ? code : null
-	    // Opera has no cut event... we try to at least catch the key combo
-	    if (!handled && code == 88 && !hasCopyEvent && (mac ? e.metaKey : e.ctrlKey))
-	      { cm.replaceSelection("", null, "cut") }
-	  }
-
-	  // Turn mouse into crosshair when Alt is held on Mac.
-	  if (code == 18 && !/\bCodeMirror-crosshair\b/.test(cm.display.lineDiv.className))
-	    { showCrossHair(cm) }
-	}
-
-	function showCrossHair(cm) {
-	  var lineDiv = cm.display.lineDiv
-	  addClass(lineDiv, "CodeMirror-crosshair")
-
-	  function up(e) {
-	    if (e.keyCode == 18 || !e.altKey) {
-	      rmClass(lineDiv, "CodeMirror-crosshair")
-	      off(document, "keyup", up)
-	      off(document, "mouseover", up)
-	    }
-	  }
-	  on(document, "keyup", up)
-	  on(document, "mouseover", up)
-	}
-
-	function onKeyUp(e) {
-	  if (e.keyCode == 16) { this.doc.sel.shift = false }
-	  signalDOMEvent(this, e)
-	}
-
-	function onKeyPress(e) {
-	  var cm = this
-	  if (eventInWidget(cm.display, e) || signalDOMEvent(cm, e) || e.ctrlKey && !e.altKey || mac && e.metaKey) { return }
-	  var keyCode = e.keyCode, charCode = e.charCode
-	  if (presto && keyCode == lastStoppedKey) {lastStoppedKey = null; e_preventDefault(e); return}
-	  if ((presto && (!e.which || e.which < 10)) && handleKeyBinding(cm, e)) { return }
-	  var ch = String.fromCharCode(charCode == null ? keyCode : charCode)
-	  // Some browsers fire keypress events for backspace
-	  if (ch == "\x08") { return }
-	  if (handleCharBinding(cm, e, ch)) { return }
-	  cm.display.input.onKeyPress(e)
-	}
-
-	// A mouse down can be a single click, double click, triple click,
-	// start of selection drag, start of text drag, new cursor
-	// (ctrl-click), rectangle drag (alt-drag), or xwin
-	// middle-click-paste. Or it might be a click on something we should
-	// not interfere with, such as a scrollbar or widget.
-	function onMouseDown(e) {
-	  var cm = this, display = cm.display
-	  if (signalDOMEvent(cm, e) || display.activeTouch && display.input.supportsTouch()) { return }
-	  display.input.ensurePolled()
-	  display.shift = e.shiftKey
-
-	  if (eventInWidget(display, e)) {
-	    if (!webkit) {
-	      // Briefly turn off draggability, to allow widgets to do
-	      // normal dragging things.
-	      display.scroller.draggable = false
-	      setTimeout(function () { return display.scroller.draggable = true; }, 100)
-	    }
-	    return
-	  }
-	  if (clickInGutter(cm, e)) { return }
-	  var start = posFromMouse(cm, e)
-	  window.focus()
-
-	  switch (e_button(e)) {
-	  case 1:
-	    // #3261: make sure, that we're not starting a second selection
-	    if (cm.state.selectingText)
-	      { cm.state.selectingText(e) }
-	    else if (start)
-	      { leftButtonDown(cm, e, start) }
-	    else if (e_target(e) == display.scroller)
-	      { e_preventDefault(e) }
-	    break
-	  case 2:
-	    if (webkit) { cm.state.lastMiddleDown = +new Date }
-	    if (start) { extendSelection(cm.doc, start) }
-	    setTimeout(function () { return display.input.focus(); }, 20)
-	    e_preventDefault(e)
-	    break
-	  case 3:
-	    if (captureRightClick) { onContextMenu(cm, e) }
-	    else { delayBlurEvent(cm) }
-	    break
-	  }
-	}
-
-	var lastClick;
-	var lastDoubleClick;
-	function leftButtonDown(cm, e, start) {
-	  if (ie) { setTimeout(bind(ensureFocus, cm), 0) }
-	  else { cm.curOp.focus = activeElt() }
-
-	  var now = +new Date, type
-	  if (lastDoubleClick && lastDoubleClick.time > now - 400 && cmp(lastDoubleClick.pos, start) == 0) {
-	    type = "triple"
-	  } else if (lastClick && lastClick.time > now - 400 && cmp(lastClick.pos, start) == 0) {
-	    type = "double"
-	    lastDoubleClick = {time: now, pos: start}
-	  } else {
-	    type = "single"
-	    lastClick = {time: now, pos: start}
-	  }
-
-	  var sel = cm.doc.sel, modifier = mac ? e.metaKey : e.ctrlKey, contained
-	  if (cm.options.dragDrop && dragAndDrop && !cm.isReadOnly() &&
-	      type == "single" && (contained = sel.contains(start)) > -1 &&
-	      (cmp((contained = sel.ranges[contained]).from(), start) < 0 || start.xRel > 0) &&
-	      (cmp(contained.to(), start) > 0 || start.xRel < 0))
-	    { leftButtonStartDrag(cm, e, start, modifier) }
-	  else
-	    { leftButtonSelect(cm, e, start, type, modifier) }
-	}
-
-	// Start a text drag. When it ends, see if any dragging actually
-	// happen, and treat as a click if it didn't.
-	function leftButtonStartDrag(cm, e, start, modifier) {
-	  var display = cm.display, startTime = +new Date
-	  var dragEnd = operation(cm, function (e2) {
-	    if (webkit) { display.scroller.draggable = false }
-	    cm.state.draggingText = false
-	    off(document, "mouseup", dragEnd)
-	    off(display.scroller, "drop", dragEnd)
-	    if (Math.abs(e.clientX - e2.clientX) + Math.abs(e.clientY - e2.clientY) < 10) {
-	      e_preventDefault(e2)
-	      if (!modifier && +new Date - 200 < startTime)
-	        { extendSelection(cm.doc, start) }
-	      // Work around unexplainable focus problem in IE9 (#2127) and Chrome (#3081)
-	      if (webkit || ie && ie_version == 9)
-	        { setTimeout(function () {document.body.focus(); display.input.focus()}, 20) }
-	      else
-	        { display.input.focus() }
-	    }
-	  })
-	  // Let the drag handler handle this.
-	  if (webkit) { display.scroller.draggable = true }
-	  cm.state.draggingText = dragEnd
-	  dragEnd.copy = mac ? e.altKey : e.ctrlKey
-	  // IE's approach to draggable
-	  if (display.scroller.dragDrop) { display.scroller.dragDrop() }
-	  on(document, "mouseup", dragEnd)
-	  on(display.scroller, "drop", dragEnd)
-	}
-
-	// Normal selection, as opposed to text dragging.
-	function leftButtonSelect(cm, e, start, type, addNew) {
-	  var display = cm.display, doc = cm.doc
-	  e_preventDefault(e)
-
-	  var ourRange, ourIndex, startSel = doc.sel, ranges = startSel.ranges
-	  if (addNew && !e.shiftKey) {
-	    ourIndex = doc.sel.contains(start)
-	    if (ourIndex > -1)
-	      { ourRange = ranges[ourIndex] }
-	    else
-	      { ourRange = new Range(start, start) }
-	  } else {
-	    ourRange = doc.sel.primary()
-	    ourIndex = doc.sel.primIndex
-	  }
-
-	  if (chromeOS ? e.shiftKey && e.metaKey : e.altKey) {
-	    type = "rect"
-	    if (!addNew) { ourRange = new Range(start, start) }
-	    start = posFromMouse(cm, e, true, true)
-	    ourIndex = -1
-	  } else if (type == "double") {
-	    var word = cm.findWordAt(start)
-	    if (cm.display.shift || doc.extend)
-	      { ourRange = extendRange(doc, ourRange, word.anchor, word.head) }
-	    else
-	      { ourRange = word }
-	  } else if (type == "triple") {
-	    var line = new Range(Pos(start.line, 0), clipPos(doc, Pos(start.line + 1, 0)))
-	    if (cm.display.shift || doc.extend)
-	      { ourRange = extendRange(doc, ourRange, line.anchor, line.head) }
-	    else
-	      { ourRange = line }
-	  } else {
-	    ourRange = extendRange(doc, ourRange, start)
-	  }
-
-	  if (!addNew) {
-	    ourIndex = 0
-	    setSelection(doc, new Selection([ourRange], 0), sel_mouse)
-	    startSel = doc.sel
-	  } else if (ourIndex == -1) {
-	    ourIndex = ranges.length
-	    setSelection(doc, normalizeSelection(ranges.concat([ourRange]), ourIndex),
-	                 {scroll: false, origin: "*mouse"})
-	  } else if (ranges.length > 1 && ranges[ourIndex].empty() && type == "single" && !e.shiftKey) {
-	    setSelection(doc, normalizeSelection(ranges.slice(0, ourIndex).concat(ranges.slice(ourIndex + 1)), 0),
-	                 {scroll: false, origin: "*mouse"})
-	    startSel = doc.sel
-	  } else {
-	    replaceOneSelection(doc, ourIndex, ourRange, sel_mouse)
-	  }
-
-	  var lastPos = start
-	  function extendTo(pos) {
-	    if (cmp(lastPos, pos) == 0) { return }
-	    lastPos = pos
-
-	    if (type == "rect") {
-	      var ranges = [], tabSize = cm.options.tabSize
-	      var startCol = countColumn(getLine(doc, start.line).text, start.ch, tabSize)
-	      var posCol = countColumn(getLine(doc, pos.line).text, pos.ch, tabSize)
-	      var left = Math.min(startCol, posCol), right = Math.max(startCol, posCol)
-	      for (var line = Math.min(start.line, pos.line), end = Math.min(cm.lastLine(), Math.max(start.line, pos.line));
-	           line <= end; line++) {
-	        var text = getLine(doc, line).text, leftPos = findColumn(text, left, tabSize)
-	        if (left == right)
-	          { ranges.push(new Range(Pos(line, leftPos), Pos(line, leftPos))) }
-	        else if (text.length > leftPos)
-	          { ranges.push(new Range(Pos(line, leftPos), Pos(line, findColumn(text, right, tabSize)))) }
-	      }
-	      if (!ranges.length) { ranges.push(new Range(start, start)) }
-	      setSelection(doc, normalizeSelection(startSel.ranges.slice(0, ourIndex).concat(ranges), ourIndex),
-	                   {origin: "*mouse", scroll: false})
-	      cm.scrollIntoView(pos)
-	    } else {
-	      var oldRange = ourRange
-	      var anchor = oldRange.anchor, head = pos
-	      if (type != "single") {
-	        var range
-	        if (type == "double")
-	          { range = cm.findWordAt(pos) }
-	        else
-	          { range = new Range(Pos(pos.line, 0), clipPos(doc, Pos(pos.line + 1, 0))) }
-	        if (cmp(range.anchor, anchor) > 0) {
-	          head = range.head
-	          anchor = minPos(oldRange.from(), range.anchor)
-	        } else {
-	          head = range.anchor
-	          anchor = maxPos(oldRange.to(), range.head)
-	        }
-	      }
-	      var ranges$1 = startSel.ranges.slice(0)
-	      ranges$1[ourIndex] = new Range(clipPos(doc, anchor), head)
-	      setSelection(doc, normalizeSelection(ranges$1, ourIndex), sel_mouse)
-	    }
-	  }
-
-	  var editorSize = display.wrapper.getBoundingClientRect()
-	  // Used to ensure timeout re-tries don't fire when another extend
-	  // happened in the meantime (clearTimeout isn't reliable -- at
-	  // least on Chrome, the timeouts still happen even when cleared,
-	  // if the clear happens after their scheduled firing time).
-	  var counter = 0
-
-	  function extend(e) {
-	    var curCount = ++counter
-	    var cur = posFromMouse(cm, e, true, type == "rect")
-	    if (!cur) { return }
-	    if (cmp(cur, lastPos) != 0) {
-	      cm.curOp.focus = activeElt()
-	      extendTo(cur)
-	      var visible = visibleLines(display, doc)
-	      if (cur.line >= visible.to || cur.line < visible.from)
-	        { setTimeout(operation(cm, function () {if (counter == curCount) { extend(e) }}), 150) }
-	    } else {
-	      var outside = e.clientY < editorSize.top ? -20 : e.clientY > editorSize.bottom ? 20 : 0
-	      if (outside) { setTimeout(operation(cm, function () {
-	        if (counter != curCount) { return }
-	        display.scroller.scrollTop += outside
-	        extend(e)
-	      }), 50) }
-	    }
-	  }
-
-	  function done(e) {
-	    cm.state.selectingText = false
-	    counter = Infinity
-	    e_preventDefault(e)
-	    display.input.focus()
-	    off(document, "mousemove", move)
-	    off(document, "mouseup", up)
-	    doc.history.lastSelOrigin = null
-	  }
-
-	  var move = operation(cm, function (e) {
-	    if (!e_button(e)) { done(e) }
-	    else { extend(e) }
-	  })
-	  var up = operation(cm, done)
-	  cm.state.selectingText = up
-	  on(document, "mousemove", move)
-	  on(document, "mouseup", up)
-	}
-
-
-	// Determines whether an event happened in the gutter, and fires the
-	// handlers for the corresponding event.
-	function gutterEvent(cm, e, type, prevent) {
-	  var mX, mY
-	  try { mX = e.clientX; mY = e.clientY }
-	  catch(e) { return false }
-	  if (mX >= Math.floor(cm.display.gutters.getBoundingClientRect().right)) { return false }
-	  if (prevent) { e_preventDefault(e) }
-
-	  var display = cm.display
-	  var lineBox = display.lineDiv.getBoundingClientRect()
-
-	  if (mY > lineBox.bottom || !hasHandler(cm, type)) { return e_defaultPrevented(e) }
-	  mY -= lineBox.top - display.viewOffset
-
-	  for (var i = 0; i < cm.options.gutters.length; ++i) {
-	    var g = display.gutters.childNodes[i]
-	    if (g && g.getBoundingClientRect().right >= mX) {
-	      var line = lineAtHeight(cm.doc, mY)
-	      var gutter = cm.options.gutters[i]
-	      signal(cm, type, cm, line, gutter, e)
-	      return e_defaultPrevented(e)
-	    }
-	  }
-	}
-
-	function clickInGutter(cm, e) {
-	  return gutterEvent(cm, e, "gutterClick", true)
-	}
-
-	// CONTEXT MENU HANDLING
-
-	// To make the context menu work, we need to briefly unhide the
-	// textarea (making it as unobtrusive as possible) to let the
-	// right-click take effect on it.
-	function onContextMenu(cm, e) {
-	  if (eventInWidget(cm.display, e) || contextMenuInGutter(cm, e)) { return }
-	  if (signalDOMEvent(cm, e, "contextmenu")) { return }
-	  cm.display.input.onContextMenu(e)
-	}
-
-	function contextMenuInGutter(cm, e) {
-	  if (!hasHandler(cm, "gutterContextMenu")) { return false }
-	  return gutterEvent(cm, e, "gutterContextMenu", false)
-	}
-
-	function themeChanged(cm) {
-	  cm.display.wrapper.className = cm.display.wrapper.className.replace(/\s*cm-s-\S+/g, "") +
-	    cm.options.theme.replace(/(^|\s)\s*/g, " cm-s-")
-	  clearCaches(cm)
-	}
-
-	var Init = {toString: function(){return "CodeMirror.Init"}}
-
-	var defaults = {}
-	var optionHandlers = {}
-
-	function defineOptions(CodeMirror) {
-	  var optionHandlers = CodeMirror.optionHandlers
-
-	  function option(name, deflt, handle, notOnInit) {
-	    CodeMirror.defaults[name] = deflt
-	    if (handle) { optionHandlers[name] =
-	      notOnInit ? function (cm, val, old) {if (old != Init) { handle(cm, val, old) }} : handle }
-	  }
-
-	  CodeMirror.defineOption = option
-
-	  // Passed to option handlers when there is no old value.
-	  CodeMirror.Init = Init
-
-	  // These two are, on init, called from the constructor because they
-	  // have to be initialized before the editor can start at all.
-	  option("value", "", function (cm, val) { return cm.setValue(val); }, true)
-	  option("mode", null, function (cm, val) {
-	    cm.doc.modeOption = val
-	    loadMode(cm)
-	  }, true)
-
-	  option("indentUnit", 2, loadMode, true)
-	  option("indentWithTabs", false)
-	  option("smartIndent", true)
-	  option("tabSize", 4, function (cm) {
-	    resetModeState(cm)
-	    clearCaches(cm)
-	    regChange(cm)
-	  }, true)
-	  option("lineSeparator", null, function (cm, val) {
-	    cm.doc.lineSep = val
-	    if (!val) { return }
-	    var newBreaks = [], lineNo = cm.doc.first
-	    cm.doc.iter(function (line) {
-	      for (var pos = 0;;) {
-	        var found = line.text.indexOf(val, pos)
-	        if (found == -1) { break }
-	        pos = found + val.length
-	        newBreaks.push(Pos(lineNo, found))
-	      }
-	      lineNo++
-	    })
-	    for (var i = newBreaks.length - 1; i >= 0; i--)
-	      { replaceRange(cm.doc, val, newBreaks[i], Pos(newBreaks[i].line, newBreaks[i].ch + val.length)) }
-	  })
-	  option("specialChars", /[\u0000-\u001f\u007f\u00ad\u200b-\u200f\u2028\u2029\ufeff]/g, function (cm, val, old) {
-	    cm.state.specialChars = new RegExp(val.source + (val.test("\t") ? "" : "|\t"), "g")
-	    if (old != Init) { cm.refresh() }
-	  })
-	  option("specialCharPlaceholder", defaultSpecialCharPlaceholder, function (cm) { return cm.refresh(); }, true)
-	  option("electricChars", true)
-	  option("inputStyle", mobile ? "contenteditable" : "textarea", function () {
-	    throw new Error("inputStyle can not (yet) be changed in a running editor") // FIXME
-	  }, true)
-	  option("spellcheck", false, function (cm, val) { return cm.getInputField().spellcheck = val; }, true)
-	  option("rtlMoveVisually", !windows)
-	  option("wholeLineUpdateBefore", true)
-
-	  option("theme", "default", function (cm) {
-	    themeChanged(cm)
-	    guttersChanged(cm)
-	  }, true)
-	  option("keyMap", "default", function (cm, val, old) {
-	    var next = getKeyMap(val)
-	    var prev = old != Init && getKeyMap(old)
-	    if (prev && prev.detach) { prev.detach(cm, next) }
-	    if (next.attach) { next.attach(cm, prev || null) }
-	  })
-	  option("extraKeys", null)
-
-	  option("lineWrapping", false, wrappingChanged, true)
-	  option("gutters", [], function (cm) {
-	    setGuttersForLineNumbers(cm.options)
-	    guttersChanged(cm)
-	  }, true)
-	  option("fixedGutter", true, function (cm, val) {
-	    cm.display.gutters.style.left = val ? compensateForHScroll(cm.display) + "px" : "0"
-	    cm.refresh()
-	  }, true)
-	  option("coverGutterNextToScrollbar", false, function (cm) { return updateScrollbars(cm); }, true)
-	  option("scrollbarStyle", "native", function (cm) {
-	    initScrollbars(cm)
-	    updateScrollbars(cm)
-	    cm.display.scrollbars.setScrollTop(cm.doc.scrollTop)
-	    cm.display.scrollbars.setScrollLeft(cm.doc.scrollLeft)
-	  }, true)
-	  option("lineNumbers", false, function (cm) {
-	    setGuttersForLineNumbers(cm.options)
-	    guttersChanged(cm)
-	  }, true)
-	  option("firstLineNumber", 1, guttersChanged, true)
-	  option("lineNumberFormatter", function (integer) { return integer; }, guttersChanged, true)
-	  option("showCursorWhenSelecting", false, updateSelection, true)
-
-	  option("resetSelectionOnContextMenu", true)
-	  option("lineWiseCopyCut", true)
-
-	  option("readOnly", false, function (cm, val) {
-	    if (val == "nocursor") {
-	      onBlur(cm)
-	      cm.display.input.blur()
-	      cm.display.disabled = true
-	    } else {
-	      cm.display.disabled = false
-	    }
-	    cm.display.input.readOnlyChanged(val)
-	  })
-	  option("disableInput", false, function (cm, val) {if (!val) { cm.display.input.reset() }}, true)
-	  option("dragDrop", true, dragDropChanged)
-	  option("allowDropFileTypes", null)
-
-	  option("cursorBlinkRate", 530)
-	  option("cursorScrollMargin", 0)
-	  option("cursorHeight", 1, updateSelection, true)
-	  option("singleCursorHeightPerLine", true, updateSelection, true)
-	  option("workTime", 100)
-	  option("workDelay", 100)
-	  option("flattenSpans", true, resetModeState, true)
-	  option("addModeClass", false, resetModeState, true)
-	  option("pollInterval", 100)
-	  option("undoDepth", 200, function (cm, val) { return cm.doc.history.undoDepth = val; })
-	  option("historyEventDelay", 1250)
-	  option("viewportMargin", 10, function (cm) { return cm.refresh(); }, true)
-	  option("maxHighlightLength", 10000, resetModeState, true)
-	  option("moveInputWithCursor", true, function (cm, val) {
-	    if (!val) { cm.display.input.resetPosition() }
-	  })
-
-	  option("tabindex", null, function (cm, val) { return cm.display.input.getField().tabIndex = val || ""; })
-	  option("autofocus", null)
-	}
-
-	function guttersChanged(cm) {
-	  updateGutters(cm)
-	  regChange(cm)
-	  setTimeout(function () { return alignHorizontally(cm); }, 20)
-	}
-
-	function dragDropChanged(cm, value, old) {
-	  var wasOn = old && old != Init
-	  if (!value != !wasOn) {
-	    var funcs = cm.display.dragFunctions
-	    var toggle = value ? on : off
-	    toggle(cm.display.scroller, "dragstart", funcs.start)
-	    toggle(cm.display.scroller, "dragenter", funcs.enter)
-	    toggle(cm.display.scroller, "dragover", funcs.over)
-	    toggle(cm.display.scroller, "dragleave", funcs.leave)
-	    toggle(cm.display.scroller, "drop", funcs.drop)
-	  }
-	}
-
-	function wrappingChanged(cm) {
-	  if (cm.options.lineWrapping) {
-	    addClass(cm.display.wrapper, "CodeMirror-wrap")
-	    cm.display.sizer.style.minWidth = ""
-	    cm.display.sizerWidth = null
-	  } else {
-	    rmClass(cm.display.wrapper, "CodeMirror-wrap")
-	    findMaxLine(cm)
-	  }
-	  estimateLineHeights(cm)
-	  regChange(cm)
-	  clearCaches(cm)
-	  setTimeout(function () { return updateScrollbars(cm); }, 100)
-	}
-
-	// A CodeMirror instance represents an editor. This is the object
-	// that user code is usually dealing with.
-
-	function CodeMirror(place, options) {
-	  var this$1 = this;
-
-	  if (!(this instanceof CodeMirror)) { return new CodeMirror(place, options) }
-
-	  this.options = options = options ? copyObj(options) : {}
-	  // Determine effective options based on given values and defaults.
-	  copyObj(defaults, options, false)
-	  setGuttersForLineNumbers(options)
-
-	  var doc = options.value
-	  if (typeof doc == "string") { doc = new Doc(doc, options.mode, null, options.lineSeparator) }
-	  this.doc = doc
-
-	  var input = new CodeMirror.inputStyles[options.inputStyle](this)
-	  var display = this.display = new Display(place, doc, input)
-	  display.wrapper.CodeMirror = this
-	  updateGutters(this)
-	  themeChanged(this)
-	  if (options.lineWrapping)
-	    { this.display.wrapper.className += " CodeMirror-wrap" }
-	  if (options.autofocus && !mobile) { display.input.focus() }
-	  initScrollbars(this)
-
-	  this.state = {
-	    keyMaps: [],  // stores maps added by addKeyMap
-	    overlays: [], // highlighting overlays, as added by addOverlay
-	    modeGen: 0,   // bumped when mode/overlay changes, used to invalidate highlighting info
-	    overwrite: false,
-	    delayingBlurEvent: false,
-	    focused: false,
-	    suppressEdits: false, // used to disable editing during key handlers when in readOnly mode
-	    pasteIncoming: false, cutIncoming: false, // help recognize paste/cut edits in input.poll
-	    selectingText: false,
-	    draggingText: false,
-	    highlight: new Delayed(), // stores highlight worker timeout
-	    keySeq: null,  // Unfinished key sequence
-	    specialChars: null
-	  }
-
-	  // Override magic textarea content restore that IE sometimes does
-	  // on our hidden textarea on reload
-	  if (ie && ie_version < 11) { setTimeout(function () { return this$1.display.input.reset(true); }, 20) }
-
-	  registerEventHandlers(this)
-	  ensureGlobalHandlers()
-
-	  startOperation(this)
-	  this.curOp.forceUpdate = true
-	  attachDoc(this, doc)
-
-	  if ((options.autofocus && !mobile) || this.hasFocus())
-	    { setTimeout(bind(onFocus, this), 20) }
-	  else
-	    { onBlur(this) }
-
-	  for (var opt in optionHandlers) { if (optionHandlers.hasOwnProperty(opt))
-	    { optionHandlers[opt](this$1, options[opt], Init) } }
-	  maybeUpdateLineNumberWidth(this)
-	  if (options.finishInit) { options.finishInit(this) }
-	  for (var i = 0; i < initHooks.length; ++i) { initHooks[i](this$1) }
-	  endOperation(this)
-	  // Suppress optimizelegibility in Webkit, since it breaks text
-	  // measuring on line wrapping boundaries.
-	  if (webkit && options.lineWrapping &&
-	      getComputedStyle(display.lineDiv).textRendering == "optimizelegibility")
-	    { display.lineDiv.style.textRendering = "auto" }
-	}
-
-	// The default configuration options.
-	CodeMirror.defaults = defaults
-	// Functions to run when options are changed.
-	CodeMirror.optionHandlers = optionHandlers
-
-	// Attach the necessary event handlers when initializing the editor
-	function registerEventHandlers(cm) {
-	  var d = cm.display
-	  on(d.scroller, "mousedown", operation(cm, onMouseDown))
-	  // Older IE's will not fire a second mousedown for a double click
-	  if (ie && ie_version < 11)
-	    { on(d.scroller, "dblclick", operation(cm, function (e) {
-	      if (signalDOMEvent(cm, e)) { return }
-	      var pos = posFromMouse(cm, e)
-	      if (!pos || clickInGutter(cm, e) || eventInWidget(cm.display, e)) { return }
-	      e_preventDefault(e)
-	      var word = cm.findWordAt(pos)
-	      extendSelection(cm.doc, word.anchor, word.head)
-	    })) }
-	  else
-	    { on(d.scroller, "dblclick", function (e) { return signalDOMEvent(cm, e) || e_preventDefault(e); }) }
-	  // Some browsers fire contextmenu *after* opening the menu, at
-	  // which point we can't mess with it anymore. Context menu is
-	  // handled in onMouseDown for these browsers.
-	  if (!captureRightClick) { on(d.scroller, "contextmenu", function (e) { return onContextMenu(cm, e); }) }
-
-	  // Used to suppress mouse event handling when a touch happens
-	  var touchFinished, prevTouch = {end: 0}
-	  function finishTouch() {
-	    if (d.activeTouch) {
-	      touchFinished = setTimeout(function () { return d.activeTouch = null; }, 1000)
-	      prevTouch = d.activeTouch
-	      prevTouch.end = +new Date
-	    }
-	  }
-	  function isMouseLikeTouchEvent(e) {
-	    if (e.touches.length != 1) { return false }
-	    var touch = e.touches[0]
-	    return touch.radiusX <= 1 && touch.radiusY <= 1
-	  }
-	  function farAway(touch, other) {
-	    if (other.left == null) { return true }
-	    var dx = other.left - touch.left, dy = other.top - touch.top
-	    return dx * dx + dy * dy > 20 * 20
-	  }
-	  on(d.scroller, "touchstart", function (e) {
-	    if (!signalDOMEvent(cm, e) && !isMouseLikeTouchEvent(e)) {
-	      d.input.ensurePolled()
-	      clearTimeout(touchFinished)
-	      var now = +new Date
-	      d.activeTouch = {start: now, moved: false,
-	                       prev: now - prevTouch.end <= 300 ? prevTouch : null}
-	      if (e.touches.length == 1) {
-	        d.activeTouch.left = e.touches[0].pageX
-	        d.activeTouch.top = e.touches[0].pageY
-	      }
-	    }
-	  })
-	  on(d.scroller, "touchmove", function () {
-	    if (d.activeTouch) { d.activeTouch.moved = true }
-	  })
-	  on(d.scroller, "touchend", function (e) {
-	    var touch = d.activeTouch
-	    if (touch && !eventInWidget(d, e) && touch.left != null &&
-	        !touch.moved && new Date - touch.start < 300) {
-	      var pos = cm.coordsChar(d.activeTouch, "page"), range
-	      if (!touch.prev || farAway(touch, touch.prev)) // Single tap
-	        { range = new Range(pos, pos) }
-	      else if (!touch.prev.prev || farAway(touch, touch.prev.prev)) // Double tap
-	        { range = cm.findWordAt(pos) }
-	      else // Triple tap
-	        { range = new Range(Pos(pos.line, 0), clipPos(cm.doc, Pos(pos.line + 1, 0))) }
-	      cm.setSelection(range.anchor, range.head)
-	      cm.focus()
-	      e_preventDefault(e)
-	    }
-	    finishTouch()
-	  })
-	  on(d.scroller, "touchcancel", finishTouch)
-
-	  // Sync scrolling between fake scrollbars and real scrollable
-	  // area, ensure viewport is updated when scrolling.
-	  on(d.scroller, "scroll", function () {
-	    if (d.scroller.clientHeight) {
-	      setScrollTop(cm, d.scroller.scrollTop)
-	      setScrollLeft(cm, d.scroller.scrollLeft, true)
-	      signal(cm, "scroll", cm)
-	    }
-	  })
-
-	  // Listen to wheel events in order to try and update the viewport on time.
-	  on(d.scroller, "mousewheel", function (e) { return onScrollWheel(cm, e); })
-	  on(d.scroller, "DOMMouseScroll", function (e) { return onScrollWheel(cm, e); })
-
-	  // Prevent wrapper from ever scrolling
-	  on(d.wrapper, "scroll", function () { return d.wrapper.scrollTop = d.wrapper.scrollLeft = 0; })
-
-	  d.dragFunctions = {
-	    enter: function (e) {if (!signalDOMEvent(cm, e)) { e_stop(e) }},
-	    over: function (e) {if (!signalDOMEvent(cm, e)) { onDragOver(cm, e); e_stop(e) }},
-	    start: function (e) { return onDragStart(cm, e); },
-	    drop: operation(cm, onDrop),
-	    leave: function (e) {if (!signalDOMEvent(cm, e)) { clearDragCursor(cm) }}
-	  }
-
-	  var inp = d.input.getField()
-	  on(inp, "keyup", function (e) { return onKeyUp.call(cm, e); })
-	  on(inp, "keydown", operation(cm, onKeyDown))
-	  on(inp, "keypress", operation(cm, onKeyPress))
-	  on(inp, "focus", function (e) { return onFocus(cm, e); })
-	  on(inp, "blur", function (e) { return onBlur(cm, e); })
-	}
-
-	var initHooks = []
-	CodeMirror.defineInitHook = function (f) { return initHooks.push(f); }
-
-	// Indent the given line. The how parameter can be "smart",
-	// "add"/null, "subtract", or "prev". When aggressive is false
-	// (typically set to true for forced single-line indents), empty
-	// lines are not indented, and places where the mode returns Pass
-	// are left alone.
-	function indentLine(cm, n, how, aggressive) {
-	  var doc = cm.doc, state
-	  if (how == null) { how = "add" }
-	  if (how == "smart") {
-	    // Fall back to "prev" when the mode doesn't have an indentation
-	    // method.
-	    if (!doc.mode.indent) { how = "prev" }
-	    else { state = getStateBefore(cm, n) }
-	  }
-
-	  var tabSize = cm.options.tabSize
-	  var line = getLine(doc, n), curSpace = countColumn(line.text, null, tabSize)
-	  if (line.stateAfter) { line.stateAfter = null }
-	  var curSpaceString = line.text.match(/^\s*/)[0], indentation
-	  if (!aggressive && !/\S/.test(line.text)) {
-	    indentation = 0
-	    how = "not"
-	  } else if (how == "smart") {
-	    indentation = doc.mode.indent(state, line.text.slice(curSpaceString.length), line.text)
-	    if (indentation == Pass || indentation > 150) {
-	      if (!aggressive) { return }
-	      how = "prev"
-	    }
-	  }
-	  if (how == "prev") {
-	    if (n > doc.first) { indentation = countColumn(getLine(doc, n-1).text, null, tabSize) }
-	    else { indentation = 0 }
-	  } else if (how == "add") {
-	    indentation = curSpace + cm.options.indentUnit
-	  } else if (how == "subtract") {
-	    indentation = curSpace - cm.options.indentUnit
-	  } else if (typeof how == "number") {
-	    indentation = curSpace + how
-	  }
-	  indentation = Math.max(0, indentation)
-
-	  var indentString = "", pos = 0
-	  if (cm.options.indentWithTabs)
-	    { for (var i = Math.floor(indentation / tabSize); i; --i) {pos += tabSize; indentString += "\t"} }
-	  if (pos < indentation) { indentString += spaceStr(indentation - pos) }
-
-	  if (indentString != curSpaceString) {
-	    replaceRange(doc, indentString, Pos(n, 0), Pos(n, curSpaceString.length), "+input")
-	    line.stateAfter = null
-	    return true
-	  } else {
-	    // Ensure that, if the cursor was in the whitespace at the start
-	    // of the line, it is moved to the end of that space.
-	    for (var i$1 = 0; i$1 < doc.sel.ranges.length; i$1++) {
-	      var range = doc.sel.ranges[i$1]
-	      if (range.head.line == n && range.head.ch < curSpaceString.length) {
-	        var pos$1 = Pos(n, curSpaceString.length)
-	        replaceOneSelection(doc, i$1, new Range(pos$1, pos$1))
-	        break
-	      }
-	    }
-	  }
-	}
-
-	// This will be set to a {lineWise: bool, text: [string]} object, so
-	// that, when pasting, we know what kind of selections the copied
-	// text was made out of.
-	var lastCopied = null
-
-	function setLastCopied(newLastCopied) {
-	  lastCopied = newLastCopied
-	}
-
-	function applyTextInput(cm, inserted, deleted, sel, origin) {
-	  var doc = cm.doc
-	  cm.display.shift = false
-	  if (!sel) { sel = doc.sel }
-
-	  var paste = cm.state.pasteIncoming || origin == "paste"
-	  var textLines = splitLinesAuto(inserted), multiPaste = null
-	  // When pasing N lines into N selections, insert one line per selection
-	  if (paste && sel.ranges.length > 1) {
-	    if (lastCopied && lastCopied.text.join("\n") == inserted) {
-	      if (sel.ranges.length % lastCopied.text.length == 0) {
-	        multiPaste = []
-	        for (var i = 0; i < lastCopied.text.length; i++)
-	          { multiPaste.push(doc.splitLines(lastCopied.text[i])) }
-	      }
-	    } else if (textLines.length == sel.ranges.length) {
-	      multiPaste = map(textLines, function (l) { return [l]; })
-	    }
-	  }
-
-	  var updateInput
-	  // Normal behavior is to insert the new text into every selection
-	  for (var i$1 = sel.ranges.length - 1; i$1 >= 0; i$1--) {
-	    var range = sel.ranges[i$1]
-	    var from = range.from(), to = range.to()
-	    if (range.empty()) {
-	      if (deleted && deleted > 0) // Handle deletion
-	        { from = Pos(from.line, from.ch - deleted) }
-	      else if (cm.state.overwrite && !paste) // Handle overwrite
-	        { to = Pos(to.line, Math.min(getLine(doc, to.line).text.length, to.ch + lst(textLines).length)) }
-	      else if (lastCopied && lastCopied.lineWise && lastCopied.text.join("\n") == inserted)
-	        { from = to = Pos(from.line, 0) }
-	    }
-	    updateInput = cm.curOp.updateInput
-	    var changeEvent = {from: from, to: to, text: multiPaste ? multiPaste[i$1 % multiPaste.length] : textLines,
-	                       origin: origin || (paste ? "paste" : cm.state.cutIncoming ? "cut" : "+input")}
-	    makeChange(cm.doc, changeEvent)
-	    signalLater(cm, "inputRead", cm, changeEvent)
-	  }
-	  if (inserted && !paste)
-	    { triggerElectric(cm, inserted) }
-
-	  ensureCursorVisible(cm)
-	  cm.curOp.updateInput = updateInput
-	  cm.curOp.typing = true
-	  cm.state.pasteIncoming = cm.state.cutIncoming = false
-	}
-
-	function handlePaste(e, cm) {
-	  var pasted = e.clipboardData && e.clipboardData.getData("Text")
-	  if (pasted) {
-	    e.preventDefault()
-	    if (!cm.isReadOnly() && !cm.options.disableInput)
-	      { runInOp(cm, function () { return applyTextInput(cm, pasted, 0, null, "paste"); }) }
-	    return true
-	  }
-	}
-
-	function triggerElectric(cm, inserted) {
-	  // When an 'electric' character is inserted, immediately trigger a reindent
-	  if (!cm.options.electricChars || !cm.options.smartIndent) { return }
-	  var sel = cm.doc.sel
-
-	  for (var i = sel.ranges.length - 1; i >= 0; i--) {
-	    var range = sel.ranges[i]
-	    if (range.head.ch > 100 || (i && sel.ranges[i - 1].head.line == range.head.line)) { continue }
-	    var mode = cm.getModeAt(range.head)
-	    var indented = false
-	    if (mode.electricChars) {
-	      for (var j = 0; j < mode.electricChars.length; j++)
-	        { if (inserted.indexOf(mode.electricChars.charAt(j)) > -1) {
-	          indented = indentLine(cm, range.head.line, "smart")
-	          break
-	        } }
-	    } else if (mode.electricInput) {
-	      if (mode.electricInput.test(getLine(cm.doc, range.head.line).text.slice(0, range.head.ch)))
-	        { indented = indentLine(cm, range.head.line, "smart") }
-	    }
-	    if (indented) { signalLater(cm, "electricInput", cm, range.head.line) }
-	  }
-	}
-
-	function copyableRanges(cm) {
-	  var text = [], ranges = []
-	  for (var i = 0; i < cm.doc.sel.ranges.length; i++) {
-	    var line = cm.doc.sel.ranges[i].head.line
-	    var lineRange = {anchor: Pos(line, 0), head: Pos(line + 1, 0)}
-	    ranges.push(lineRange)
-	    text.push(cm.getRange(lineRange.anchor, lineRange.head))
-	  }
-	  return {text: text, ranges: ranges}
-	}
-
-	function disableBrowserMagic(field, spellcheck) {
-	  field.setAttribute("autocorrect", "off")
-	  field.setAttribute("autocapitalize", "off")
-	  field.setAttribute("spellcheck", !!spellcheck)
-	}
-
-	function hiddenTextarea() {
-	  var te = elt("textarea", null, null, "position: absolute; bottom: -1em; padding: 0; width: 1px; height: 1em; outline: none")
-	  var div = elt("div", [te], null, "overflow: hidden; position: relative; width: 3px; height: 0px;")
-	  // The textarea is kept positioned near the cursor to prevent the
-	  // fact that it'll be scrolled into view on input from scrolling
-	  // our fake cursor out of view. On webkit, when wrap=off, paste is
-	  // very slow. So make the area wide instead.
-	  if (webkit) { te.style.width = "1000px" }
-	  else { te.setAttribute("wrap", "off") }
-	  // If border: 0; -- iOS fails to open keyboard (issue #1287)
-	  if (ios) { te.style.border = "1px solid black" }
-	  disableBrowserMagic(te)
-	  return div
-	}
-
-	// The publicly visible API. Note that methodOp(f) means
-	// 'wrap f in an operation, performed on its `this` parameter'.
-
-	// This is not the complete set of editor methods. Most of the
-	// methods defined on the Doc type are also injected into
-	// CodeMirror.prototype, for backwards compatibility and
-	// convenience.
-
-	function addEditorMethods(CodeMirror) {
-	  var optionHandlers = CodeMirror.optionHandlers
-
-	  var helpers = CodeMirror.helpers = {}
-
-	  CodeMirror.prototype = {
-	    constructor: CodeMirror,
-	    focus: function(){window.focus(); this.display.input.focus()},
-
-	    setOption: function(option, value) {
-	      var options = this.options, old = options[option]
-	      if (options[option] == value && option != "mode") { return }
-	      options[option] = value
-	      if (optionHandlers.hasOwnProperty(option))
-	        { operation(this, optionHandlers[option])(this, value, old) }
-	    },
-
-	    getOption: function(option) {return this.options[option]},
-	    getDoc: function() {return this.doc},
-
-	    addKeyMap: function(map, bottom) {
-	      this.state.keyMaps[bottom ? "push" : "unshift"](getKeyMap(map))
-	    },
-	    removeKeyMap: function(map) {
-	      var maps = this.state.keyMaps
-	      for (var i = 0; i < maps.length; ++i)
-	        { if (maps[i] == map || maps[i].name == map) {
-	          maps.splice(i, 1)
-	          return true
-	        } }
-	    },
-
-	    addOverlay: methodOp(function(spec, options) {
-	      var mode = spec.token ? spec : CodeMirror.getMode(this.options, spec)
-	      if (mode.startState) { throw new Error("Overlays may not be stateful.") }
-	      insertSorted(this.state.overlays,
-	                   {mode: mode, modeSpec: spec, opaque: options && options.opaque,
-	                    priority: (options && options.priority) || 0},
-	                   function (overlay) { return overlay.priority; })
-	      this.state.modeGen++
-	      regChange(this)
-	    }),
-	    removeOverlay: methodOp(function(spec) {
-	      var this$1 = this;
-
-	      var overlays = this.state.overlays
-	      for (var i = 0; i < overlays.length; ++i) {
-	        var cur = overlays[i].modeSpec
-	        if (cur == spec || typeof spec == "string" && cur.name == spec) {
-	          overlays.splice(i, 1)
-	          this$1.state.modeGen++
-	          regChange(this$1)
-	          return
-	        }
-	      }
-	    }),
-
-	    indentLine: methodOp(function(n, dir, aggressive) {
-	      if (typeof dir != "string" && typeof dir != "number") {
-	        if (dir == null) { dir = this.options.smartIndent ? "smart" : "prev" }
-	        else { dir = dir ? "add" : "subtract" }
-	      }
-	      if (isLine(this.doc, n)) { indentLine(this, n, dir, aggressive) }
-	    }),
-	    indentSelection: methodOp(function(how) {
-	      var this$1 = this;
-
-	      var ranges = this.doc.sel.ranges, end = -1
-	      for (var i = 0; i < ranges.length; i++) {
-	        var range = ranges[i]
-	        if (!range.empty()) {
-	          var from = range.from(), to = range.to()
-	          var start = Math.max(end, from.line)
-	          end = Math.min(this$1.lastLine(), to.line - (to.ch ? 0 : 1)) + 1
-	          for (var j = start; j < end; ++j)
-	            { indentLine(this$1, j, how) }
-	          var newRanges = this$1.doc.sel.ranges
-	          if (from.ch == 0 && ranges.length == newRanges.length && newRanges[i].from().ch > 0)
-	            { replaceOneSelection(this$1.doc, i, new Range(from, newRanges[i].to()), sel_dontScroll) }
-	        } else if (range.head.line > end) {
-	          indentLine(this$1, range.head.line, how, true)
-	          end = range.head.line
-	          if (i == this$1.doc.sel.primIndex) { ensureCursorVisible(this$1) }
-	        }
-	      }
-	    }),
-
-	    // Fetch the parser token for a given character. Useful for hacks
-	    // that want to inspect the mode state (say, for completion).
-	    getTokenAt: function(pos, precise) {
-	      return takeToken(this, pos, precise)
-	    },
-
-	    getLineTokens: function(line, precise) {
-	      return takeToken(this, Pos(line), precise, true)
-	    },
-
-	    getTokenTypeAt: function(pos) {
-	      pos = clipPos(this.doc, pos)
-	      var styles = getLineStyles(this, getLine(this.doc, pos.line))
-	      var before = 0, after = (styles.length - 1) / 2, ch = pos.ch
-	      var type
-	      if (ch == 0) { type = styles[2] }
-	      else { for (;;) {
-	        var mid = (before + after) >> 1
-	        if ((mid ? styles[mid * 2 - 1] : 0) >= ch) { after = mid }
-	        else if (styles[mid * 2 + 1] < ch) { before = mid + 1 }
-	        else { type = styles[mid * 2 + 2]; break }
-	      } }
-	      var cut = type ? type.indexOf("overlay ") : -1
-	      return cut < 0 ? type : cut == 0 ? null : type.slice(0, cut - 1)
-	    },
-
-	    getModeAt: function(pos) {
-	      var mode = this.doc.mode
-	      if (!mode.innerMode) { return mode }
-	      return CodeMirror.innerMode(mode, this.getTokenAt(pos).state).mode
-	    },
-
-	    getHelper: function(pos, type) {
-	      return this.getHelpers(pos, type)[0]
-	    },
-
-	    getHelpers: function(pos, type) {
-	      var this$1 = this;
-
-	      var found = []
-	      if (!helpers.hasOwnProperty(type)) { return found }
-	      var help = helpers[type], mode = this.getModeAt(pos)
-	      if (typeof mode[type] == "string") {
-	        if (help[mode[type]]) { found.push(help[mode[type]]) }
-	      } else if (mode[type]) {
-	        for (var i = 0; i < mode[type].length; i++) {
-	          var val = help[mode[type][i]]
-	          if (val) { found.push(val) }
-	        }
-	      } else if (mode.helperType && help[mode.helperType]) {
-	        found.push(help[mode.helperType])
-	      } else if (help[mode.name]) {
-	        found.push(help[mode.name])
-	      }
-	      for (var i$1 = 0; i$1 < help._global.length; i$1++) {
-	        var cur = help._global[i$1]
-	        if (cur.pred(mode, this$1) && indexOf(found, cur.val) == -1)
-	          { found.push(cur.val) }
-	      }
-	      return found
-	    },
-
-	    getStateAfter: function(line, precise) {
-	      var doc = this.doc
-	      line = clipLine(doc, line == null ? doc.first + doc.size - 1: line)
-	      return getStateBefore(this, line + 1, precise)
-	    },
-
-	    cursorCoords: function(start, mode) {
-	      var pos, range = this.doc.sel.primary()
-	      if (start == null) { pos = range.head }
-	      else if (typeof start == "object") { pos = clipPos(this.doc, start) }
-	      else { pos = start ? range.from() : range.to() }
-	      return cursorCoords(this, pos, mode || "page")
-	    },
-
-	    charCoords: function(pos, mode) {
-	      return charCoords(this, clipPos(this.doc, pos), mode || "page")
-	    },
-
-	    coordsChar: function(coords, mode) {
-	      coords = fromCoordSystem(this, coords, mode || "page")
-	      return coordsChar(this, coords.left, coords.top)
-	    },
-
-	    lineAtHeight: function(height, mode) {
-	      height = fromCoordSystem(this, {top: height, left: 0}, mode || "page").top
-	      return lineAtHeight(this.doc, height + this.display.viewOffset)
-	    },
-	    heightAtLine: function(line, mode, includeWidgets) {
-	      var end = false, lineObj
-	      if (typeof line == "number") {
-	        var last = this.doc.first + this.doc.size - 1
-	        if (line < this.doc.first) { line = this.doc.first }
-	        else if (line > last) { line = last; end = true }
-	        lineObj = getLine(this.doc, line)
-	      } else {
-	        lineObj = line
-	      }
-	      return intoCoordSystem(this, lineObj, {top: 0, left: 0}, mode || "page", includeWidgets).top +
-	        (end ? this.doc.height - heightAtLine(lineObj) : 0)
-	    },
-
-	    defaultTextHeight: function() { return textHeight(this.display) },
-	    defaultCharWidth: function() { return charWidth(this.display) },
-
-	    getViewport: function() { return {from: this.display.viewFrom, to: this.display.viewTo}},
-
-	    addWidget: function(pos, node, scroll, vert, horiz) {
-	      var display = this.display
-	      pos = cursorCoords(this, clipPos(this.doc, pos))
-	      var top = pos.bottom, left = pos.left
-	      node.style.position = "absolute"
-	      node.setAttribute("cm-ignore-events", "true")
-	      this.display.input.setUneditable(node)
-	      display.sizer.appendChild(node)
-	      if (vert == "over") {
-	        top = pos.top
-	      } else if (vert == "above" || vert == "near") {
-	        var vspace = Math.max(display.wrapper.clientHeight, this.doc.height),
-	        hspace = Math.max(display.sizer.clientWidth, display.lineSpace.clientWidth)
-	        // Default to positioning above (if specified and possible); otherwise default to positioning below
-	        if ((vert == 'above' || pos.bottom + node.offsetHeight > vspace) && pos.top > node.offsetHeight)
-	          { top = pos.top - node.offsetHeight }
-	        else if (pos.bottom + node.offsetHeight <= vspace)
-	          { top = pos.bottom }
-	        if (left + node.offsetWidth > hspace)
-	          { left = hspace - node.offsetWidth }
-	      }
-	      node.style.top = top + "px"
-	      node.style.left = node.style.right = ""
-	      if (horiz == "right") {
-	        left = display.sizer.clientWidth - node.offsetWidth
-	        node.style.right = "0px"
-	      } else {
-	        if (horiz == "left") { left = 0 }
-	        else if (horiz == "middle") { left = (display.sizer.clientWidth - node.offsetWidth) / 2 }
-	        node.style.left = left + "px"
-	      }
-	      if (scroll)
-	        { scrollIntoView(this, left, top, left + node.offsetWidth, top + node.offsetHeight) }
-	    },
-
-	    triggerOnKeyDown: methodOp(onKeyDown),
-	    triggerOnKeyPress: methodOp(onKeyPress),
-	    triggerOnKeyUp: onKeyUp,
-
-	    execCommand: function(cmd) {
-	      if (commands.hasOwnProperty(cmd))
-	        { return commands[cmd].call(null, this) }
-	    },
-
-	    triggerElectric: methodOp(function(text) { triggerElectric(this, text) }),
-
-	    findPosH: function(from, amount, unit, visually) {
-	      var this$1 = this;
-
-	      var dir = 1
-	      if (amount < 0) { dir = -1; amount = -amount }
-	      var cur = clipPos(this.doc, from)
-	      for (var i = 0; i < amount; ++i) {
-	        cur = findPosH(this$1.doc, cur, dir, unit, visually)
-	        if (cur.hitSide) { break }
-	      }
-	      return cur
-	    },
-
-	    moveH: methodOp(function(dir, unit) {
-	      var this$1 = this;
-
-	      this.extendSelectionsBy(function (range) {
-	        if (this$1.display.shift || this$1.doc.extend || range.empty())
-	          { return findPosH(this$1.doc, range.head, dir, unit, this$1.options.rtlMoveVisually) }
-	        else
-	          { return dir < 0 ? range.from() : range.to() }
-	      }, sel_move)
-	    }),
-
-	    deleteH: methodOp(function(dir, unit) {
-	      var sel = this.doc.sel, doc = this.doc
-	      if (sel.somethingSelected())
-	        { doc.replaceSelection("", null, "+delete") }
-	      else
-	        { deleteNearSelection(this, function (range) {
-	          var other = findPosH(doc, range.head, dir, unit, false)
-	          return dir < 0 ? {from: other, to: range.head} : {from: range.head, to: other}
-	        }) }
-	    }),
-
-	    findPosV: function(from, amount, unit, goalColumn) {
-	      var this$1 = this;
-
-	      var dir = 1, x = goalColumn
-	      if (amount < 0) { dir = -1; amount = -amount }
-	      var cur = clipPos(this.doc, from)
-	      for (var i = 0; i < amount; ++i) {
-	        var coords = cursorCoords(this$1, cur, "div")
-	        if (x == null) { x = coords.left }
-	        else { coords.left = x }
-	        cur = findPosV(this$1, coords, dir, unit)
-	        if (cur.hitSide) { break }
-	      }
-	      return cur
-	    },
-
-	    moveV: methodOp(function(dir, unit) {
-	      var this$1 = this;
-
-	      var doc = this.doc, goals = []
-	      var collapse = !this.display.shift && !doc.extend && doc.sel.somethingSelected()
-	      doc.extendSelectionsBy(function (range) {
-	        if (collapse)
-	          { return dir < 0 ? range.from() : range.to() }
-	        var headPos = cursorCoords(this$1, range.head, "div")
-	        if (range.goalColumn != null) { headPos.left = range.goalColumn }
-	        goals.push(headPos.left)
-	        var pos = findPosV(this$1, headPos, dir, unit)
-	        if (unit == "page" && range == doc.sel.primary())
-	          { addToScrollPos(this$1, null, charCoords(this$1, pos, "div").top - headPos.top) }
-	        return pos
-	      }, sel_move)
-	      if (goals.length) { for (var i = 0; i < doc.sel.ranges.length; i++)
-	        { doc.sel.ranges[i].goalColumn = goals[i] } }
-	    }),
-
-	    // Find the word at the given position (as returned by coordsChar).
-	    findWordAt: function(pos) {
-	      var doc = this.doc, line = getLine(doc, pos.line).text
-	      var start = pos.ch, end = pos.ch
-	      if (line) {
-	        var helper = this.getHelper(pos, "wordChars")
-	        if ((pos.xRel < 0 || end == line.length) && start) { --start; } else { ++end }
-	        var startChar = line.charAt(start)
-	        var check = isWordChar(startChar, helper)
-	          ? function (ch) { return isWordChar(ch, helper); }
-	          : /\s/.test(startChar) ? function (ch) { return /\s/.test(ch); }
-	          : function (ch) { return (!/\s/.test(ch) && !isWordChar(ch)); }
-	        while (start > 0 && check(line.charAt(start - 1))) { --start }
-	        while (end < line.length && check(line.charAt(end))) { ++end }
-	      }
-	      return new Range(Pos(pos.line, start), Pos(pos.line, end))
-	    },
-
-	    toggleOverwrite: function(value) {
-	      if (value != null && value == this.state.overwrite) { return }
-	      if (this.state.overwrite = !this.state.overwrite)
-	        { addClass(this.display.cursorDiv, "CodeMirror-overwrite") }
-	      else
-	        { rmClass(this.display.cursorDiv, "CodeMirror-overwrite") }
-
-	      signal(this, "overwriteToggle", this, this.state.overwrite)
-	    },
-	    hasFocus: function() { return this.display.input.getField() == activeElt() },
-	    isReadOnly: function() { return !!(this.options.readOnly || this.doc.cantEdit) },
-
-	    scrollTo: methodOp(function(x, y) {
-	      if (x != null || y != null) { resolveScrollToPos(this) }
-	      if (x != null) { this.curOp.scrollLeft = x }
-	      if (y != null) { this.curOp.scrollTop = y }
-	    }),
-	    getScrollInfo: function() {
-	      var scroller = this.display.scroller
-	      return {left: scroller.scrollLeft, top: scroller.scrollTop,
-	              height: scroller.scrollHeight - scrollGap(this) - this.display.barHeight,
-	              width: scroller.scrollWidth - scrollGap(this) - this.display.barWidth,
-	              clientHeight: displayHeight(this), clientWidth: displayWidth(this)}
-	    },
-
-	    scrollIntoView: methodOp(function(range, margin) {
-	      if (range == null) {
-	        range = {from: this.doc.sel.primary().head, to: null}
-	        if (margin == null) { margin = this.options.cursorScrollMargin }
-	      } else if (typeof range == "number") {
-	        range = {from: Pos(range, 0), to: null}
-	      } else if (range.from == null) {
-	        range = {from: range, to: null}
-	      }
-	      if (!range.to) { range.to = range.from }
-	      range.margin = margin || 0
-
-	      if (range.from.line != null) {
-	        resolveScrollToPos(this)
-	        this.curOp.scrollToPos = range
-	      } else {
-	        var sPos = calculateScrollPos(this, Math.min(range.from.left, range.to.left),
-	                                      Math.min(range.from.top, range.to.top) - range.margin,
-	                                      Math.max(range.from.right, range.to.right),
-	                                      Math.max(range.from.bottom, range.to.bottom) + range.margin)
-	        this.scrollTo(sPos.scrollLeft, sPos.scrollTop)
-	      }
-	    }),
-
-	    setSize: methodOp(function(width, height) {
-	      var this$1 = this;
-
-	      var interpret = function (val) { return typeof val == "number" || /^\d+$/.test(String(val)) ? val + "px" : val; }
-	      if (width != null) { this.display.wrapper.style.width = interpret(width) }
-	      if (height != null) { this.display.wrapper.style.height = interpret(height) }
-	      if (this.options.lineWrapping) { clearLineMeasurementCache(this) }
-	      var lineNo = this.display.viewFrom
-	      this.doc.iter(lineNo, this.display.viewTo, function (line) {
-	        if (line.widgets) { for (var i = 0; i < line.widgets.length; i++)
-	          { if (line.widgets[i].noHScroll) { regLineChange(this$1, lineNo, "widget"); break } } }
-	        ++lineNo
-	      })
-	      this.curOp.forceUpdate = true
-	      signal(this, "refresh", this)
-	    }),
-
-	    operation: function(f){return runInOp(this, f)},
-
-	    refresh: methodOp(function() {
-	      var oldHeight = this.display.cachedTextHeight
-	      regChange(this)
-	      this.curOp.forceUpdate = true
-	      clearCaches(this)
-	      this.scrollTo(this.doc.scrollLeft, this.doc.scrollTop)
-	      updateGutterSpace(this)
-	      if (oldHeight == null || Math.abs(oldHeight - textHeight(this.display)) > .5)
-	        { estimateLineHeights(this) }
-	      signal(this, "refresh", this)
-	    }),
-
-	    swapDoc: methodOp(function(doc) {
-	      var old = this.doc
-	      old.cm = null
-	      attachDoc(this, doc)
-	      clearCaches(this)
-	      this.display.input.reset()
-	      this.scrollTo(doc.scrollLeft, doc.scrollTop)
-	      this.curOp.forceScroll = true
-	      signalLater(this, "swapDoc", this, old)
-	      return old
-	    }),
-
-	    getInputField: function(){return this.display.input.getField()},
-	    getWrapperElement: function(){return this.display.wrapper},
-	    getScrollerElement: function(){return this.display.scroller},
-	    getGutterElement: function(){return this.display.gutters}
-	  }
-	  eventMixin(CodeMirror)
-
-	  CodeMirror.registerHelper = function(type, name, value) {
-	    if (!helpers.hasOwnProperty(type)) { helpers[type] = CodeMirror[type] = {_global: []} }
-	    helpers[type][name] = value
-	  }
-	  CodeMirror.registerGlobalHelper = function(type, name, predicate, value) {
-	    CodeMirror.registerHelper(type, name, value)
-	    helpers[type]._global.push({pred: predicate, val: value})
-	  }
-	}
-
-	// Used for horizontal relative motion. Dir is -1 or 1 (left or
-	// right), unit can be "char", "column" (like char, but doesn't
-	// cross line boundaries), "word" (across next word), or "group" (to
-	// the start of next group of word or non-word-non-whitespace
-	// chars). The visually param controls whether, in right-to-left
-	// text, direction 1 means to move towards the next index in the
-	// string, or towards the character to the right of the current
-	// position. The resulting position will have a hitSide=true
-	// property if it reached the end of the document.
-	function findPosH(doc, pos, dir, unit, visually) {
-	  var line = pos.line, ch = pos.ch, origDir = dir
-	  var lineObj = getLine(doc, line)
-	  function findNextLine() {
-	    var l = line + dir
-	    if (l < doc.first || l >= doc.first + doc.size) { return false }
-	    line = l
-	    return lineObj = getLine(doc, l)
-	  }
-	  function moveOnce(boundToLine) {
-	    var next = (visually ? moveVisually : moveLogically)(lineObj, ch, dir, true)
-	    if (next == null) {
-	      if (!boundToLine && findNextLine()) {
-	        if (visually) { ch = (dir < 0 ? lineRight : lineLeft)(lineObj) }
-	        else { ch = dir < 0 ? lineObj.text.length : 0 }
-	      } else { return false }
-	    } else { ch = next }
-	    return true
-	  }
-
-	  if (unit == "char") {
-	    moveOnce()
-	  } else if (unit == "column") {
-	    moveOnce(true)
-	  } else if (unit == "word" || unit == "group") {
-	    var sawType = null, group = unit == "group"
-	    var helper = doc.cm && doc.cm.getHelper(pos, "wordChars")
-	    for (var first = true;; first = false) {
-	      if (dir < 0 && !moveOnce(!first)) { break }
-	      var cur = lineObj.text.charAt(ch) || "\n"
-	      var type = isWordChar(cur, helper) ? "w"
-	        : group && cur == "\n" ? "n"
-	        : !group || /\s/.test(cur) ? null
-	        : "p"
-	      if (group && !first && !type) { type = "s" }
-	      if (sawType && sawType != type) {
-	        if (dir < 0) {dir = 1; moveOnce()}
-	        break
-	      }
-
-	      if (type) { sawType = type }
-	      if (dir > 0 && !moveOnce(!first)) { break }
-	    }
-	  }
-	  var result = skipAtomic(doc, Pos(line, ch), pos, origDir, true)
-	  if (!cmp(pos, result)) { result.hitSide = true }
-	  return result
-	}
-
-	// For relative vertical movement. Dir may be -1 or 1. Unit can be
-	// "page" or "line". The resulting position will have a hitSide=true
-	// property if it reached the end of the document.
-	function findPosV(cm, pos, dir, unit) {
-	  var doc = cm.doc, x = pos.left, y
-	  if (unit == "page") {
-	    var pageSize = Math.min(cm.display.wrapper.clientHeight, window.innerHeight || document.documentElement.clientHeight)
-	    var moveAmount = Math.max(pageSize - .5 * textHeight(cm.display), 3)
-	    y = (dir > 0 ? pos.bottom : pos.top) + dir * moveAmount
-
-	  } else if (unit == "line") {
-	    y = dir > 0 ? pos.bottom + 3 : pos.top - 3
-	  }
-	  var target
-	  for (;;) {
-	    target = coordsChar(cm, x, y)
-	    if (!target.outside) { break }
-	    if (dir < 0 ? y <= 0 : y >= doc.height) { target.hitSide = true; break }
-	    y += dir * 5
-	  }
-	  return target
-	}
-
-	// CONTENTEDITABLE INPUT STYLE
-
-	function ContentEditableInput(cm) {
-	  this.cm = cm
-	  this.lastAnchorNode = this.lastAnchorOffset = this.lastFocusNode = this.lastFocusOffset = null
-	  this.polling = new Delayed()
-	  this.composing = null
-	  this.gracePeriod = false
-	  this.readDOMTimeout = null
-	}
-
-	ContentEditableInput.prototype = copyObj({
-	  init: function(display) {
-	    var this$1 = this;
-
-	    var input = this, cm = input.cm
-	    var div = input.div = display.lineDiv
-	    disableBrowserMagic(div, cm.options.spellcheck)
-
-	    on(div, "paste", function (e) {
-	      if (signalDOMEvent(cm, e) || handlePaste(e, cm)) { return }
-	      // IE doesn't fire input events, so we schedule a read for the pasted content in this way
-	      if (ie_version <= 11) { setTimeout(operation(cm, function () {
-	        if (!input.pollContent()) { regChange(cm) }
-	      }), 20) }
-	    })
-
-	    on(div, "compositionstart", function (e) {
-	      this$1.composing = {data: e.data}
-	    })
-	    on(div, "compositionupdate", function (e) {
-	      if (!this$1.composing) { this$1.composing = {data: e.data} }
-	    })
-	    on(div, "compositionend", function (e) {
-	      if (this$1.composing) {
-	        if (e.data != this$1.composing.data) { this$1.readFromDOMSoon() }
-	        this$1.composing = null
-	      }
-	    })
-
-	    on(div, "touchstart", function () { return input.forceCompositionEnd(); })
-
-	    on(div, "input", function () {
-	      if (!this$1.composing) { this$1.readFromDOMSoon() }
-	    })
-
-	    function onCopyCut(e) {
-	      if (signalDOMEvent(cm, e)) { return }
-	      if (cm.somethingSelected()) {
-	        setLastCopied({lineWise: false, text: cm.getSelections()})
-	        if (e.type == "cut") { cm.replaceSelection("", null, "cut") }
-	      } else if (!cm.options.lineWiseCopyCut) {
-	        return
-	      } else {
-	        var ranges = copyableRanges(cm)
-	        setLastCopied({lineWise: true, text: ranges.text})
-	        if (e.type == "cut") {
-	          cm.operation(function () {
-	            cm.setSelections(ranges.ranges, 0, sel_dontScroll)
-	            cm.replaceSelection("", null, "cut")
-	          })
-	        }
-	      }
-	      if (e.clipboardData) {
-	        e.clipboardData.clearData()
-	        var content = lastCopied.text.join("\n")
-	        // iOS exposes the clipboard API, but seems to discard content inserted into it
-	        e.clipboardData.setData("Text", content)
-	        if (e.clipboardData.getData("Text") == content) {
-	          e.preventDefault()
-	          return
-	        }
-	      }
-	      // Old-fashioned briefly-focus-a-textarea hack
-	      var kludge = hiddenTextarea(), te = kludge.firstChild
-	      cm.display.lineSpace.insertBefore(kludge, cm.display.lineSpace.firstChild)
-	      te.value = lastCopied.text.join("\n")
-	      var hadFocus = document.activeElement
-	      selectInput(te)
-	      setTimeout(function () {
-	        cm.display.lineSpace.removeChild(kludge)
-	        hadFocus.focus()
-	        if (hadFocus == div) { input.showPrimarySelection() }
-	      }, 50)
-	    }
-	    on(div, "copy", onCopyCut)
-	    on(div, "cut", onCopyCut)
-	  },
-
-	  prepareSelection: function() {
-	    var result = prepareSelection(this.cm, false)
-	    result.focus = this.cm.state.focused
-	    return result
-	  },
-
-	  showSelection: function(info, takeFocus) {
-	    if (!info || !this.cm.display.view.length) { return }
-	    if (info.focus || takeFocus) { this.showPrimarySelection() }
-	    this.showMultipleSelections(info)
-	  },
-
-	  showPrimarySelection: function() {
-	    var sel = window.getSelection(), prim = this.cm.doc.sel.primary()
-	    var curAnchor = domToPos(this.cm, sel.anchorNode, sel.anchorOffset)
-	    var curFocus = domToPos(this.cm, sel.focusNode, sel.focusOffset)
-	    if (curAnchor && !curAnchor.bad && curFocus && !curFocus.bad &&
-	        cmp(minPos(curAnchor, curFocus), prim.from()) == 0 &&
-	        cmp(maxPos(curAnchor, curFocus), prim.to()) == 0)
-	      { return }
-
-	    var start = posToDOM(this.cm, prim.from())
-	    var end = posToDOM(this.cm, prim.to())
-	    if (!start && !end) { return }
-
-	    var view = this.cm.display.view
-	    var old = sel.rangeCount && sel.getRangeAt(0)
-	    if (!start) {
-	      start = {node: view[0].measure.map[2], offset: 0}
-	    } else if (!end) { // FIXME dangerously hacky
-	      var measure = view[view.length - 1].measure
-	      var map = measure.maps ? measure.maps[measure.maps.length - 1] : measure.map
-	      end = {node: map[map.length - 1], offset: map[map.length - 2] - map[map.length - 3]}
-	    }
-
-	    var rng
-	    try { rng = range(start.node, start.offset, end.offset, end.node) }
-	    catch(e) {} // Our model of the DOM might be outdated, in which case the range we try to set can be impossible
-	    if (rng) {
-	      if (!gecko && this.cm.state.focused) {
-	        sel.collapse(start.node, start.offset)
-	        if (!rng.collapsed) {
-	          sel.removeAllRanges()
-	          sel.addRange(rng)
-	        }
-	      } else {
-	        sel.removeAllRanges()
-	        sel.addRange(rng)
-	      }
-	      if (old && sel.anchorNode == null) { sel.addRange(old) }
-	      else if (gecko) { this.startGracePeriod() }
-	    }
-	    this.rememberSelection()
-	  },
-
-	  startGracePeriod: function() {
-	    var this$1 = this;
-
-	    clearTimeout(this.gracePeriod)
-	    this.gracePeriod = setTimeout(function () {
-	      this$1.gracePeriod = false
-	      if (this$1.selectionChanged())
-	        { this$1.cm.operation(function () { return this$1.cm.curOp.selectionChanged = true; }) }
-	    }, 20)
-	  },
-
-	  showMultipleSelections: function(info) {
-	    removeChildrenAndAdd(this.cm.display.cursorDiv, info.cursors)
-	    removeChildrenAndAdd(this.cm.display.selectionDiv, info.selection)
-	  },
-
-	  rememberSelection: function() {
-	    var sel = window.getSelection()
-	    this.lastAnchorNode = sel.anchorNode; this.lastAnchorOffset = sel.anchorOffset
-	    this.lastFocusNode = sel.focusNode; this.lastFocusOffset = sel.focusOffset
-	  },
-
-	  selectionInEditor: function() {
-	    var sel = window.getSelection()
-	    if (!sel.rangeCount) { return false }
-	    var node = sel.getRangeAt(0).commonAncestorContainer
-	    return contains(this.div, node)
-	  },
-
-	  focus: function() {
-	    if (this.cm.options.readOnly != "nocursor") {
-	      if (!this.selectionInEditor())
-	        { this.showSelection(this.prepareSelection(), true) }
-	      this.div.focus()
-	    }
-	  },
-	  blur: function() { this.div.blur() },
-	  getField: function() { return this.div },
-
-	  supportsTouch: function() { return true },
-
-	  receivedFocus: function() {
-	    var input = this
-	    if (this.selectionInEditor())
-	      { this.pollSelection() }
-	    else
-	      { runInOp(this.cm, function () { return input.cm.curOp.selectionChanged = true; }) }
-
-	    function poll() {
-	      if (input.cm.state.focused) {
-	        input.pollSelection()
-	        input.polling.set(input.cm.options.pollInterval, poll)
-	      }
-	    }
-	    this.polling.set(this.cm.options.pollInterval, poll)
-	  },
-
-	  selectionChanged: function() {
-	    var sel = window.getSelection()
-	    return sel.anchorNode != this.lastAnchorNode || sel.anchorOffset != this.lastAnchorOffset ||
-	      sel.focusNode != this.lastFocusNode || sel.focusOffset != this.lastFocusOffset
-	  },
-
-	  pollSelection: function() {
-	    if (!this.composing && this.readDOMTimeout == null && !this.gracePeriod && this.selectionChanged()) {
-	      var sel = window.getSelection(), cm = this.cm
-	      this.rememberSelection()
-	      var anchor = domToPos(cm, sel.anchorNode, sel.anchorOffset)
-	      var head = domToPos(cm, sel.focusNode, sel.focusOffset)
-	      if (anchor && head) { runInOp(cm, function () {
-	        setSelection(cm.doc, simpleSelection(anchor, head), sel_dontScroll)
-	        if (anchor.bad || head.bad) { cm.curOp.selectionChanged = true }
-	      }) }
-	    }
-	  },
-
-	  pollContent: function() {
-	    if (this.readDOMTimeout != null) {
-	      clearTimeout(this.readDOMTimeout)
-	      this.readDOMTimeout = null
-	    }
-
-	    var cm = this.cm, display = cm.display, sel = cm.doc.sel.primary()
-	    var from = sel.from(), to = sel.to()
-	    if (from.ch == 0 && from.line > cm.firstLine())
-	      { from = Pos(from.line - 1, getLine(cm.doc, from.line - 1).length) }
-	    if (to.ch == getLine(cm.doc, to.line).text.length && to.line < cm.lastLine())
-	      { to = Pos(to.line + 1, 0) }
-	    if (from.line < display.viewFrom || to.line > display.viewTo - 1) { return false }
-
-	    var fromIndex, fromLine, fromNode
-	    if (from.line == display.viewFrom || (fromIndex = findViewIndex(cm, from.line)) == 0) {
-	      fromLine = lineNo(display.view[0].line)
-	      fromNode = display.view[0].node
-	    } else {
-	      fromLine = lineNo(display.view[fromIndex].line)
-	      fromNode = display.view[fromIndex - 1].node.nextSibling
-	    }
-	    var toIndex = findViewIndex(cm, to.line)
-	    var toLine, toNode
-	    if (toIndex == display.view.length - 1) {
-	      toLine = display.viewTo - 1
-	      toNode = display.lineDiv.lastChild
-	    } else {
-	      toLine = lineNo(display.view[toIndex + 1].line) - 1
-	      toNode = display.view[toIndex + 1].node.previousSibling
-	    }
-
-	    if (!fromNode) { return false }
-	    var newText = cm.doc.splitLines(domTextBetween(cm, fromNode, toNode, fromLine, toLine))
-	    var oldText = getBetween(cm.doc, Pos(fromLine, 0), Pos(toLine, getLine(cm.doc, toLine).text.length))
-	    while (newText.length > 1 && oldText.length > 1) {
-	      if (lst(newText) == lst(oldText)) { newText.pop(); oldText.pop(); toLine-- }
-	      else if (newText[0] == oldText[0]) { newText.shift(); oldText.shift(); fromLine++ }
-	      else { break }
-	    }
-
-	    var cutFront = 0, cutEnd = 0
-	    var newTop = newText[0], oldTop = oldText[0], maxCutFront = Math.min(newTop.length, oldTop.length)
-	    while (cutFront < maxCutFront && newTop.charCodeAt(cutFront) == oldTop.charCodeAt(cutFront))
-	      { ++cutFront }
-	    var newBot = lst(newText), oldBot = lst(oldText)
-	    var maxCutEnd = Math.min(newBot.length - (newText.length == 1 ? cutFront : 0),
-	                             oldBot.length - (oldText.length == 1 ? cutFront : 0))
-	    while (cutEnd < maxCutEnd &&
-	           newBot.charCodeAt(newBot.length - cutEnd - 1) == oldBot.charCodeAt(oldBot.length - cutEnd - 1))
-	      { ++cutEnd }
-
-	    newText[newText.length - 1] = newBot.slice(0, newBot.length - cutEnd).replace(/^\u200b+/, "")
-	    newText[0] = newText[0].slice(cutFront).replace(/\u200b+$/, "")
-
-	    var chFrom = Pos(fromLine, cutFront)
-	    var chTo = Pos(toLine, oldText.length ? lst(oldText).length - cutEnd : 0)
-	    if (newText.length > 1 || newText[0] || cmp(chFrom, chTo)) {
-	      replaceRange(cm.doc, newText, chFrom, chTo, "+input")
-	      return true
-	    }
-	  },
-
-	  ensurePolled: function() {
-	    this.forceCompositionEnd()
-	  },
-	  reset: function() {
-	    this.forceCompositionEnd()
-	  },
-	  forceCompositionEnd: function() {
-	    if (!this.composing) { return }
-	    this.composing = null
-	    if (!this.pollContent()) { regChange(this.cm) }
-	    this.div.blur()
-	    this.div.focus()
-	  },
-	  readFromDOMSoon: function() {
-	    var this$1 = this;
-
-	    if (this.readDOMTimeout != null) { return }
-	    this.readDOMTimeout = setTimeout(function () {
-	      this$1.readDOMTimeout = null
-	      if (this$1.composing) { return }
-	      if (this$1.cm.isReadOnly() || !this$1.pollContent())
-	        { runInOp(this$1.cm, function () { return regChange(this$1.cm); }) }
-	    }, 80)
-	  },
-
-	  setUneditable: function(node) {
-	    node.contentEditable = "false"
-	  },
-
-	  onKeyPress: function(e) {
-	    e.preventDefault()
-	    if (!this.cm.isReadOnly())
-	      { operation(this.cm, applyTextInput)(this.cm, String.fromCharCode(e.charCode == null ? e.keyCode : e.charCode), 0) }
-	  },
-
-	  readOnlyChanged: function(val) {
-	    this.div.contentEditable = String(val != "nocursor")
-	  },
-
-	  onContextMenu: nothing,
-	  resetPosition: nothing,
-
-	  needsContentAttribute: true
-	  }, ContentEditableInput.prototype)
-
-	function posToDOM(cm, pos) {
-	  var view = findViewForLine(cm, pos.line)
-	  if (!view || view.hidden) { return null }
-	  var line = getLine(cm.doc, pos.line)
-	  var info = mapFromLineView(view, line, pos.line)
-
-	  var order = getOrder(line), side = "left"
-	  if (order) {
-	    var partPos = getBidiPartAt(order, pos.ch)
-	    side = partPos % 2 ? "right" : "left"
-	  }
-	  var result = nodeAndOffsetInLineMap(info.map, pos.ch, side)
-	  result.offset = result.collapse == "right" ? result.end : result.start
-	  return result
-	}
-
-	function badPos(pos, bad) { if (bad) { pos.bad = true; } return pos }
-
-	function domTextBetween(cm, from, to, fromLine, toLine) {
-	  var text = "", closing = false, lineSep = cm.doc.lineSeparator()
-	  function recognizeMarker(id) { return function (marker) { return marker.id == id; } }
-	  function walk(node) {
-	    if (node.nodeType == 1) {
-	      var cmText = node.getAttribute("cm-text")
-	      if (cmText != null) {
-	        if (cmText == "") { text += node.textContent.replace(/\u200b/g, "") }
-	        else { text += cmText }
-	        return
-	      }
-	      var markerID = node.getAttribute("cm-marker"), range
-	      if (markerID) {
-	        var found = cm.findMarks(Pos(fromLine, 0), Pos(toLine + 1, 0), recognizeMarker(+markerID))
-	        if (found.length && (range = found[0].find()))
-	          { text += getBetween(cm.doc, range.from, range.to).join(lineSep) }
-	        return
-	      }
-	      if (node.getAttribute("contenteditable") == "false") { return }
-	      for (var i = 0; i < node.childNodes.length; i++)
-	        { walk(node.childNodes[i]) }
-	      if (/^(pre|div|p)$/i.test(node.nodeName))
-	        { closing = true }
-	    } else if (node.nodeType == 3) {
-	      var val = node.nodeValue
-	      if (!val) { return }
-	      if (closing) {
-	        text += lineSep
-	        closing = false
-	      }
-	      text += val
-	    }
-	  }
-	  for (;;) {
-	    walk(from)
-	    if (from == to) { break }
-	    from = from.nextSibling
-	  }
-	  return text
-	}
-
-	function domToPos(cm, node, offset) {
-	  var lineNode
-	  if (node == cm.display.lineDiv) {
-	    lineNode = cm.display.lineDiv.childNodes[offset]
-	    if (!lineNode) { return badPos(cm.clipPos(Pos(cm.display.viewTo - 1)), true) }
-	    node = null; offset = 0
-	  } else {
-	    for (lineNode = node;; lineNode = lineNode.parentNode) {
-	      if (!lineNode || lineNode == cm.display.lineDiv) { return null }
-	      if (lineNode.parentNode && lineNode.parentNode == cm.display.lineDiv) { break }
-	    }
-	  }
-	  for (var i = 0; i < cm.display.view.length; i++) {
-	    var lineView = cm.display.view[i]
-	    if (lineView.node == lineNode)
-	      { return locateNodeInLineView(lineView, node, offset) }
-	  }
-	}
-
-	function locateNodeInLineView(lineView, node, offset) {
-	  var wrapper = lineView.text.firstChild, bad = false
-	  if (!node || !contains(wrapper, node)) { return badPos(Pos(lineNo(lineView.line), 0), true) }
-	  if (node == wrapper) {
-	    bad = true
-	    node = wrapper.childNodes[offset]
-	    offset = 0
-	    if (!node) {
-	      var line = lineView.rest ? lst(lineView.rest) : lineView.line
-	      return badPos(Pos(lineNo(line), line.text.length), bad)
-	    }
-	  }
-
-	  var textNode = node.nodeType == 3 ? node : null, topNode = node
-	  if (!textNode && node.childNodes.length == 1 && node.firstChild.nodeType == 3) {
-	    textNode = node.firstChild
-	    if (offset) { offset = textNode.nodeValue.length }
-	  }
-	  while (topNode.parentNode != wrapper) { topNode = topNode.parentNode }
-	  var measure = lineView.measure, maps = measure.maps
-
-	  function find(textNode, topNode, offset) {
-	    for (var i = -1; i < (maps ? maps.length : 0); i++) {
-	      var map = i < 0 ? measure.map : maps[i]
-	      for (var j = 0; j < map.length; j += 3) {
-	        var curNode = map[j + 2]
-	        if (curNode == textNode || curNode == topNode) {
-	          var line = lineNo(i < 0 ? lineView.line : lineView.rest[i])
-	          var ch = map[j] + offset
-	          if (offset < 0 || curNode != textNode) { ch = map[j + (offset ? 1 : 0)] }
-	          return Pos(line, ch)
-	        }
-	      }
-	    }
-	  }
-	  var found = find(textNode, topNode, offset)
-	  if (found) { return badPos(found, bad) }
-
-	  // FIXME this is all really shaky. might handle the few cases it needs to handle, but likely to cause problems
-	  for (var after = topNode.nextSibling, dist = textNode ? textNode.nodeValue.length - offset : 0; after; after = after.nextSibling) {
-	    found = find(after, after.firstChild, 0)
-	    if (found)
-	      { return badPos(Pos(found.line, found.ch - dist), bad) }
-	    else
-	      { dist += after.textContent.length }
-	  }
-	  for (var before = topNode.previousSibling, dist$1 = offset; before; before = before.previousSibling) {
-	    found = find(before, before.firstChild, -1)
-	    if (found)
-	      { return badPos(Pos(found.line, found.ch + dist$1), bad) }
-	    else
-	      { dist$1 += before.textContent.length }
-	  }
-	}
-
-	// TEXTAREA INPUT STYLE
-
-	function TextareaInput(cm) {
-	  this.cm = cm
-	  // See input.poll and input.reset
-	  this.prevInput = ""
-
-	  // Flag that indicates whether we expect input to appear real soon
-	  // now (after some event like 'keypress' or 'input') and are
-	  // polling intensively.
-	  this.pollingFast = false
-	  // Self-resetting timeout for the poller
-	  this.polling = new Delayed()
-	  // Tracks when input.reset has punted to just putting a short
-	  // string into the textarea instead of the full selection.
-	  this.inaccurateSelection = false
-	  // Used to work around IE issue with selection being forgotten when focus moves away from textarea
-	  this.hasSelection = false
-	  this.composing = null
-	}
-
-	TextareaInput.prototype = copyObj({
-	  init: function(display) {
-	    var this$1 = this;
-
-	    var input = this, cm = this.cm
-
-	    // Wraps and hides input textarea
-	    var div = this.wrapper = hiddenTextarea()
-	    // The semihidden textarea that is focused when the editor is
-	    // focused, and receives input.
-	    var te = this.textarea = div.firstChild
-	    display.wrapper.insertBefore(div, display.wrapper.firstChild)
-
-	    // Needed to hide big blue blinking cursor on Mobile Safari (doesn't seem to work in iOS 8 anymore)
-	    if (ios) { te.style.width = "0px" }
-
-	    on(te, "input", function () {
-	      if (ie && ie_version >= 9 && this$1.hasSelection) { this$1.hasSelection = null }
-	      input.poll()
-	    })
-
-	    on(te, "paste", function (e) {
-	      if (signalDOMEvent(cm, e) || handlePaste(e, cm)) { return }
-
-	      cm.state.pasteIncoming = true
-	      input.fastPoll()
-	    })
-
-	    function prepareCopyCut(e) {
-	      if (signalDOMEvent(cm, e)) { return }
-	      if (cm.somethingSelected()) {
-	        setLastCopied({lineWise: false, text: cm.getSelections()})
-	        if (input.inaccurateSelection) {
-	          input.prevInput = ""
-	          input.inaccurateSelection = false
-	          te.value = lastCopied.text.join("\n")
-	          selectInput(te)
-	        }
-	      } else if (!cm.options.lineWiseCopyCut) {
-	        return
-	      } else {
-	        var ranges = copyableRanges(cm)
-	        setLastCopied({lineWise: true, text: ranges.text})
-	        if (e.type == "cut") {
-	          cm.setSelections(ranges.ranges, null, sel_dontScroll)
-	        } else {
-	          input.prevInput = ""
-	          te.value = ranges.text.join("\n")
-	          selectInput(te)
-	        }
-	      }
-	      if (e.type == "cut") { cm.state.cutIncoming = true }
-	    }
-	    on(te, "cut", prepareCopyCut)
-	    on(te, "copy", prepareCopyCut)
-
-	    on(display.scroller, "paste", function (e) {
-	      if (eventInWidget(display, e) || signalDOMEvent(cm, e)) { return }
-	      cm.state.pasteIncoming = true
-	      input.focus()
-	    })
-
-	    // Prevent normal selection in the editor (we handle our own)
-	    on(display.lineSpace, "selectstart", function (e) {
-	      if (!eventInWidget(display, e)) { e_preventDefault(e) }
-	    })
-
-	    on(te, "compositionstart", function () {
-	      var start = cm.getCursor("from")
-	      if (input.composing) { input.composing.range.clear() }
-	      input.composing = {
-	        start: start,
-	        range: cm.markText(start, cm.getCursor("to"), {className: "CodeMirror-composing"})
-	      }
-	    })
-	    on(te, "compositionend", function () {
-	      if (input.composing) {
-	        input.poll()
-	        input.composing.range.clear()
-	        input.composing = null
-	      }
-	    })
-	  },
-
-	  prepareSelection: function() {
-	    // Redraw the selection and/or cursor
-	    var cm = this.cm, display = cm.display, doc = cm.doc
-	    var result = prepareSelection(cm)
-
-	    // Move the hidden textarea near the cursor to prevent scrolling artifacts
-	    if (cm.options.moveInputWithCursor) {
-	      var headPos = cursorCoords(cm, doc.sel.primary().head, "div")
-	      var wrapOff = display.wrapper.getBoundingClientRect(), lineOff = display.lineDiv.getBoundingClientRect()
-	      result.teTop = Math.max(0, Math.min(display.wrapper.clientHeight - 10,
-	                                          headPos.top + lineOff.top - wrapOff.top))
-	      result.teLeft = Math.max(0, Math.min(display.wrapper.clientWidth - 10,
-	                                           headPos.left + lineOff.left - wrapOff.left))
-	    }
-
-	    return result
-	  },
-
-	  showSelection: function(drawn) {
-	    var cm = this.cm, display = cm.display
-	    removeChildrenAndAdd(display.cursorDiv, drawn.cursors)
-	    removeChildrenAndAdd(display.selectionDiv, drawn.selection)
-	    if (drawn.teTop != null) {
-	      this.wrapper.style.top = drawn.teTop + "px"
-	      this.wrapper.style.left = drawn.teLeft + "px"
-	    }
-	  },
-
-	  // Reset the input to correspond to the selection (or to be empty,
-	  // when not typing and nothing is selected)
-	  reset: function(typing) {
-	    if (this.contextMenuPending) { return }
-	    var minimal, selected, cm = this.cm, doc = cm.doc
-	    if (cm.somethingSelected()) {
-	      this.prevInput = ""
-	      var range = doc.sel.primary()
-	      minimal = hasCopyEvent &&
-	        (range.to().line - range.from().line > 100 || (selected = cm.getSelection()).length > 1000)
-	      var content = minimal ? "-" : selected || cm.getSelection()
-	      this.textarea.value = content
-	      if (cm.state.focused) { selectInput(this.textarea) }
-	      if (ie && ie_version >= 9) { this.hasSelection = content }
-	    } else if (!typing) {
-	      this.prevInput = this.textarea.value = ""
-	      if (ie && ie_version >= 9) { this.hasSelection = null }
-	    }
-	    this.inaccurateSelection = minimal
-	  },
-
-	  getField: function() { return this.textarea },
-
-	  supportsTouch: function() { return false },
-
-	  focus: function() {
-	    if (this.cm.options.readOnly != "nocursor" && (!mobile || activeElt() != this.textarea)) {
-	      try { this.textarea.focus() }
-	      catch (e) {} // IE8 will throw if the textarea is display: none or not in DOM
-	    }
-	  },
-
-	  blur: function() { this.textarea.blur() },
-
-	  resetPosition: function() {
-	    this.wrapper.style.top = this.wrapper.style.left = 0
-	  },
-
-	  receivedFocus: function() { this.slowPoll() },
-
-	  // Poll for input changes, using the normal rate of polling. This
-	  // runs as long as the editor is focused.
-	  slowPoll: function() {
-	    var this$1 = this;
-
-	    if (this.pollingFast) { return }
-	    this.polling.set(this.cm.options.pollInterval, function () {
-	      this$1.poll()
-	      if (this$1.cm.state.focused) { this$1.slowPoll() }
-	    })
-	  },
-
-	  // When an event has just come in that is likely to add or change
-	  // something in the input textarea, we poll faster, to ensure that
-	  // the change appears on the screen quickly.
-	  fastPoll: function() {
-	    var missed = false, input = this
-	    input.pollingFast = true
-	    function p() {
-	      var changed = input.poll()
-	      if (!changed && !missed) {missed = true; input.polling.set(60, p)}
-	      else {input.pollingFast = false; input.slowPoll()}
-	    }
-	    input.polling.set(20, p)
-	  },
-
-	  // Read input from the textarea, and update the document to match.
-	  // When something is selected, it is present in the textarea, and
-	  // selected (unless it is huge, in which case a placeholder is
-	  // used). When nothing is selected, the cursor sits after previously
-	  // seen text (can be empty), which is stored in prevInput (we must
-	  // not reset the textarea when typing, because that breaks IME).
-	  poll: function() {
-	    var this$1 = this;
-
-	    var cm = this.cm, input = this.textarea, prevInput = this.prevInput
-	    // Since this is called a *lot*, try to bail out as cheaply as
-	    // possible when it is clear that nothing happened. hasSelection
-	    // will be the case when there is a lot of text in the textarea,
-	    // in which case reading its value would be expensive.
-	    if (this.contextMenuPending || !cm.state.focused ||
-	        (hasSelection(input) && !prevInput && !this.composing) ||
-	        cm.isReadOnly() || cm.options.disableInput || cm.state.keySeq)
-	      { return false }
-
-	    var text = input.value
-	    // If nothing changed, bail.
-	    if (text == prevInput && !cm.somethingSelected()) { return false }
-	    // Work around nonsensical selection resetting in IE9/10, and
-	    // inexplicable appearance of private area unicode characters on
-	    // some key combos in Mac (#2689).
-	    if (ie && ie_version >= 9 && this.hasSelection === text ||
-	        mac && /[\uf700-\uf7ff]/.test(text)) {
-	      cm.display.input.reset()
-	      return false
-	    }
-
-	    if (cm.doc.sel == cm.display.selForContextMenu) {
-	      var first = text.charCodeAt(0)
-	      if (first == 0x200b && !prevInput) { prevInput = "\u200b" }
-	      if (first == 0x21da) { this.reset(); return this.cm.execCommand("undo") }
-	    }
-	    // Find the part of the input that is actually new
-	    var same = 0, l = Math.min(prevInput.length, text.length)
-	    while (same < l && prevInput.charCodeAt(same) == text.charCodeAt(same)) { ++same }
-
-	    runInOp(cm, function () {
-	      applyTextInput(cm, text.slice(same), prevInput.length - same,
-	                     null, this$1.composing ? "*compose" : null)
-
-	      // Don't leave long text in the textarea, since it makes further polling slow
-	      if (text.length > 1000 || text.indexOf("\n") > -1) { input.value = this$1.prevInput = "" }
-	      else { this$1.prevInput = text }
-
-	      if (this$1.composing) {
-	        this$1.composing.range.clear()
-	        this$1.composing.range = cm.markText(this$1.composing.start, cm.getCursor("to"),
-	                                           {className: "CodeMirror-composing"})
-	      }
-	    })
-	    return true
-	  },
-
-	  ensurePolled: function() {
-	    if (this.pollingFast && this.poll()) { this.pollingFast = false }
-	  },
-
-	  onKeyPress: function() {
-	    if (ie && ie_version >= 9) { this.hasSelection = null }
-	    this.fastPoll()
-	  },
-
-	  onContextMenu: function(e) {
-	    var input = this, cm = input.cm, display = cm.display, te = input.textarea
-	    var pos = posFromMouse(cm, e), scrollPos = display.scroller.scrollTop
-	    if (!pos || presto) { return } // Opera is difficult.
-
-	    // Reset the current text selection only if the click is done outside of the selection
-	    // and 'resetSelectionOnContextMenu' option is true.
-	    var reset = cm.options.resetSelectionOnContextMenu
-	    if (reset && cm.doc.sel.contains(pos) == -1)
-	      { operation(cm, setSelection)(cm.doc, simpleSelection(pos), sel_dontScroll) }
-
-	    var oldCSS = te.style.cssText, oldWrapperCSS = input.wrapper.style.cssText
-	    input.wrapper.style.cssText = "position: absolute"
-	    var wrapperBox = input.wrapper.getBoundingClientRect()
-	    te.style.cssText = "position: absolute; width: 30px; height: 30px;\n      top: " + (e.clientY - wrapperBox.top - 5) + "px; left: " + (e.clientX - wrapperBox.left - 5) + "px;\n      z-index: 1000; background: " + (ie ? "rgba(255, 255, 255, .05)" : "transparent") + ";\n      outline: none; border-width: 0; outline: none; overflow: hidden; opacity: .05; filter: alpha(opacity=5);"
-	    var oldScrollY
-	    if (webkit) { oldScrollY = window.scrollY } // Work around Chrome issue (#2712)
-	    display.input.focus()
-	    if (webkit) { window.scrollTo(null, oldScrollY) }
-	    display.input.reset()
-	    // Adds "Select all" to context menu in FF
-	    if (!cm.somethingSelected()) { te.value = input.prevInput = " " }
-	    input.contextMenuPending = true
-	    display.selForContextMenu = cm.doc.sel
-	    clearTimeout(display.detectingSelectAll)
-
-	    // Select-all will be greyed out if there's nothing to select, so
-	    // this adds a zero-width space so that we can later check whether
-	    // it got selected.
-	    function prepareSelectAllHack() {
-	      if (te.selectionStart != null) {
-	        var selected = cm.somethingSelected()
-	        var extval = "\u200b" + (selected ? te.value : "")
-	        te.value = "\u21da" // Used to catch context-menu undo
-	        te.value = extval
-	        input.prevInput = selected ? "" : "\u200b"
-	        te.selectionStart = 1; te.selectionEnd = extval.length
-	        // Re-set this, in case some other handler touched the
-	        // selection in the meantime.
-	        display.selForContextMenu = cm.doc.sel
-	      }
-	    }
-	    function rehide() {
-	      input.contextMenuPending = false
-	      input.wrapper.style.cssText = oldWrapperCSS
-	      te.style.cssText = oldCSS
-	      if (ie && ie_version < 9) { display.scrollbars.setScrollTop(display.scroller.scrollTop = scrollPos) }
-
-	      // Try to detect the user choosing select-all
-	      if (te.selectionStart != null) {
-	        if (!ie || (ie && ie_version < 9)) { prepareSelectAllHack() }
-	        var i = 0, poll = function () {
-	          if (display.selForContextMenu == cm.doc.sel && te.selectionStart == 0 &&
-	              te.selectionEnd > 0 && input.prevInput == "\u200b")
-	            { operation(cm, selectAll)(cm) }
-	          else if (i++ < 10) { display.detectingSelectAll = setTimeout(poll, 500) }
-	          else { display.input.reset() }
-	        }
-	        display.detectingSelectAll = setTimeout(poll, 200)
-	      }
-	    }
-
-	    if (ie && ie_version >= 9) { prepareSelectAllHack() }
-	    if (captureRightClick) {
-	      e_stop(e)
-	      var mouseup = function () {
-	        off(window, "mouseup", mouseup)
-	        setTimeout(rehide, 20)
-	      }
-	      on(window, "mouseup", mouseup)
-	    } else {
-	      setTimeout(rehide, 50)
-	    }
-	  },
-
-	  readOnlyChanged: function(val) {
-	    if (!val) { this.reset() }
-	  },
-
-	  setUneditable: nothing,
-
-	  needsContentAttribute: false
-	}, TextareaInput.prototype)
-
-	function fromTextArea(textarea, options) {
-	  options = options ? copyObj(options) : {}
-	  options.value = textarea.value
-	  if (!options.tabindex && textarea.tabIndex)
-	    { options.tabindex = textarea.tabIndex }
-	  if (!options.placeholder && textarea.placeholder)
-	    { options.placeholder = textarea.placeholder }
-	  // Set autofocus to true if this textarea is focused, or if it has
-	  // autofocus and no other element is focused.
-	  if (options.autofocus == null) {
-	    var hasFocus = activeElt()
-	    options.autofocus = hasFocus == textarea ||
-	      textarea.getAttribute("autofocus") != null && hasFocus == document.body
-	  }
-
-	  function save() {textarea.value = cm.getValue()}
-
-	  var realSubmit
-	  if (textarea.form) {
-	    on(textarea.form, "submit", save)
-	    // Deplorable hack to make the submit method do the right thing.
-	    if (!options.leaveSubmitMethodAlone) {
-	      var form = textarea.form
-	      realSubmit = form.submit
-	      try {
-	        var wrappedSubmit = form.submit = function () {
-	          save()
-	          form.submit = realSubmit
-	          form.submit()
-	          form.submit = wrappedSubmit
-	        }
-	      } catch(e) {}
-	    }
-	  }
-
-	  options.finishInit = function (cm) {
-	    cm.save = save
-	    cm.getTextArea = function () { return textarea; }
-	    cm.toTextArea = function () {
-	      cm.toTextArea = isNaN // Prevent this from being ran twice
-	      save()
-	      textarea.parentNode.removeChild(cm.getWrapperElement())
-	      textarea.style.display = ""
-	      if (textarea.form) {
-	        off(textarea.form, "submit", save)
-	        if (typeof textarea.form.submit == "function")
-	          { textarea.form.submit = realSubmit }
-	      }
-	    }
-	  }
-
-	  textarea.style.display = "none"
-	  var cm = CodeMirror(function (node) { return textarea.parentNode.insertBefore(node, textarea.nextSibling); },
-	    options)
-	  return cm
-	}
-
-	function addLegacyProps(CodeMirror) {
-	  CodeMirror.off = off
-	  CodeMirror.on = on
-	  CodeMirror.wheelEventPixels = wheelEventPixels
-	  CodeMirror.Doc = Doc
-	  CodeMirror.splitLines = splitLinesAuto
-	  CodeMirror.countColumn = countColumn
-	  CodeMirror.findColumn = findColumn
-	  CodeMirror.isWordChar = isWordCharBasic
-	  CodeMirror.Pass = Pass
-	  CodeMirror.signal = signal
-	  CodeMirror.Line = Line
-	  CodeMirror.changeEnd = changeEnd
-	  CodeMirror.scrollbarModel = scrollbarModel
-	  CodeMirror.Pos = Pos
-	  CodeMirror.cmpPos = cmp
-	  CodeMirror.modes = modes
-	  CodeMirror.mimeModes = mimeModes
-	  CodeMirror.resolveMode = resolveMode
-	  CodeMirror.getMode = getMode
-	  CodeMirror.modeExtensions = modeExtensions
-	  CodeMirror.extendMode = extendMode
-	  CodeMirror.copyState = copyState
-	  CodeMirror.startState = startState
-	  CodeMirror.innerMode = innerMode
-	  CodeMirror.commands = commands
-	  CodeMirror.keyMap = keyMap
-	  CodeMirror.keyName = keyName
-	  CodeMirror.isModifierKey = isModifierKey
-	  CodeMirror.lookupKey = lookupKey
-	  CodeMirror.normalizeKeyMap = normalizeKeyMap
-	  CodeMirror.StringStream = StringStream
-	  CodeMirror.SharedTextMarker = SharedTextMarker
-	  CodeMirror.TextMarker = TextMarker
-	  CodeMirror.LineWidget = LineWidget
-	  CodeMirror.e_preventDefault = e_preventDefault
-	  CodeMirror.e_stopPropagation = e_stopPropagation
-	  CodeMirror.e_stop = e_stop
-	  CodeMirror.addClass = addClass
-	  CodeMirror.contains = contains
-	  CodeMirror.rmClass = rmClass
-	  CodeMirror.keyNames = keyNames
-	}
-
-	// EDITOR CONSTRUCTOR
-
-	defineOptions(CodeMirror)
-
-	addEditorMethods(CodeMirror)
-
-	// Set up methods on CodeMirror's prototype to redirect to the editor's document.
-	var dontDelegate = "iter insert remove copy getEditor constructor".split(" ")
-	for (var prop in Doc.prototype) { if (Doc.prototype.hasOwnProperty(prop) && indexOf(dontDelegate, prop) < 0)
-	  { CodeMirror.prototype[prop] = (function(method) {
-	    return function() {return method.apply(this.doc, arguments)}
-	  })(Doc.prototype[prop]) } }
-
-	eventMixin(Doc)
-
-	// INPUT HANDLING
-
-	CodeMirror.inputStyles = {"textarea": TextareaInput, "contenteditable": ContentEditableInput}
-
-	// MODE DEFINITION AND QUERYING
-
-	// Extra arguments are stored as the mode's dependencies, which is
-	// used by (legacy) mechanisms like loadmode.js to automatically
-	// load a mode. (Preferred mechanism is the require/define calls.)
-	CodeMirror.defineMode = function(name/*, mode, …*/) {
-	  if (!CodeMirror.defaults.mode && name != "null") { CodeMirror.defaults.mode = name }
-	  defineMode.apply(this, arguments)
-	}
-
-	CodeMirror.defineMIME = defineMIME
-
-	// Minimal default mode.
-	CodeMirror.defineMode("null", function () { return ({token: function (stream) { return stream.skipToEnd(); }}); })
-	CodeMirror.defineMIME("text/plain", "null")
-
-	// EXTENSIONS
-
-	CodeMirror.defineExtension = function (name, func) {
-	  CodeMirror.prototype[name] = func
-	}
-	CodeMirror.defineDocExtension = function (name, func) {
-	  Doc.prototype[name] = func
-	}
-
-	CodeMirror.fromTextArea = fromTextArea
-
-	addLegacyProps(CodeMirror)
-
-	CodeMirror.version = "5.21.0"
-
-	return CodeMirror;
-
-	})));
-
-/***/ },
-/* 268 */
-/***/ function(module, exports, __webpack_require__) {
-
-	// CodeMirror, copyright (c) by Marijn Haverbeke and others
-	// Distributed under an MIT license: http://codemirror.net/LICENSE
-
-	(function(mod) {
-	  if (true) // CommonJS
-	    mod(__webpack_require__(267));
-	  else if (typeof define == "function" && define.amd) // AMD
-	    define(["../../lib/codemirror"], mod);
-	  else // Plain browser env
-	    mod(CodeMirror);
-	})(function(CodeMirror) {
-	  "use strict";
-
-	  var HINT_ELEMENT_CLASS        = "CodeMirror-hint";
-	  var ACTIVE_HINT_ELEMENT_CLASS = "CodeMirror-hint-active";
-
-	  // This is the old interface, kept around for now to stay
-	  // backwards-compatible.
-	  CodeMirror.showHint = function(cm, getHints, options) {
-	    if (!getHints) return cm.showHint(options);
-	    if (options && options.async) getHints.async = true;
-	    var newOpts = {hint: getHints};
-	    if (options) for (var prop in options) newOpts[prop] = options[prop];
-	    return cm.showHint(newOpts);
-	  };
-
-	  CodeMirror.defineExtension("showHint", function(options) {
-	    options = parseOptions(this, this.getCursor("start"), options);
-	    var selections = this.listSelections()
-	    if (selections.length > 1) return;
-	    // By default, don't allow completion when something is selected.
-	    // A hint function can have a `supportsSelection` property to
-	    // indicate that it can handle selections.
-	    if (this.somethingSelected()) {
-	      if (!options.hint.supportsSelection) return;
-	      // Don't try with cross-line selections
-	      for (var i = 0; i < selections.length; i++)
-	        if (selections[i].head.line != selections[i].anchor.line) return;
-	    }
-
-	    if (this.state.completionActive) this.state.completionActive.close();
-	    var completion = this.state.completionActive = new Completion(this, options);
-	    if (!completion.options.hint) return;
-
-	    CodeMirror.signal(this, "startCompletion", this);
-	    completion.update(true);
-	  });
-
-	  function Completion(cm, options) {
-	    this.cm = cm;
-	    this.options = options;
-	    this.widget = null;
-	    this.debounce = 0;
-	    this.tick = 0;
-	    this.startPos = this.cm.getCursor("start");
-	    this.startLen = this.cm.getLine(this.startPos.line).length - this.cm.getSelection().length;
-
-	    var self = this;
-	    cm.on("cursorActivity", this.activityFunc = function() { self.cursorActivity(); });
-	  }
-
-	  var requestAnimationFrame = window.requestAnimationFrame || function(fn) {
-	    return setTimeout(fn, 1000/60);
-	  };
-	  var cancelAnimationFrame = window.cancelAnimationFrame || clearTimeout;
-
-	  Completion.prototype = {
-	    close: function() {
-	      if (!this.active()) return;
-	      this.cm.state.completionActive = null;
-	      this.tick = null;
-	      this.cm.off("cursorActivity", this.activityFunc);
-
-	      if (this.widget && this.data) CodeMirror.signal(this.data, "close");
-	      if (this.widget) this.widget.close();
-	      CodeMirror.signal(this.cm, "endCompletion", this.cm);
-	    },
-
-	    active: function() {
-	      return this.cm.state.completionActive == this;
-	    },
-
-	    pick: function(data, i) {
-	      var completion = data.list[i];
-	      if (completion.hint) completion.hint(this.cm, data, completion);
-	      else this.cm.replaceRange(getText(completion), completion.from || data.from,
-	                                completion.to || data.to, "complete");
-	      CodeMirror.signal(data, "pick", completion);
-	      this.close();
-	    },
-
-	    cursorActivity: function() {
-	      if (this.debounce) {
-	        cancelAnimationFrame(this.debounce);
-	        this.debounce = 0;
-	      }
-
-	      var pos = this.cm.getCursor(), line = this.cm.getLine(pos.line);
-	      if (pos.line != this.startPos.line || line.length - pos.ch != this.startLen - this.startPos.ch ||
-	          pos.ch < this.startPos.ch || this.cm.somethingSelected() ||
-	          (pos.ch && this.options.closeCharacters.test(line.charAt(pos.ch - 1)))) {
-	        this.close();
-	      } else {
-	        var self = this;
-	        this.debounce = requestAnimationFrame(function() {self.update();});
-	        if (this.widget) this.widget.disable();
-	      }
-	    },
-
-	    update: function(first) {
-	      if (this.tick == null) return
-	      var self = this, myTick = ++this.tick
-	      fetchHints(this.options.hint, this.cm, this.options, function(data) {
-	        if (self.tick == myTick) self.finishUpdate(data, first)
-	      })
-	    },
-
-	    finishUpdate: function(data, first) {
-	      if (this.data) CodeMirror.signal(this.data, "update");
-
-	      var picked = (this.widget && this.widget.picked) || (first && this.options.completeSingle);
-	      if (this.widget) this.widget.close();
-
-	      if (data && this.data && isNewCompletion(this.data, data)) return;
-	      this.data = data;
-
-	      if (data && data.list.length) {
-	        if (picked && data.list.length == 1) {
-	          this.pick(data, 0);
-	        } else {
-	          this.widget = new Widget(this, data);
-	          CodeMirror.signal(data, "shown");
-	        }
-	      }
-	    }
-	  };
-
-	  function isNewCompletion(old, nw) {
-	    var moved = CodeMirror.cmpPos(nw.from, old.from)
-	    return moved > 0 && old.to.ch - old.from.ch != nw.to.ch - nw.from.ch
-	  }
-
-	  function parseOptions(cm, pos, options) {
-	    var editor = cm.options.hintOptions;
-	    var out = {};
-	    for (var prop in defaultOptions) out[prop] = defaultOptions[prop];
-	    if (editor) for (var prop in editor)
-	      if (editor[prop] !== undefined) out[prop] = editor[prop];
-	    if (options) for (var prop in options)
-	      if (options[prop] !== undefined) out[prop] = options[prop];
-	    if (out.hint.resolve) out.hint = out.hint.resolve(cm, pos)
-	    return out;
-	  }
-
-	  function getText(completion) {
-	    if (typeof completion == "string") return completion;
-	    else return completion.text;
-	  }
-
-	  function buildKeyMap(completion, handle) {
-	    var baseMap = {
-	      Up: function() {handle.moveFocus(-1);},
-	      Down: function() {handle.moveFocus(1);},
-	      PageUp: function() {handle.moveFocus(-handle.menuSize() + 1, true);},
-	      PageDown: function() {handle.moveFocus(handle.menuSize() - 1, true);},
-	      Home: function() {handle.setFocus(0);},
-	      End: function() {handle.setFocus(handle.length - 1);},
-	      Enter: handle.pick,
-	      Tab: handle.pick,
-	      Esc: handle.close
-	    };
-	    var custom = completion.options.customKeys;
-	    var ourMap = custom ? {} : baseMap;
-	    function addBinding(key, val) {
-	      var bound;
-	      if (typeof val != "string")
-	        bound = function(cm) { return val(cm, handle); };
-	      // This mechanism is deprecated
-	      else if (baseMap.hasOwnProperty(val))
-	        bound = baseMap[val];
-	      else
-	        bound = val;
-	      ourMap[key] = bound;
-	    }
-	    if (custom)
-	      for (var key in custom) if (custom.hasOwnProperty(key))
-	        addBinding(key, custom[key]);
-	    var extra = completion.options.extraKeys;
-	    if (extra)
-	      for (var key in extra) if (extra.hasOwnProperty(key))
-	        addBinding(key, extra[key]);
-	    return ourMap;
-	  }
-
-	  function getHintElement(hintsElement, el) {
-	    while (el && el != hintsElement) {
-	      if (el.nodeName.toUpperCase() === "LI" && el.parentNode == hintsElement) return el;
-	      el = el.parentNode;
-	    }
-	  }
-
-	  function Widget(completion, data) {
-	    this.completion = completion;
-	    this.data = data;
-	    this.picked = false;
-	    var widget = this, cm = completion.cm;
-
-	    var hints = this.hints = document.createElement("ul");
-	    hints.className = "CodeMirror-hints";
-	    this.selectedHint = data.selectedHint || 0;
-
-	    var completions = data.list;
-	    for (var i = 0; i < completions.length; ++i) {
-	      var elt = hints.appendChild(document.createElement("li")), cur = completions[i];
-	      var className = HINT_ELEMENT_CLASS + (i != this.selectedHint ? "" : " " + ACTIVE_HINT_ELEMENT_CLASS);
-	      if (cur.className != null) className = cur.className + " " + className;
-	      elt.className = className;
-	      if (cur.render) cur.render(elt, data, cur);
-	      else elt.appendChild(document.createTextNode(cur.displayText || getText(cur)));
-	      elt.hintId = i;
-	    }
-
-	    var pos = cm.cursorCoords(completion.options.alignWithWord ? data.from : null);
-	    var left = pos.left, top = pos.bottom, below = true;
-	    hints.style.left = left + "px";
-	    hints.style.top = top + "px";
-	    // If we're at the edge of the screen, then we want the menu to appear on the left of the cursor.
-	    var winW = window.innerWidth || Math.max(document.body.offsetWidth, document.documentElement.offsetWidth);
-	    var winH = window.innerHeight || Math.max(document.body.offsetHeight, document.documentElement.offsetHeight);
-	    (completion.options.container || document.body).appendChild(hints);
-	    var box = hints.getBoundingClientRect(), overlapY = box.bottom - winH;
-	    var scrolls = hints.scrollHeight > hints.clientHeight + 1
-	    var startScroll = cm.getScrollInfo();
-
-	    if (overlapY > 0) {
-	      var height = box.bottom - box.top, curTop = pos.top - (pos.bottom - box.top);
-	      if (curTop - height > 0) { // Fits above cursor
-	        hints.style.top = (top = pos.top - height) + "px";
-	        below = false;
-	      } else if (height > winH) {
-	        hints.style.height = (winH - 5) + "px";
-	        hints.style.top = (top = pos.bottom - box.top) + "px";
-	        var cursor = cm.getCursor();
-	        if (data.from.ch != cursor.ch) {
-	          pos = cm.cursorCoords(cursor);
-	          hints.style.left = (left = pos.left) + "px";
-	          box = hints.getBoundingClientRect();
-	        }
-	      }
-	    }
-	    var overlapX = box.right - winW;
-	    if (overlapX > 0) {
-	      if (box.right - box.left > winW) {
-	        hints.style.width = (winW - 5) + "px";
-	        overlapX -= (box.right - box.left) - winW;
-	      }
-	      hints.style.left = (left = pos.left - overlapX) + "px";
-	    }
-	    if (scrolls) for (var node = hints.firstChild; node; node = node.nextSibling)
-	      node.style.paddingRight = cm.display.nativeBarWidth + "px"
-
-	    cm.addKeyMap(this.keyMap = buildKeyMap(completion, {
-	      moveFocus: function(n, avoidWrap) { widget.changeActive(widget.selectedHint + n, avoidWrap); },
-	      setFocus: function(n) { widget.changeActive(n); },
-	      menuSize: function() { return widget.screenAmount(); },
-	      length: completions.length,
-	      close: function() { completion.close(); },
-	      pick: function() { widget.pick(); },
-	      data: data
-	    }));
-
-	    if (completion.options.closeOnUnfocus) {
-	      var closingOnBlur;
-	      cm.on("blur", this.onBlur = function() { closingOnBlur = setTimeout(function() { completion.close(); }, 100); });
-	      cm.on("focus", this.onFocus = function() { clearTimeout(closingOnBlur); });
-	    }
-
-	    cm.on("scroll", this.onScroll = function() {
-	      var curScroll = cm.getScrollInfo(), editor = cm.getWrapperElement().getBoundingClientRect();
-	      var newTop = top + startScroll.top - curScroll.top;
-	      var point = newTop - (window.pageYOffset || (document.documentElement || document.body).scrollTop);
-	      if (!below) point += hints.offsetHeight;
-	      if (point <= editor.top || point >= editor.bottom) return completion.close();
-	      hints.style.top = newTop + "px";
-	      hints.style.left = (left + startScroll.left - curScroll.left) + "px";
-	    });
-
-	    CodeMirror.on(hints, "dblclick", function(e) {
-	      var t = getHintElement(hints, e.target || e.srcElement);
-	      if (t && t.hintId != null) {widget.changeActive(t.hintId); widget.pick();}
-	    });
-
-	    CodeMirror.on(hints, "click", function(e) {
-	      var t = getHintElement(hints, e.target || e.srcElement);
-	      if (t && t.hintId != null) {
-	        widget.changeActive(t.hintId);
-	        if (completion.options.completeOnSingleClick) widget.pick();
-	      }
-	    });
-
-	    CodeMirror.on(hints, "mousedown", function() {
-	      setTimeout(function(){cm.focus();}, 20);
-	    });
-
-	    CodeMirror.signal(data, "select", completions[0], hints.firstChild);
-	    return true;
-	  }
-
-	  Widget.prototype = {
-	    close: function() {
-	      if (this.completion.widget != this) return;
-	      this.completion.widget = null;
-	      this.hints.parentNode.removeChild(this.hints);
-	      this.completion.cm.removeKeyMap(this.keyMap);
-
-	      var cm = this.completion.cm;
-	      if (this.completion.options.closeOnUnfocus) {
-	        cm.off("blur", this.onBlur);
-	        cm.off("focus", this.onFocus);
-	      }
-	      cm.off("scroll", this.onScroll);
-	    },
-
-	    disable: function() {
-	      this.completion.cm.removeKeyMap(this.keyMap);
-	      var widget = this;
-	      this.keyMap = {Enter: function() { widget.picked = true; }};
-	      this.completion.cm.addKeyMap(this.keyMap);
-	    },
-
-	    pick: function() {
-	      this.completion.pick(this.data, this.selectedHint);
-	    },
-
-	    changeActive: function(i, avoidWrap) {
-	      if (i >= this.data.list.length)
-	        i = avoidWrap ? this.data.list.length - 1 : 0;
-	      else if (i < 0)
-	        i = avoidWrap ? 0  : this.data.list.length - 1;
-	      if (this.selectedHint == i) return;
-	      var node = this.hints.childNodes[this.selectedHint];
-	      node.className = node.className.replace(" " + ACTIVE_HINT_ELEMENT_CLASS, "");
-	      node = this.hints.childNodes[this.selectedHint = i];
-	      node.className += " " + ACTIVE_HINT_ELEMENT_CLASS;
-	      if (node.offsetTop < this.hints.scrollTop)
-	        this.hints.scrollTop = node.offsetTop - 3;
-	      else if (node.offsetTop + node.offsetHeight > this.hints.scrollTop + this.hints.clientHeight)
-	        this.hints.scrollTop = node.offsetTop + node.offsetHeight - this.hints.clientHeight + 3;
-	      CodeMirror.signal(this.data, "select", this.data.list[this.selectedHint], node);
-	    },
-
-	    screenAmount: function() {
-	      return Math.floor(this.hints.clientHeight / this.hints.firstChild.offsetHeight) || 1;
-	    }
-	  };
-
-	  function applicableHelpers(cm, helpers) {
-	    if (!cm.somethingSelected()) return helpers
-	    var result = []
-	    for (var i = 0; i < helpers.length; i++)
-	      if (helpers[i].supportsSelection) result.push(helpers[i])
-	    return result
-	  }
-
-	  function fetchHints(hint, cm, options, callback) {
-	    if (hint.async) {
-	      hint(cm, callback, options)
-	    } else {
-	      var result = hint(cm, options)
-	      if (result && result.then) result.then(callback)
-	      else callback(result)
-	    }
-	  }
-
-	  function resolveAutoHints(cm, pos) {
-	    var helpers = cm.getHelpers(pos, "hint"), words
-	    if (helpers.length) {
-	      var resolved = function(cm, callback, options) {
-	        var app = applicableHelpers(cm, helpers);
-	        function run(i) {
-	          if (i == app.length) return callback(null)
-	          fetchHints(app[i], cm, options, function(result) {
-	            if (result && result.list.length > 0) callback(result)
-	            else run(i + 1)
-	          })
-	        }
-	        run(0)
-	      }
-	      resolved.async = true
-	      resolved.supportsSelection = true
-	      return resolved
-	    } else if (words = cm.getHelper(cm.getCursor(), "hintWords")) {
-	      return function(cm) { return CodeMirror.hint.fromList(cm, {words: words}) }
-	    } else if (CodeMirror.hint.anyword) {
-	      return function(cm, options) { return CodeMirror.hint.anyword(cm, options) }
-	    } else {
-	      return function() {}
-	    }
-	  }
-
-	  CodeMirror.registerHelper("hint", "auto", {
-	    resolve: resolveAutoHints
-	  });
-
-	  CodeMirror.registerHelper("hint", "fromList", function(cm, options) {
-	    var cur = cm.getCursor(), token = cm.getTokenAt(cur);
-	    var to = CodeMirror.Pos(cur.line, token.end);
-	    if (token.string && /\w/.test(token.string[token.string.length - 1])) {
-	      var term = token.string, from = CodeMirror.Pos(cur.line, token.start);
-	    } else {
-	      var term = "", from = to;
-	    }
-	    var found = [];
-	    for (var i = 0; i < options.words.length; i++) {
-	      var word = options.words[i];
-	      if (word.slice(0, term.length) == term)
-	        found.push(word);
-	    }
-
-	    if (found.length) return {list: found, from: from, to: to};
-	  });
-
-	  CodeMirror.commands.autocomplete = CodeMirror.showHint;
-
-	  var defaultOptions = {
-	    hint: CodeMirror.hint.auto,
-	    completeSingle: true,
-	    alignWithWord: true,
-	    closeCharacters: /[\s()\[\]{};:>,]/,
-	    closeOnUnfocus: true,
-	    completeOnSingleClick: true,
-	    container: null,
-	    customKeys: null,
-	    extraKeys: null
-	  };
-
-	  CodeMirror.defineOption("hintOptions", null);
-	});
-
-
-/***/ },
-/* 269 */
-/***/ function(module, exports, __webpack_require__) {
-
-	// CodeMirror, copyright (c) by Marijn Haverbeke and others
-	// Distributed under an MIT license: http://codemirror.net/LICENSE
-
-	(function(mod) {
-	  if (true) // CommonJS
-	    mod(__webpack_require__(267));
-	  else if (typeof define == "function" && define.amd) // AMD
-	    define(["../../lib/codemirror"], mod);
-	  else // Plain browser env
-	    mod(CodeMirror);
-	})(function(CodeMirror) {
-	  "use strict";
-
-	  var noOptions = {};
-	  var nonWS = /[^\s\u00a0]/;
-	  var Pos = CodeMirror.Pos;
-
-	  function firstNonWS(str) {
-	    var found = str.search(nonWS);
-	    return found == -1 ? 0 : found;
-	  }
-
-	  CodeMirror.commands.toggleComment = function(cm) {
-	    cm.toggleComment();
-	  };
-
-	  CodeMirror.defineExtension("toggleComment", function(options) {
-	    if (!options) options = noOptions;
-	    var cm = this;
-	    var minLine = Infinity, ranges = this.listSelections(), mode = null;
-	    for (var i = ranges.length - 1; i >= 0; i--) {
-	      var from = ranges[i].from(), to = ranges[i].to();
-	      if (from.line >= minLine) continue;
-	      if (to.line >= minLine) to = Pos(minLine, 0);
-	      minLine = from.line;
-	      if (mode == null) {
-	        if (cm.uncomment(from, to, options)) mode = "un";
-	        else { cm.lineComment(from, to, options); mode = "line"; }
-	      } else if (mode == "un") {
-	        cm.uncomment(from, to, options);
-	      } else {
-	        cm.lineComment(from, to, options);
-	      }
-	    }
-	  });
-
-	  // Rough heuristic to try and detect lines that are part of multi-line string
-	  function probablyInsideString(cm, pos, line) {
-	    return /\bstring\b/.test(cm.getTokenTypeAt(Pos(pos.line, 0))) && !/^[\'\"`]/.test(line)
-	  }
-
-	  CodeMirror.defineExtension("lineComment", function(from, to, options) {
-	    if (!options) options = noOptions;
-	    var self = this, mode = self.getModeAt(from);
-	    var firstLine = self.getLine(from.line);
-	    if (firstLine == null || probablyInsideString(self, from, firstLine)) return;
-
-	    var commentString = options.lineComment || mode.lineComment;
-	    if (!commentString) {
-	      if (options.blockCommentStart || mode.blockCommentStart) {
-	        options.fullLines = true;
-	        self.blockComment(from, to, options);
-	      }
-	      return;
-	    }
-
-	    var end = Math.min(to.ch != 0 || to.line == from.line ? to.line + 1 : to.line, self.lastLine() + 1);
-	    var pad = options.padding == null ? " " : options.padding;
-	    var blankLines = options.commentBlankLines || from.line == to.line;
-
-	    self.operation(function() {
-	      if (options.indent) {
-	        var baseString = null;
-	        for (var i = from.line; i < end; ++i) {
-	          var line = self.getLine(i);
-	          var whitespace = line.slice(0, firstNonWS(line));
-	          if (baseString == null || baseString.length > whitespace.length) {
-	            baseString = whitespace;
-	          }
-	        }
-	        for (var i = from.line; i < end; ++i) {
-	          var line = self.getLine(i), cut = baseString.length;
-	          if (!blankLines && !nonWS.test(line)) continue;
-	          if (line.slice(0, cut) != baseString) cut = firstNonWS(line);
-	          self.replaceRange(baseString + commentString + pad, Pos(i, 0), Pos(i, cut));
-	        }
-	      } else {
-	        for (var i = from.line; i < end; ++i) {
-	          if (blankLines || nonWS.test(self.getLine(i)))
-	            self.replaceRange(commentString + pad, Pos(i, 0));
-	        }
-	      }
-	    });
-	  });
-
-	  CodeMirror.defineExtension("blockComment", function(from, to, options) {
-	    if (!options) options = noOptions;
-	    var self = this, mode = self.getModeAt(from);
-	    var startString = options.blockCommentStart || mode.blockCommentStart;
-	    var endString = options.blockCommentEnd || mode.blockCommentEnd;
-	    if (!startString || !endString) {
-	      if ((options.lineComment || mode.lineComment) && options.fullLines != false)
-	        self.lineComment(from, to, options);
-	      return;
-	    }
-	    if (/\bcomment\b/.test(self.getTokenTypeAt(Pos(from.line, 0)))) return
-
-	    var end = Math.min(to.line, self.lastLine());
-	    if (end != from.line && to.ch == 0 && nonWS.test(self.getLine(end))) --end;
-
-	    var pad = options.padding == null ? " " : options.padding;
-	    if (from.line > end) return;
-
-	    self.operation(function() {
-	      if (options.fullLines != false) {
-	        var lastLineHasText = nonWS.test(self.getLine(end));
-	        self.replaceRange(pad + endString, Pos(end));
-	        self.replaceRange(startString + pad, Pos(from.line, 0));
-	        var lead = options.blockCommentLead || mode.blockCommentLead;
-	        if (lead != null) for (var i = from.line + 1; i <= end; ++i)
-	          if (i != end || lastLineHasText)
-	            self.replaceRange(lead + pad, Pos(i, 0));
-	      } else {
-	        self.replaceRange(endString, to);
-	        self.replaceRange(startString, from);
-	      }
-	    });
-	  });
-
-	  CodeMirror.defineExtension("uncomment", function(from, to, options) {
-	    if (!options) options = noOptions;
-	    var self = this, mode = self.getModeAt(from);
-	    var end = Math.min(to.ch != 0 || to.line == from.line ? to.line : to.line - 1, self.lastLine()), start = Math.min(from.line, end);
-
-	    // Try finding line comments
-	    var lineString = options.lineComment || mode.lineComment, lines = [];
-	    var pad = options.padding == null ? " " : options.padding, didSomething;
-	    lineComment: {
-	      if (!lineString) break lineComment;
-	      for (var i = start; i <= end; ++i) {
-	        var line = self.getLine(i);
-	        var found = line.indexOf(lineString);
-	        if (found > -1 && !/comment/.test(self.getTokenTypeAt(Pos(i, found + 1)))) found = -1;
-	        if (found == -1 && nonWS.test(line)) break lineComment;
-	        if (found > -1 && nonWS.test(line.slice(0, found))) break lineComment;
-	        lines.push(line);
-	      }
-	      self.operation(function() {
-	        for (var i = start; i <= end; ++i) {
-	          var line = lines[i - start];
-	          var pos = line.indexOf(lineString), endPos = pos + lineString.length;
-	          if (pos < 0) continue;
-	          if (line.slice(endPos, endPos + pad.length) == pad) endPos += pad.length;
-	          didSomething = true;
-	          self.replaceRange("", Pos(i, pos), Pos(i, endPos));
-	        }
-	      });
-	      if (didSomething) return true;
-	    }
-
-	    // Try block comments
-	    var startString = options.blockCommentStart || mode.blockCommentStart;
-	    var endString = options.blockCommentEnd || mode.blockCommentEnd;
-	    if (!startString || !endString) return false;
-	    var lead = options.blockCommentLead || mode.blockCommentLead;
-	    var startLine = self.getLine(start), open = startLine.indexOf(startString)
-	    if (open == -1) return false
-	    var endLine = end == start ? startLine : self.getLine(end)
-	    var close = endLine.indexOf(endString, end == start ? open + startString.length : 0);
-	    if (close == -1 && start != end) {
-	      endLine = self.getLine(--end);
-	      close = endLine.indexOf(endString);
-	    }
-	    if (close == -1 ||
-	        !/comment/.test(self.getTokenTypeAt(Pos(start, open + 1))) ||
-	        !/comment/.test(self.getTokenTypeAt(Pos(end, close + 1))))
-	      return false;
-
-	    // Avoid killing block comments completely outside the selection.
-	    // Positions of the last startString before the start of the selection, and the first endString after it.
-	    var lastStart = startLine.lastIndexOf(startString, from.ch);
-	    var firstEnd = lastStart == -1 ? -1 : startLine.slice(0, from.ch).indexOf(endString, lastStart + startString.length);
-	    if (lastStart != -1 && firstEnd != -1 && firstEnd + endString.length != from.ch) return false;
-	    // Positions of the first endString after the end of the selection, and the last startString before it.
-	    firstEnd = endLine.indexOf(endString, to.ch);
-	    var almostLastStart = endLine.slice(to.ch).lastIndexOf(startString, firstEnd - to.ch);
-	    lastStart = (firstEnd == -1 || almostLastStart == -1) ? -1 : to.ch + almostLastStart;
-	    if (firstEnd != -1 && lastStart != -1 && lastStart != to.ch) return false;
-
-	    self.operation(function() {
-	      self.replaceRange("", Pos(end, close - (pad && endLine.slice(close - pad.length, close) == pad ? pad.length : 0)),
-	                        Pos(end, close + endString.length));
-	      var openEnd = open + startString.length;
-	      if (pad && startLine.slice(openEnd, openEnd + pad.length) == pad) openEnd += pad.length;
-	      self.replaceRange("", Pos(start, open), Pos(start, openEnd));
-	      if (lead) for (var i = start + 1; i <= end; ++i) {
-	        var line = self.getLine(i), found = line.indexOf(lead);
-	        if (found == -1 || nonWS.test(line.slice(0, found))) continue;
-	        var foundEnd = found + lead.length;
-	        if (pad && line.slice(foundEnd, foundEnd + pad.length) == pad) foundEnd += pad.length;
-	        self.replaceRange("", Pos(i, found), Pos(i, foundEnd));
-	      }
-	    });
-	    return true;
-	  });
-	});
-
-
-/***/ },
-/* 270 */
-/***/ function(module, exports, __webpack_require__) {
-
-	// CodeMirror, copyright (c) by Marijn Haverbeke and others
-	// Distributed under an MIT license: http://codemirror.net/LICENSE
-
-	(function(mod) {
-	  if (true) // CommonJS
-	    mod(__webpack_require__(267));
-	  else if (typeof define == "function" && define.amd) // AMD
-	    define(["../../lib/codemirror"], mod);
-	  else // Plain browser env
-	    mod(CodeMirror);
-	})(function(CodeMirror) {
-	  var ie_lt8 = /MSIE \d/.test(navigator.userAgent) &&
-	    (document.documentMode == null || document.documentMode < 8);
-
-	  var Pos = CodeMirror.Pos;
-
-	  var matching = {"(": ")>", ")": "(<", "[": "]>", "]": "[<", "{": "}>", "}": "{<"};
-
-	  function findMatchingBracket(cm, where, strict, config) {
-	    var line = cm.getLineHandle(where.line), pos = where.ch - 1;
-	    var match = (pos >= 0 && matching[line.text.charAt(pos)]) || matching[line.text.charAt(++pos)];
-	    if (!match) return null;
-	    var dir = match.charAt(1) == ">" ? 1 : -1;
-	    if (strict && (dir > 0) != (pos == where.ch)) return null;
-	    var style = cm.getTokenTypeAt(Pos(where.line, pos + 1));
-
-	    var found = scanForBracket(cm, Pos(where.line, pos + (dir > 0 ? 1 : 0)), dir, style || null, config);
-	    if (found == null) return null;
-	    return {from: Pos(where.line, pos), to: found && found.pos,
-	            match: found && found.ch == match.charAt(0), forward: dir > 0};
-	  }
-
-	  // bracketRegex is used to specify which type of bracket to scan
-	  // should be a regexp, e.g. /[[\]]/
-	  //
-	  // Note: If "where" is on an open bracket, then this bracket is ignored.
-	  //
-	  // Returns false when no bracket was found, null when it reached
-	  // maxScanLines and gave up
-	  function scanForBracket(cm, where, dir, style, config) {
-	    var maxScanLen = (config && config.maxScanLineLength) || 10000;
-	    var maxScanLines = (config && config.maxScanLines) || 1000;
-
-	    var stack = [];
-	    var re = config && config.bracketRegex ? config.bracketRegex : /[(){}[\]]/;
-	    var lineEnd = dir > 0 ? Math.min(where.line + maxScanLines, cm.lastLine() + 1)
-	                          : Math.max(cm.firstLine() - 1, where.line - maxScanLines);
-	    for (var lineNo = where.line; lineNo != lineEnd; lineNo += dir) {
-	      var line = cm.getLine(lineNo);
-	      if (!line) continue;
-	      var pos = dir > 0 ? 0 : line.length - 1, end = dir > 0 ? line.length : -1;
-	      if (line.length > maxScanLen) continue;
-	      if (lineNo == where.line) pos = where.ch - (dir < 0 ? 1 : 0);
-	      for (; pos != end; pos += dir) {
-	        var ch = line.charAt(pos);
-	        if (re.test(ch) && (style === undefined || cm.getTokenTypeAt(Pos(lineNo, pos + 1)) == style)) {
-	          var match = matching[ch];
-	          if ((match.charAt(1) == ">") == (dir > 0)) stack.push(ch);
-	          else if (!stack.length) return {pos: Pos(lineNo, pos), ch: ch};
-	          else stack.pop();
-	        }
-	      }
-	    }
-	    return lineNo - dir == (dir > 0 ? cm.lastLine() : cm.firstLine()) ? false : null;
-	  }
-
-	  function matchBrackets(cm, autoclear, config) {
-	    // Disable brace matching in long lines, since it'll cause hugely slow updates
-	    var maxHighlightLen = cm.state.matchBrackets.maxHighlightLineLength || 1000;
-	    var marks = [], ranges = cm.listSelections();
-	    for (var i = 0; i < ranges.length; i++) {
-	      var match = ranges[i].empty() && findMatchingBracket(cm, ranges[i].head, false, config);
-	      if (match && cm.getLine(match.from.line).length <= maxHighlightLen) {
-	        var style = match.match ? "CodeMirror-matchingbracket" : "CodeMirror-nonmatchingbracket";
-	        marks.push(cm.markText(match.from, Pos(match.from.line, match.from.ch + 1), {className: style}));
-	        if (match.to && cm.getLine(match.to.line).length <= maxHighlightLen)
-	          marks.push(cm.markText(match.to, Pos(match.to.line, match.to.ch + 1), {className: style}));
-	      }
-	    }
-
-	    if (marks.length) {
-	      // Kludge to work around the IE bug from issue #1193, where text
-	      // input stops going to the textare whever this fires.
-	      if (ie_lt8 && cm.state.focused) cm.focus();
-
-	      var clear = function() {
-	        cm.operation(function() {
-	          for (var i = 0; i < marks.length; i++) marks[i].clear();
-	        });
-	      };
-	      if (autoclear) setTimeout(clear, 800);
-	      else return clear;
-	    }
-	  }
-
-	  var currentlyHighlighted = null;
-	  function doMatchBrackets(cm) {
-	    cm.operation(function() {
-	      if (currentlyHighlighted) {currentlyHighlighted(); currentlyHighlighted = null;}
-	      currentlyHighlighted = matchBrackets(cm, false, cm.state.matchBrackets);
-	    });
-	  }
-
-	  CodeMirror.defineOption("matchBrackets", false, function(cm, val, old) {
-	    if (old && old != CodeMirror.Init) {
-	      cm.off("cursorActivity", doMatchBrackets);
-	      if (currentlyHighlighted) {currentlyHighlighted(); currentlyHighlighted = null;}
-	    }
-	    if (val) {
-	      cm.state.matchBrackets = typeof val == "object" ? val : {};
-	      cm.on("cursorActivity", doMatchBrackets);
-	    }
-	  });
-
-	  CodeMirror.defineExtension("matchBrackets", function() {matchBrackets(this, true);});
-	  CodeMirror.defineExtension("findMatchingBracket", function(pos, strict, config){
-	    return findMatchingBracket(this, pos, strict, config);
-	  });
-	  CodeMirror.defineExtension("scanForBracket", function(pos, dir, style, config){
-	    return scanForBracket(this, pos, dir, style, config);
-	  });
-	});
-
-
-/***/ },
-/* 271 */
-/***/ function(module, exports, __webpack_require__) {
-
-	// CodeMirror, copyright (c) by Marijn Haverbeke and others
-	// Distributed under an MIT license: http://codemirror.net/LICENSE
-
-	(function(mod) {
-	  if (true) // CommonJS
-	    mod(__webpack_require__(267));
-	  else if (typeof define == "function" && define.amd) // AMD
-	    define(["../../lib/codemirror"], mod);
-	  else // Plain browser env
-	    mod(CodeMirror);
-	})(function(CodeMirror) {
-	  var defaults = {
-	    pairs: "()[]{}''\"\"",
-	    triples: "",
-	    explode: "[]{}"
-	  };
-
-	  var Pos = CodeMirror.Pos;
-
-	  CodeMirror.defineOption("autoCloseBrackets", false, function(cm, val, old) {
-	    if (old && old != CodeMirror.Init) {
-	      cm.removeKeyMap(keyMap);
-	      cm.state.closeBrackets = null;
-	    }
-	    if (val) {
-	      cm.state.closeBrackets = val;
-	      cm.addKeyMap(keyMap);
-	    }
-	  });
-
-	  function getOption(conf, name) {
-	    if (name == "pairs" && typeof conf == "string") return conf;
-	    if (typeof conf == "object" && conf[name] != null) return conf[name];
-	    return defaults[name];
-	  }
-
-	  var bind = defaults.pairs + "`";
-	  var keyMap = {Backspace: handleBackspace, Enter: handleEnter};
-	  for (var i = 0; i < bind.length; i++)
-	    keyMap["'" + bind.charAt(i) + "'"] = handler(bind.charAt(i));
-
-	  function handler(ch) {
-	    return function(cm) { return handleChar(cm, ch); };
-	  }
-
-	  function getConfig(cm) {
-	    var deflt = cm.state.closeBrackets;
-	    if (!deflt) return null;
-	    var mode = cm.getModeAt(cm.getCursor());
-	    return mode.closeBrackets || deflt;
-	  }
-
-	  function handleBackspace(cm) {
-	    var conf = getConfig(cm);
-	    if (!conf || cm.getOption("disableInput")) return CodeMirror.Pass;
-
-	    var pairs = getOption(conf, "pairs");
-	    var ranges = cm.listSelections();
-	    for (var i = 0; i < ranges.length; i++) {
-	      if (!ranges[i].empty()) return CodeMirror.Pass;
-	      var around = charsAround(cm, ranges[i].head);
-	      if (!around || pairs.indexOf(around) % 2 != 0) return CodeMirror.Pass;
-	    }
-	    for (var i = ranges.length - 1; i >= 0; i--) {
-	      var cur = ranges[i].head;
-	      cm.replaceRange("", Pos(cur.line, cur.ch - 1), Pos(cur.line, cur.ch + 1), "+delete");
-	    }
-	  }
-
-	  function handleEnter(cm) {
-	    var conf = getConfig(cm);
-	    var explode = conf && getOption(conf, "explode");
-	    if (!explode || cm.getOption("disableInput")) return CodeMirror.Pass;
-
-	    var ranges = cm.listSelections();
-	    for (var i = 0; i < ranges.length; i++) {
-	      if (!ranges[i].empty()) return CodeMirror.Pass;
-	      var around = charsAround(cm, ranges[i].head);
-	      if (!around || explode.indexOf(around) % 2 != 0) return CodeMirror.Pass;
-	    }
-	    cm.operation(function() {
-	      cm.replaceSelection("\n\n", null);
-	      cm.execCommand("goCharLeft");
-	      ranges = cm.listSelections();
-	      for (var i = 0; i < ranges.length; i++) {
-	        var line = ranges[i].head.line;
-	        cm.indentLine(line, null, true);
-	        cm.indentLine(line + 1, null, true);
-	      }
-	    });
-	  }
-
-	  function contractSelection(sel) {
-	    var inverted = CodeMirror.cmpPos(sel.anchor, sel.head) > 0;
-	    return {anchor: new Pos(sel.anchor.line, sel.anchor.ch + (inverted ? -1 : 1)),
-	            head: new Pos(sel.head.line, sel.head.ch + (inverted ? 1 : -1))};
-	  }
-
-	  function handleChar(cm, ch) {
-	    var conf = getConfig(cm);
-	    if (!conf || cm.getOption("disableInput")) return CodeMirror.Pass;
-
-	    var pairs = getOption(conf, "pairs");
-	    var pos = pairs.indexOf(ch);
-	    if (pos == -1) return CodeMirror.Pass;
-	    var triples = getOption(conf, "triples");
-
-	    var identical = pairs.charAt(pos + 1) == ch;
-	    var ranges = cm.listSelections();
-	    var opening = pos % 2 == 0;
-
-	    var type;
-	    for (var i = 0; i < ranges.length; i++) {
-	      var range = ranges[i], cur = range.head, curType;
-	      var next = cm.getRange(cur, Pos(cur.line, cur.ch + 1));
-	      if (opening && !range.empty()) {
-	        curType = "surround";
-	      } else if ((identical || !opening) && next == ch) {
-	        if (identical && stringStartsAfter(cm, cur))
-	          curType = "both";
-	        else if (triples.indexOf(ch) >= 0 && cm.getRange(cur, Pos(cur.line, cur.ch + 3)) == ch + ch + ch)
-	          curType = "skipThree";
-	        else
-	          curType = "skip";
-	      } else if (identical && cur.ch > 1 && triples.indexOf(ch) >= 0 &&
-	                 cm.getRange(Pos(cur.line, cur.ch - 2), cur) == ch + ch &&
-	                 (cur.ch <= 2 || cm.getRange(Pos(cur.line, cur.ch - 3), Pos(cur.line, cur.ch - 2)) != ch)) {
-	        curType = "addFour";
-	      } else if (identical) {
-	        if (!CodeMirror.isWordChar(next) && enteringString(cm, cur, ch)) curType = "both";
-	        else return CodeMirror.Pass;
-	      } else if (opening && (cm.getLine(cur.line).length == cur.ch ||
-	                             isClosingBracket(next, pairs) ||
-	                             /\s/.test(next))) {
-	        curType = "both";
-	      } else {
-	        return CodeMirror.Pass;
-	      }
-	      if (!type) type = curType;
-	      else if (type != curType) return CodeMirror.Pass;
-	    }
-
-	    var left = pos % 2 ? pairs.charAt(pos - 1) : ch;
-	    var right = pos % 2 ? ch : pairs.charAt(pos + 1);
-	    cm.operation(function() {
-	      if (type == "skip") {
-	        cm.execCommand("goCharRight");
-	      } else if (type == "skipThree") {
-	        for (var i = 0; i < 3; i++)
-	          cm.execCommand("goCharRight");
-	      } else if (type == "surround") {
-	        var sels = cm.getSelections();
-	        for (var i = 0; i < sels.length; i++)
-	          sels[i] = left + sels[i] + right;
-	        cm.replaceSelections(sels, "around");
-	        sels = cm.listSelections().slice();
-	        for (var i = 0; i < sels.length; i++)
-	          sels[i] = contractSelection(sels[i]);
-	        cm.setSelections(sels);
-	      } else if (type == "both") {
-	        cm.replaceSelection(left + right, null);
-	        cm.triggerElectric(left + right);
-	        cm.execCommand("goCharLeft");
-	      } else if (type == "addFour") {
-	        cm.replaceSelection(left + left + left + left, "before");
-	        cm.execCommand("goCharRight");
-	      }
-	    });
-	  }
-
-	  function isClosingBracket(ch, pairs) {
-	    var pos = pairs.lastIndexOf(ch);
-	    return pos > -1 && pos % 2 == 1;
-	  }
-
-	  function charsAround(cm, pos) {
-	    var str = cm.getRange(Pos(pos.line, pos.ch - 1),
-	                          Pos(pos.line, pos.ch + 1));
-	    return str.length == 2 ? str : null;
-	  }
-
-	  // Project the token type that will exists after the given char is
-	  // typed, and use it to determine whether it would cause the start
-	  // of a string token.
-	  function enteringString(cm, pos, ch) {
-	    var line = cm.getLine(pos.line);
-	    var token = cm.getTokenAt(pos);
-	    if (/\bstring2?\b/.test(token.type)) return false;
-	    var stream = new CodeMirror.StringStream(line.slice(0, pos.ch) + ch + line.slice(pos.ch), 4);
-	    stream.pos = stream.start = token.start;
-	    for (;;) {
-	      var type1 = cm.getMode().token(stream, token.state);
-	      if (stream.pos >= pos.ch + 1) return /\bstring2?\b/.test(type1);
-	      stream.start = stream.pos;
-	    }
-	  }
-
-	  function stringStartsAfter(cm, pos) {
-	    var token = cm.getTokenAt(Pos(pos.line, pos.ch + 1))
-	    return /\bstring/.test(token.type) && token.start == pos.ch
-	  }
-	});
-
-
-/***/ },
-/* 272 */
-/***/ function(module, exports, __webpack_require__) {
-
-	// CodeMirror, copyright (c) by Marijn Haverbeke and others
-	// Distributed under an MIT license: http://codemirror.net/LICENSE
-
-	(function(mod) {
-	  if (true) // CommonJS
-	    mod(__webpack_require__(267), __webpack_require__(273));
-	  else if (typeof define == "function" && define.amd) // AMD
-	    define(["../../lib/codemirror", "./foldcode"], mod);
-	  else // Plain browser env
-	    mod(CodeMirror);
-	})(function(CodeMirror) {
-	  "use strict";
-
-	  CodeMirror.defineOption("foldGutter", false, function(cm, val, old) {
-	    if (old && old != CodeMirror.Init) {
-	      cm.clearGutter(cm.state.foldGutter.options.gutter);
-	      cm.state.foldGutter = null;
-	      cm.off("gutterClick", onGutterClick);
-	      cm.off("change", onChange);
-	      cm.off("viewportChange", onViewportChange);
-	      cm.off("fold", onFold);
-	      cm.off("unfold", onFold);
-	      cm.off("swapDoc", onChange);
-	    }
-	    if (val) {
-	      cm.state.foldGutter = new State(parseOptions(val));
-	      updateInViewport(cm);
-	      cm.on("gutterClick", onGutterClick);
-	      cm.on("change", onChange);
-	      cm.on("viewportChange", onViewportChange);
-	      cm.on("fold", onFold);
-	      cm.on("unfold", onFold);
-	      cm.on("swapDoc", onChange);
-	    }
-	  });
-
-	  var Pos = CodeMirror.Pos;
-
-	  function State(options) {
-	    this.options = options;
-	    this.from = this.to = 0;
-	  }
-
-	  function parseOptions(opts) {
-	    if (opts === true) opts = {};
-	    if (opts.gutter == null) opts.gutter = "CodeMirror-foldgutter";
-	    if (opts.indicatorOpen == null) opts.indicatorOpen = "CodeMirror-foldgutter-open";
-	    if (opts.indicatorFolded == null) opts.indicatorFolded = "CodeMirror-foldgutter-folded";
-	    return opts;
-	  }
-
-	  function isFolded(cm, line) {
-	    var marks = cm.findMarks(Pos(line, 0), Pos(line + 1, 0));
-	    for (var i = 0; i < marks.length; ++i)
-	      if (marks[i].__isFold && marks[i].find().from.line == line) return marks[i];
-	  }
-
-	  function marker(spec) {
-	    if (typeof spec == "string") {
-	      var elt = document.createElement("div");
-	      elt.className = spec + " CodeMirror-guttermarker-subtle";
-	      return elt;
-	    } else {
-	      return spec.cloneNode(true);
-	    }
-	  }
-
-	  function updateFoldInfo(cm, from, to) {
-	    var opts = cm.state.foldGutter.options, cur = from;
-	    var minSize = cm.foldOption(opts, "minFoldSize");
-	    var func = cm.foldOption(opts, "rangeFinder");
-	    cm.eachLine(from, to, function(line) {
-	      var mark = null;
-	      if (isFolded(cm, cur)) {
-	        mark = marker(opts.indicatorFolded);
-	      } else {
-	        var pos = Pos(cur, 0);
-	        var range = func && func(cm, pos);
-	        if (range && range.to.line - range.from.line >= minSize)
-	          mark = marker(opts.indicatorOpen);
-	      }
-	      cm.setGutterMarker(line, opts.gutter, mark);
-	      ++cur;
-	    });
-	  }
-
-	  function updateInViewport(cm) {
-	    var vp = cm.getViewport(), state = cm.state.foldGutter;
-	    if (!state) return;
-	    cm.operation(function() {
-	      updateFoldInfo(cm, vp.from, vp.to);
-	    });
-	    state.from = vp.from; state.to = vp.to;
-	  }
-
-	  function onGutterClick(cm, line, gutter) {
-	    var state = cm.state.foldGutter;
-	    if (!state) return;
-	    var opts = state.options;
-	    if (gutter != opts.gutter) return;
-	    var folded = isFolded(cm, line);
-	    if (folded) folded.clear();
-	    else cm.foldCode(Pos(line, 0), opts.rangeFinder);
-	  }
-
-	  function onChange(cm) {
-	    var state = cm.state.foldGutter;
-	    if (!state) return;
-	    var opts = state.options;
-	    state.from = state.to = 0;
-	    clearTimeout(state.changeUpdate);
-	    state.changeUpdate = setTimeout(function() { updateInViewport(cm); }, opts.foldOnChangeTimeSpan || 600);
-	  }
-
-	  function onViewportChange(cm) {
-	    var state = cm.state.foldGutter;
-	    if (!state) return;
-	    var opts = state.options;
-	    clearTimeout(state.changeUpdate);
-	    state.changeUpdate = setTimeout(function() {
-	      var vp = cm.getViewport();
-	      if (state.from == state.to || vp.from - state.to > 20 || state.from - vp.to > 20) {
-	        updateInViewport(cm);
-	      } else {
-	        cm.operation(function() {
-	          if (vp.from < state.from) {
-	            updateFoldInfo(cm, vp.from, state.from);
-	            state.from = vp.from;
-	          }
-	          if (vp.to > state.to) {
-	            updateFoldInfo(cm, state.to, vp.to);
-	            state.to = vp.to;
-	          }
-	        });
-	      }
-	    }, opts.updateViewportTimeSpan || 400);
-	  }
-
-	  function onFold(cm, from) {
-	    var state = cm.state.foldGutter;
-	    if (!state) return;
-	    var line = from.line;
-	    if (line >= state.from && line < state.to)
-	      updateFoldInfo(cm, line, line + 1);
-	  }
-	});
-
-
-/***/ },
-/* 273 */
-/***/ function(module, exports, __webpack_require__) {
-
-	// CodeMirror, copyright (c) by Marijn Haverbeke and others
-	// Distributed under an MIT license: http://codemirror.net/LICENSE
-
-	(function(mod) {
-	  if (true) // CommonJS
-	    mod(__webpack_require__(267));
-	  else if (typeof define == "function" && define.amd) // AMD
-	    define(["../../lib/codemirror"], mod);
-	  else // Plain browser env
-	    mod(CodeMirror);
-	})(function(CodeMirror) {
-	  "use strict";
-
-	  function doFold(cm, pos, options, force) {
-	    if (options && options.call) {
-	      var finder = options;
-	      options = null;
-	    } else {
-	      var finder = getOption(cm, options, "rangeFinder");
-	    }
-	    if (typeof pos == "number") pos = CodeMirror.Pos(pos, 0);
-	    var minSize = getOption(cm, options, "minFoldSize");
-
-	    function getRange(allowFolded) {
-	      var range = finder(cm, pos);
-	      if (!range || range.to.line - range.from.line < minSize) return null;
-	      var marks = cm.findMarksAt(range.from);
-	      for (var i = 0; i < marks.length; ++i) {
-	        if (marks[i].__isFold && force !== "fold") {
-	          if (!allowFolded) return null;
-	          range.cleared = true;
-	          marks[i].clear();
-	        }
-	      }
-	      return range;
-	    }
-
-	    var range = getRange(true);
-	    if (getOption(cm, options, "scanUp")) while (!range && pos.line > cm.firstLine()) {
-	      pos = CodeMirror.Pos(pos.line - 1, 0);
-	      range = getRange(false);
-	    }
-	    if (!range || range.cleared || force === "unfold") return;
-
-	    var myWidget = makeWidget(cm, options);
-	    CodeMirror.on(myWidget, "mousedown", function(e) {
-	      myRange.clear();
-	      CodeMirror.e_preventDefault(e);
-	    });
-	    var myRange = cm.markText(range.from, range.to, {
-	      replacedWith: myWidget,
-	      clearOnEnter: getOption(cm, options, "clearOnEnter"),
-	      __isFold: true
-	    });
-	    myRange.on("clear", function(from, to) {
-	      CodeMirror.signal(cm, "unfold", cm, from, to);
-	    });
-	    CodeMirror.signal(cm, "fold", cm, range.from, range.to);
-	  }
-
-	  function makeWidget(cm, options) {
-	    var widget = getOption(cm, options, "widget");
-	    if (typeof widget == "string") {
-	      var text = document.createTextNode(widget);
-	      widget = document.createElement("span");
-	      widget.appendChild(text);
-	      widget.className = "CodeMirror-foldmarker";
-	    }
-	    return widget;
-	  }
-
-	  // Clumsy backwards-compatible interface
-	  CodeMirror.newFoldFunction = function(rangeFinder, widget) {
-	    return function(cm, pos) { doFold(cm, pos, {rangeFinder: rangeFinder, widget: widget}); };
-	  };
-
-	  // New-style interface
-	  CodeMirror.defineExtension("foldCode", function(pos, options, force) {
-	    doFold(this, pos, options, force);
-	  });
-
-	  CodeMirror.defineExtension("isFolded", function(pos) {
-	    var marks = this.findMarksAt(pos);
-	    for (var i = 0; i < marks.length; ++i)
-	      if (marks[i].__isFold) return true;
-	  });
-
-	  CodeMirror.commands.toggleFold = function(cm) {
-	    cm.foldCode(cm.getCursor());
-	  };
-	  CodeMirror.commands.fold = function(cm) {
-	    cm.foldCode(cm.getCursor(), null, "fold");
-	  };
-	  CodeMirror.commands.unfold = function(cm) {
-	    cm.foldCode(cm.getCursor(), null, "unfold");
-	  };
-	  CodeMirror.commands.foldAll = function(cm) {
-	    cm.operation(function() {
-	      for (var i = cm.firstLine(), e = cm.lastLine(); i <= e; i++)
-	        cm.foldCode(CodeMirror.Pos(i, 0), null, "fold");
-	    });
-	  };
-	  CodeMirror.commands.unfoldAll = function(cm) {
-	    cm.operation(function() {
-	      for (var i = cm.firstLine(), e = cm.lastLine(); i <= e; i++)
-	        cm.foldCode(CodeMirror.Pos(i, 0), null, "unfold");
-	    });
-	  };
-
-	  CodeMirror.registerHelper("fold", "combine", function() {
-	    var funcs = Array.prototype.slice.call(arguments, 0);
-	    return function(cm, start) {
-	      for (var i = 0; i < funcs.length; ++i) {
-	        var found = funcs[i](cm, start);
-	        if (found) return found;
-	      }
-	    };
-	  });
-
-	  CodeMirror.registerHelper("fold", "auto", function(cm, start) {
-	    var helpers = cm.getHelpers(start, "fold");
-	    for (var i = 0; i < helpers.length; i++) {
-	      var cur = helpers[i](cm, start);
-	      if (cur) return cur;
-	    }
-	  });
-
-	  var defaultOptions = {
-	    rangeFinder: CodeMirror.fold.auto,
-	    widget: "\u2194",
-	    minFoldSize: 0,
-	    scanUp: false,
-	    clearOnEnter: true
-	  };
-
-	  CodeMirror.defineOption("foldOptions", null);
-
-	  function getOption(cm, options, name) {
-	    if (options && options[name] !== undefined)
-	      return options[name];
-	    var editorOptions = cm.options.foldOptions;
-	    if (editorOptions && editorOptions[name] !== undefined)
-	      return editorOptions[name];
-	    return defaultOptions[name];
-	  }
-
-	  CodeMirror.defineExtension("foldOption", function(options, name) {
-	    return getOption(this, options, name);
-	  });
-	});
-
-
-/***/ },
-/* 274 */
-/***/ function(module, exports, __webpack_require__) {
-
-	// CodeMirror, copyright (c) by Marijn Haverbeke and others
-	// Distributed under an MIT license: http://codemirror.net/LICENSE
-
-	(function(mod) {
-	  if (true) // CommonJS
-	    mod(__webpack_require__(267));
-	  else if (typeof define == "function" && define.amd) // AMD
-	    define(["../../lib/codemirror"], mod);
-	  else // Plain browser env
-	    mod(CodeMirror);
-	})(function(CodeMirror) {
-	"use strict";
-
-	CodeMirror.registerHelper("fold", "brace", function(cm, start) {
-	  var line = start.line, lineText = cm.getLine(line);
-	  var tokenType;
-
-	  function findOpening(openCh) {
-	    for (var at = start.ch, pass = 0;;) {
-	      var found = at <= 0 ? -1 : lineText.lastIndexOf(openCh, at - 1);
-	      if (found == -1) {
-	        if (pass == 1) break;
-	        pass = 1;
-	        at = lineText.length;
-	        continue;
-	      }
-	      if (pass == 1 && found < start.ch) break;
-	      tokenType = cm.getTokenTypeAt(CodeMirror.Pos(line, found + 1));
-	      if (!/^(comment|string)/.test(tokenType)) return found + 1;
-	      at = found - 1;
-	    }
-	  }
-
-	  var startToken = "{", endToken = "}", startCh = findOpening("{");
-	  if (startCh == null) {
-	    startToken = "[", endToken = "]";
-	    startCh = findOpening("[");
-	  }
-
-	  if (startCh == null) return;
-	  var count = 1, lastLine = cm.lastLine(), end, endCh;
-	  outer: for (var i = line; i <= lastLine; ++i) {
-	    var text = cm.getLine(i), pos = i == line ? startCh : 0;
-	    for (;;) {
-	      var nextOpen = text.indexOf(startToken, pos), nextClose = text.indexOf(endToken, pos);
-	      if (nextOpen < 0) nextOpen = text.length;
-	      if (nextClose < 0) nextClose = text.length;
-	      pos = Math.min(nextOpen, nextClose);
-	      if (pos == text.length) break;
-	      if (cm.getTokenTypeAt(CodeMirror.Pos(i, pos + 1)) == tokenType) {
-	        if (pos == nextOpen) ++count;
-	        else if (!--count) { end = i; endCh = pos; break outer; }
-	      }
-	      ++pos;
-	    }
-	  }
-	  if (end == null || line == end && endCh == startCh) return;
-	  return {from: CodeMirror.Pos(line, startCh),
-	          to: CodeMirror.Pos(end, endCh)};
-	});
-
-	CodeMirror.registerHelper("fold", "import", function(cm, start) {
-	  function hasImport(line) {
-	    if (line < cm.firstLine() || line > cm.lastLine()) return null;
-	    var start = cm.getTokenAt(CodeMirror.Pos(line, 1));
-	    if (!/\S/.test(start.string)) start = cm.getTokenAt(CodeMirror.Pos(line, start.end + 1));
-	    if (start.type != "keyword" || start.string != "import") return null;
-	    // Now find closing semicolon, return its position
-	    for (var i = line, e = Math.min(cm.lastLine(), line + 10); i <= e; ++i) {
-	      var text = cm.getLine(i), semi = text.indexOf(";");
-	      if (semi != -1) return {startCh: start.end, end: CodeMirror.Pos(i, semi)};
-	    }
-	  }
-
-	  var startLine = start.line, has = hasImport(startLine), prev;
-	  if (!has || hasImport(startLine - 1) || ((prev = hasImport(startLine - 2)) && prev.end.line == startLine - 1))
-	    return null;
-	  for (var end = has.end;;) {
-	    var next = hasImport(end.line + 1);
-	    if (next == null) break;
-	    end = next.end;
-	  }
-	  return {from: cm.clipPos(CodeMirror.Pos(startLine, has.startCh + 1)), to: end};
-	});
-
-	CodeMirror.registerHelper("fold", "include", function(cm, start) {
-	  function hasInclude(line) {
-	    if (line < cm.firstLine() || line > cm.lastLine()) return null;
-	    var start = cm.getTokenAt(CodeMirror.Pos(line, 1));
-	    if (!/\S/.test(start.string)) start = cm.getTokenAt(CodeMirror.Pos(line, start.end + 1));
-	    if (start.type == "meta" && start.string.slice(0, 8) == "#include") return start.start + 8;
-	  }
-
-	  var startLine = start.line, has = hasInclude(startLine);
-	  if (has == null || hasInclude(startLine - 1) != null) return null;
-	  for (var end = startLine;;) {
-	    var next = hasInclude(end + 1);
-	    if (next == null) break;
-	    ++end;
-	  }
-	  return {from: CodeMirror.Pos(startLine, has + 1),
-	          to: cm.clipPos(CodeMirror.Pos(end))};
-	});
-
-	});
-
-
-/***/ },
-/* 275 */
-/***/ function(module, exports, __webpack_require__) {
-
-	// CodeMirror, copyright (c) by Marijn Haverbeke and others
-	// Distributed under an MIT license: http://codemirror.net/LICENSE
-
-	(function(mod) {
-	  if (true) // CommonJS
-	    mod(__webpack_require__(267));
-	  else if (typeof define == "function" && define.amd) // AMD
-	    define(["../../lib/codemirror"], mod);
-	  else // Plain browser env
-	    mod(CodeMirror);
-	})(function(CodeMirror) {
-	  "use strict";
-	  var GUTTER_ID = "CodeMirror-lint-markers";
-
-	  function showTooltip(e, content) {
-	    var tt = document.createElement("div");
-	    tt.className = "CodeMirror-lint-tooltip";
-	    tt.appendChild(content.cloneNode(true));
-	    document.body.appendChild(tt);
-
-	    function position(e) {
-	      if (!tt.parentNode) return CodeMirror.off(document, "mousemove", position);
-	      tt.style.top = Math.max(0, e.clientY - tt.offsetHeight - 5) + "px";
-	      tt.style.left = (e.clientX + 5) + "px";
-	    }
-	    CodeMirror.on(document, "mousemove", position);
-	    position(e);
-	    if (tt.style.opacity != null) tt.style.opacity = 1;
-	    return tt;
-	  }
-	  function rm(elt) {
-	    if (elt.parentNode) elt.parentNode.removeChild(elt);
-	  }
-	  function hideTooltip(tt) {
-	    if (!tt.parentNode) return;
-	    if (tt.style.opacity == null) rm(tt);
-	    tt.style.opacity = 0;
-	    setTimeout(function() { rm(tt); }, 600);
-	  }
-
-	  function showTooltipFor(e, content, node) {
-	    var tooltip = showTooltip(e, content);
-	    function hide() {
-	      CodeMirror.off(node, "mouseout", hide);
-	      if (tooltip) { hideTooltip(tooltip); tooltip = null; }
-	    }
-	    var poll = setInterval(function() {
-	      if (tooltip) for (var n = node;; n = n.parentNode) {
-	        if (n && n.nodeType == 11) n = n.host;
-	        if (n == document.body) return;
-	        if (!n) { hide(); break; }
-	      }
-	      if (!tooltip) return clearInterval(poll);
-	    }, 400);
-	    CodeMirror.on(node, "mouseout", hide);
-	  }
-
-	  function LintState(cm, options, hasGutter) {
-	    this.marked = [];
-	    this.options = options;
-	    this.timeout = null;
-	    this.hasGutter = hasGutter;
-	    this.onMouseOver = function(e) { onMouseOver(cm, e); };
-	    this.waitingFor = 0
-	  }
-
-	  function parseOptions(_cm, options) {
-	    if (options instanceof Function) return {getAnnotations: options};
-	    if (!options || options === true) options = {};
-	    return options;
-	  }
-
-	  function clearMarks(cm) {
-	    var state = cm.state.lint;
-	    if (state.hasGutter) cm.clearGutter(GUTTER_ID);
-	    for (var i = 0; i < state.marked.length; ++i)
-	      state.marked[i].clear();
-	    state.marked.length = 0;
-	  }
-
-	  function makeMarker(labels, severity, multiple, tooltips) {
-	    var marker = document.createElement("div"), inner = marker;
-	    marker.className = "CodeMirror-lint-marker-" + severity;
-	    if (multiple) {
-	      inner = marker.appendChild(document.createElement("div"));
-	      inner.className = "CodeMirror-lint-marker-multiple";
-	    }
-
-	    if (tooltips != false) CodeMirror.on(inner, "mouseover", function(e) {
-	      showTooltipFor(e, labels, inner);
-	    });
-
-	    return marker;
-	  }
-
-	  function getMaxSeverity(a, b) {
-	    if (a == "error") return a;
-	    else return b;
-	  }
-
-	  function groupByLine(annotations) {
-	    var lines = [];
-	    for (var i = 0; i < annotations.length; ++i) {
-	      var ann = annotations[i], line = ann.from.line;
-	      (lines[line] || (lines[line] = [])).push(ann);
-	    }
-	    return lines;
-	  }
-
-	  function annotationTooltip(ann) {
-	    var severity = ann.severity;
-	    if (!severity) severity = "error";
-	    var tip = document.createElement("div");
-	    tip.className = "CodeMirror-lint-message-" + severity;
-	    tip.appendChild(document.createTextNode(ann.message));
-	    return tip;
-	  }
-
-	  function lintAsync(cm, getAnnotations, passOptions) {
-	    var state = cm.state.lint
-	    var id = ++state.waitingFor
-	    function abort() {
-	      id = -1
-	      cm.off("change", abort)
-	    }
-	    cm.on("change", abort)
-	    getAnnotations(cm.getValue(), function(annotations, arg2) {
-	      cm.off("change", abort)
-	      if (state.waitingFor != id) return
-	      if (arg2 && annotations instanceof CodeMirror) annotations = arg2
-	      updateLinting(cm, annotations)
-	    }, passOptions, cm);
-	  }
-
-	  function startLinting(cm) {
-	    var state = cm.state.lint, options = state.options;
-	    var passOptions = options.options || options; // Support deprecated passing of `options` property in options
-	    var getAnnotations = options.getAnnotations || cm.getHelper(CodeMirror.Pos(0, 0), "lint");
-	    if (!getAnnotations) return;
-	    if (options.async || getAnnotations.async) {
-	      lintAsync(cm, getAnnotations, passOptions)
-	    } else {
-	      updateLinting(cm, getAnnotations(cm.getValue(), passOptions, cm));
-	    }
-	  }
-
-	  function updateLinting(cm, annotationsNotSorted) {
-	    clearMarks(cm);
-	    var state = cm.state.lint, options = state.options;
-
-	    var annotations = groupByLine(annotationsNotSorted);
-
-	    for (var line = 0; line < annotations.length; ++line) {
-	      var anns = annotations[line];
-	      if (!anns) continue;
-
-	      var maxSeverity = null;
-	      var tipLabel = state.hasGutter && document.createDocumentFragment();
-
-	      for (var i = 0; i < anns.length; ++i) {
-	        var ann = anns[i];
-	        var severity = ann.severity;
-	        if (!severity) severity = "error";
-	        maxSeverity = getMaxSeverity(maxSeverity, severity);
-
-	        if (options.formatAnnotation) ann = options.formatAnnotation(ann);
-	        if (state.hasGutter) tipLabel.appendChild(annotationTooltip(ann));
-
-	        if (ann.to) state.marked.push(cm.markText(ann.from, ann.to, {
-	          className: "CodeMirror-lint-mark-" + severity,
-	          __annotation: ann
-	        }));
-	      }
-
-	      if (state.hasGutter)
-	        cm.setGutterMarker(line, GUTTER_ID, makeMarker(tipLabel, maxSeverity, anns.length > 1,
-	                                                       state.options.tooltips));
-	    }
-	    if (options.onUpdateLinting) options.onUpdateLinting(annotationsNotSorted, annotations, cm);
-	  }
-
-	  function onChange(cm) {
-	    var state = cm.state.lint;
-	    if (!state) return;
-	    clearTimeout(state.timeout);
-	    state.timeout = setTimeout(function(){startLinting(cm);}, state.options.delay || 500);
-	  }
-
-	  function popupTooltips(annotations, e) {
-	    var target = e.target || e.srcElement;
-	    var tooltip = document.createDocumentFragment();
-	    for (var i = 0; i < annotations.length; i++) {
-	      var ann = annotations[i];
-	      tooltip.appendChild(annotationTooltip(ann));
-	    }
-	    showTooltipFor(e, tooltip, target);
-	  }
-
-	  function onMouseOver(cm, e) {
-	    var target = e.target || e.srcElement;
-	    if (!/\bCodeMirror-lint-mark-/.test(target.className)) return;
-	    var box = target.getBoundingClientRect(), x = (box.left + box.right) / 2, y = (box.top + box.bottom) / 2;
-	    var spans = cm.findMarksAt(cm.coordsChar({left: x, top: y}, "client"));
-
-	    var annotations = [];
-	    for (var i = 0; i < spans.length; ++i) {
-	      var ann = spans[i].__annotation;
-	      if (ann) annotations.push(ann);
-	    }
-	    if (annotations.length) popupTooltips(annotations, e);
-	  }
-
-	  CodeMirror.defineOption("lint", false, function(cm, val, old) {
-	    if (old && old != CodeMirror.Init) {
-	      clearMarks(cm);
-	      if (cm.state.lint.options.lintOnChange !== false)
-	        cm.off("change", onChange);
-	      CodeMirror.off(cm.getWrapperElement(), "mouseover", cm.state.lint.onMouseOver);
-	      clearTimeout(cm.state.lint.timeout);
-	      delete cm.state.lint;
-	    }
-
-	    if (val) {
-	      var gutters = cm.getOption("gutters"), hasLintGutter = false;
-	      for (var i = 0; i < gutters.length; ++i) if (gutters[i] == GUTTER_ID) hasLintGutter = true;
-	      var state = cm.state.lint = new LintState(cm, parseOptions(cm, val), hasLintGutter);
-	      if (state.options.lintOnChange !== false)
-	        cm.on("change", onChange);
-	      if (state.options.tooltips != false && state.options.tooltips != "gutter")
-	        CodeMirror.on(cm.getWrapperElement(), "mouseover", state.onMouseOver);
-
-	      startLinting(cm);
-	    }
-	  });
-
-	  CodeMirror.defineExtension("performLint", function() {
-	    if (this.state.lint) startLinting(this);
-	  });
-	});
-
-
-/***/ },
-/* 276 */
-/***/ function(module, exports, __webpack_require__) {
-
-	// CodeMirror, copyright (c) by Marijn Haverbeke and others
-	// Distributed under an MIT license: http://codemirror.net/LICENSE
-
-	// A rough approximation of Sublime Text's keybindings
-	// Depends on addon/search/searchcursor.js and optionally addon/dialog/dialogs.js
-
-	(function(mod) {
-	  if (true) // CommonJS
-	    mod(__webpack_require__(267), __webpack_require__(277), __webpack_require__(270));
-	  else if (typeof define == "function" && define.amd) // AMD
-	    define(["../lib/codemirror", "../addon/search/searchcursor", "../addon/edit/matchbrackets"], mod);
-	  else // Plain browser env
-	    mod(CodeMirror);
-	})(function(CodeMirror) {
-	  "use strict";
-
-	  var map = CodeMirror.keyMap.sublime = {fallthrough: "default"};
-	  var cmds = CodeMirror.commands;
-	  var Pos = CodeMirror.Pos;
-	  var mac = CodeMirror.keyMap["default"] == CodeMirror.keyMap.macDefault;
-	  var ctrl = mac ? "Cmd-" : "Ctrl-";
-
-	  // This is not exactly Sublime's algorithm. I couldn't make heads or tails of that.
-	  function findPosSubword(doc, start, dir) {
-	    if (dir < 0 && start.ch == 0) return doc.clipPos(Pos(start.line - 1));
-	    var line = doc.getLine(start.line);
-	    if (dir > 0 && start.ch >= line.length) return doc.clipPos(Pos(start.line + 1, 0));
-	    var state = "start", type;
-	    for (var pos = start.ch, e = dir < 0 ? 0 : line.length, i = 0; pos != e; pos += dir, i++) {
-	      var next = line.charAt(dir < 0 ? pos - 1 : pos);
-	      var cat = next != "_" && CodeMirror.isWordChar(next) ? "w" : "o";
-	      if (cat == "w" && next.toUpperCase() == next) cat = "W";
-	      if (state == "start") {
-	        if (cat != "o") { state = "in"; type = cat; }
-	      } else if (state == "in") {
-	        if (type != cat) {
-	          if (type == "w" && cat == "W" && dir < 0) pos--;
-	          if (type == "W" && cat == "w" && dir > 0) { type = "w"; continue; }
-	          break;
-	        }
-	      }
-	    }
-	    return Pos(start.line, pos);
-	  }
-
-	  function moveSubword(cm, dir) {
-	    cm.extendSelectionsBy(function(range) {
-	      if (cm.display.shift || cm.doc.extend || range.empty())
-	        return findPosSubword(cm.doc, range.head, dir);
-	      else
-	        return dir < 0 ? range.from() : range.to();
-	    });
-	  }
-
-	  var goSubwordCombo = mac ? "Ctrl-" : "Alt-";
-
-	  cmds[map[goSubwordCombo + "Left"] = "goSubwordLeft"] = function(cm) { moveSubword(cm, -1); };
-	  cmds[map[goSubwordCombo + "Right"] = "goSubwordRight"] = function(cm) { moveSubword(cm, 1); };
-
-	  if (mac) map["Cmd-Left"] = "goLineStartSmart";
-
-	  var scrollLineCombo = mac ? "Ctrl-Alt-" : "Ctrl-";
-
-	  cmds[map[scrollLineCombo + "Up"] = "scrollLineUp"] = function(cm) {
-	    var info = cm.getScrollInfo();
-	    if (!cm.somethingSelected()) {
-	      var visibleBottomLine = cm.lineAtHeight(info.top + info.clientHeight, "local");
-	      if (cm.getCursor().line >= visibleBottomLine)
-	        cm.execCommand("goLineUp");
-	    }
-	    cm.scrollTo(null, info.top - cm.defaultTextHeight());
-	  };
-	  cmds[map[scrollLineCombo + "Down"] = "scrollLineDown"] = function(cm) {
-	    var info = cm.getScrollInfo();
-	    if (!cm.somethingSelected()) {
-	      var visibleTopLine = cm.lineAtHeight(info.top, "local")+1;
-	      if (cm.getCursor().line <= visibleTopLine)
-	        cm.execCommand("goLineDown");
-	    }
-	    cm.scrollTo(null, info.top + cm.defaultTextHeight());
-	  };
-
-	  cmds[map["Shift-" + ctrl + "L"] = "splitSelectionByLine"] = function(cm) {
-	    var ranges = cm.listSelections(), lineRanges = [];
-	    for (var i = 0; i < ranges.length; i++) {
-	      var from = ranges[i].from(), to = ranges[i].to();
-	      for (var line = from.line; line <= to.line; ++line)
-	        if (!(to.line > from.line && line == to.line && to.ch == 0))
-	          lineRanges.push({anchor: line == from.line ? from : Pos(line, 0),
-	                           head: line == to.line ? to : Pos(line)});
-	    }
-	    cm.setSelections(lineRanges, 0);
-	  };
-
-	  map["Shift-Tab"] = "indentLess";
-
-	  cmds[map["Esc"] = "singleSelectionTop"] = function(cm) {
-	    var range = cm.listSelections()[0];
-	    cm.setSelection(range.anchor, range.head, {scroll: false});
-	  };
-
-	  cmds[map[ctrl + "L"] = "selectLine"] = function(cm) {
-	    var ranges = cm.listSelections(), extended = [];
-	    for (var i = 0; i < ranges.length; i++) {
-	      var range = ranges[i];
-	      extended.push({anchor: Pos(range.from().line, 0),
-	                     head: Pos(range.to().line + 1, 0)});
-	    }
-	    cm.setSelections(extended);
-	  };
-
-	  map["Shift-Ctrl-K"] = "deleteLine";
-
-	  function insertLine(cm, above) {
-	    if (cm.isReadOnly()) return CodeMirror.Pass
-	    cm.operation(function() {
-	      var len = cm.listSelections().length, newSelection = [], last = -1;
-	      for (var i = 0; i < len; i++) {
-	        var head = cm.listSelections()[i].head;
-	        if (head.line <= last) continue;
-	        var at = Pos(head.line + (above ? 0 : 1), 0);
-	        cm.replaceRange("\n", at, null, "+insertLine");
-	        cm.indentLine(at.line, null, true);
-	        newSelection.push({head: at, anchor: at});
-	        last = head.line + 1;
-	      }
-	      cm.setSelections(newSelection);
-	    });
-	    cm.execCommand("indentAuto");
-	  }
-
-	  cmds[map[ctrl + "Enter"] = "insertLineAfter"] = function(cm) { return insertLine(cm, false); };
-
-	  cmds[map["Shift-" + ctrl + "Enter"] = "insertLineBefore"] = function(cm) { return insertLine(cm, true); };
-
-	  function wordAt(cm, pos) {
-	    var start = pos.ch, end = start, line = cm.getLine(pos.line);
-	    while (start && CodeMirror.isWordChar(line.charAt(start - 1))) --start;
-	    while (end < line.length && CodeMirror.isWordChar(line.charAt(end))) ++end;
-	    return {from: Pos(pos.line, start), to: Pos(pos.line, end), word: line.slice(start, end)};
-	  }
-
-	  cmds[map[ctrl + "D"] = "selectNextOccurrence"] = function(cm) {
-	    var from = cm.getCursor("from"), to = cm.getCursor("to");
-	    var fullWord = cm.state.sublimeFindFullWord == cm.doc.sel;
-	    if (CodeMirror.cmpPos(from, to) == 0) {
-	      var word = wordAt(cm, from);
-	      if (!word.word) return;
-	      cm.setSelection(word.from, word.to);
-	      fullWord = true;
-	    } else {
-	      var text = cm.getRange(from, to);
-	      var query = fullWord ? new RegExp("\\b" + text + "\\b") : text;
-	      var cur = cm.getSearchCursor(query, to);
-	      if (cur.findNext()) {
-	        cm.addSelection(cur.from(), cur.to());
-	      } else {
-	        cur = cm.getSearchCursor(query, Pos(cm.firstLine(), 0));
-	        if (cur.findNext())
-	          cm.addSelection(cur.from(), cur.to());
-	      }
-	    }
-	    if (fullWord)
-	      cm.state.sublimeFindFullWord = cm.doc.sel;
-	  };
-
-	  var mirror = "(){}[]";
-	  function selectBetweenBrackets(cm) {
-	    var pos = cm.getCursor(), opening = cm.scanForBracket(pos, -1);
-	    if (!opening) return;
-	    for (;;) {
-	      var closing = cm.scanForBracket(pos, 1);
-	      if (!closing) return;
-	      if (closing.ch == mirror.charAt(mirror.indexOf(opening.ch) + 1)) {
-	        cm.setSelection(Pos(opening.pos.line, opening.pos.ch + 1), closing.pos, false);
-	        return true;
-	      }
-	      pos = Pos(closing.pos.line, closing.pos.ch + 1);
-	    }
-	  }
-
-	  cmds[map["Shift-" + ctrl + "Space"] = "selectScope"] = function(cm) {
-	    selectBetweenBrackets(cm) || cm.execCommand("selectAll");
-	  };
-	  cmds[map["Shift-" + ctrl + "M"] = "selectBetweenBrackets"] = function(cm) {
-	    if (!selectBetweenBrackets(cm)) return CodeMirror.Pass;
-	  };
-
-	  cmds[map[ctrl + "M"] = "goToBracket"] = function(cm) {
-	    cm.extendSelectionsBy(function(range) {
-	      var next = cm.scanForBracket(range.head, 1);
-	      if (next && CodeMirror.cmpPos(next.pos, range.head) != 0) return next.pos;
-	      var prev = cm.scanForBracket(range.head, -1);
-	      return prev && Pos(prev.pos.line, prev.pos.ch + 1) || range.head;
-	    });
-	  };
-
-	  var swapLineCombo = mac ? "Cmd-Ctrl-" : "Shift-Ctrl-";
-
-	  cmds[map[swapLineCombo + "Up"] = "swapLineUp"] = function(cm) {
-	    if (cm.isReadOnly()) return CodeMirror.Pass
-	    var ranges = cm.listSelections(), linesToMove = [], at = cm.firstLine() - 1, newSels = [];
-	    for (var i = 0; i < ranges.length; i++) {
-	      var range = ranges[i], from = range.from().line - 1, to = range.to().line;
-	      newSels.push({anchor: Pos(range.anchor.line - 1, range.anchor.ch),
-	                    head: Pos(range.head.line - 1, range.head.ch)});
-	      if (range.to().ch == 0 && !range.empty()) --to;
-	      if (from > at) linesToMove.push(from, to);
-	      else if (linesToMove.length) linesToMove[linesToMove.length - 1] = to;
-	      at = to;
-	    }
-	    cm.operation(function() {
-	      for (var i = 0; i < linesToMove.length; i += 2) {
-	        var from = linesToMove[i], to = linesToMove[i + 1];
-	        var line = cm.getLine(from);
-	        cm.replaceRange("", Pos(from, 0), Pos(from + 1, 0), "+swapLine");
-	        if (to > cm.lastLine())
-	          cm.replaceRange("\n" + line, Pos(cm.lastLine()), null, "+swapLine");
-	        else
-	          cm.replaceRange(line + "\n", Pos(to, 0), null, "+swapLine");
-	      }
-	      cm.setSelections(newSels);
-	      cm.scrollIntoView();
-	    });
-	  };
-
-	  cmds[map[swapLineCombo + "Down"] = "swapLineDown"] = function(cm) {
-	    if (cm.isReadOnly()) return CodeMirror.Pass
-	    var ranges = cm.listSelections(), linesToMove = [], at = cm.lastLine() + 1;
-	    for (var i = ranges.length - 1; i >= 0; i--) {
-	      var range = ranges[i], from = range.to().line + 1, to = range.from().line;
-	      if (range.to().ch == 0 && !range.empty()) from--;
-	      if (from < at) linesToMove.push(from, to);
-	      else if (linesToMove.length) linesToMove[linesToMove.length - 1] = to;
-	      at = to;
-	    }
-	    cm.operation(function() {
-	      for (var i = linesToMove.length - 2; i >= 0; i -= 2) {
-	        var from = linesToMove[i], to = linesToMove[i + 1];
-	        var line = cm.getLine(from);
-	        if (from == cm.lastLine())
-	          cm.replaceRange("", Pos(from - 1), Pos(from), "+swapLine");
-	        else
-	          cm.replaceRange("", Pos(from, 0), Pos(from + 1, 0), "+swapLine");
-	        cm.replaceRange(line + "\n", Pos(to, 0), null, "+swapLine");
-	      }
-	      cm.scrollIntoView();
-	    });
-	  };
-
-	  cmds[map[ctrl + "/"] = "toggleCommentIndented"] = function(cm) {
-	    cm.toggleComment({ indent: true });
-	  }
-
-	  cmds[map[ctrl + "J"] = "joinLines"] = function(cm) {
-	    var ranges = cm.listSelections(), joined = [];
-	    for (var i = 0; i < ranges.length; i++) {
-	      var range = ranges[i], from = range.from();
-	      var start = from.line, end = range.to().line;
-	      while (i < ranges.length - 1 && ranges[i + 1].from().line == end)
-	        end = ranges[++i].to().line;
-	      joined.push({start: start, end: end, anchor: !range.empty() && from});
-	    }
-	    cm.operation(function() {
-	      var offset = 0, ranges = [];
-	      for (var i = 0; i < joined.length; i++) {
-	        var obj = joined[i];
-	        var anchor = obj.anchor && Pos(obj.anchor.line - offset, obj.anchor.ch), head;
-	        for (var line = obj.start; line <= obj.end; line++) {
-	          var actual = line - offset;
-	          if (line == obj.end) head = Pos(actual, cm.getLine(actual).length + 1);
-	          if (actual < cm.lastLine()) {
-	            cm.replaceRange(" ", Pos(actual), Pos(actual + 1, /^\s*/.exec(cm.getLine(actual + 1))[0].length));
-	            ++offset;
-	          }
-	        }
-	        ranges.push({anchor: anchor || head, head: head});
-	      }
-	      cm.setSelections(ranges, 0);
-	    });
-	  };
-
-	  cmds[map["Shift-" + ctrl + "D"] = "duplicateLine"] = function(cm) {
-	    cm.operation(function() {
-	      var rangeCount = cm.listSelections().length;
-	      for (var i = 0; i < rangeCount; i++) {
-	        var range = cm.listSelections()[i];
-	        if (range.empty())
-	          cm.replaceRange(cm.getLine(range.head.line) + "\n", Pos(range.head.line, 0));
-	        else
-	          cm.replaceRange(cm.getRange(range.from(), range.to()), range.from());
-	      }
-	      cm.scrollIntoView();
-	    });
-	  };
-
-	  if (!mac) map[ctrl + "T"] = "transposeChars";
-
-	  function sortLines(cm, caseSensitive) {
-	    if (cm.isReadOnly()) return CodeMirror.Pass
-	    var ranges = cm.listSelections(), toSort = [], selected;
-	    for (var i = 0; i < ranges.length; i++) {
-	      var range = ranges[i];
-	      if (range.empty()) continue;
-	      var from = range.from().line, to = range.to().line;
-	      while (i < ranges.length - 1 && ranges[i + 1].from().line == to)
-	        to = range[++i].to().line;
-	      toSort.push(from, to);
-	    }
-	    if (toSort.length) selected = true;
-	    else toSort.push(cm.firstLine(), cm.lastLine());
-
-	    cm.operation(function() {
-	      var ranges = [];
-	      for (var i = 0; i < toSort.length; i += 2) {
-	        var from = toSort[i], to = toSort[i + 1];
-	        var start = Pos(from, 0), end = Pos(to);
-	        var lines = cm.getRange(start, end, false);
-	        if (caseSensitive)
-	          lines.sort();
-	        else
-	          lines.sort(function(a, b) {
-	            var au = a.toUpperCase(), bu = b.toUpperCase();
-	            if (au != bu) { a = au; b = bu; }
-	            return a < b ? -1 : a == b ? 0 : 1;
-	          });
-	        cm.replaceRange(lines, start, end);
-	        if (selected) ranges.push({anchor: start, head: end});
-	      }
-	      if (selected) cm.setSelections(ranges, 0);
-	    });
-	  }
-
-	  cmds[map["F9"] = "sortLines"] = function(cm) { sortLines(cm, true); };
-	  cmds[map[ctrl + "F9"] = "sortLinesInsensitive"] = function(cm) { sortLines(cm, false); };
-
-	  cmds[map["F2"] = "nextBookmark"] = function(cm) {
-	    var marks = cm.state.sublimeBookmarks;
-	    if (marks) while (marks.length) {
-	      var current = marks.shift();
-	      var found = current.find();
-	      if (found) {
-	        marks.push(current);
-	        return cm.setSelection(found.from, found.to);
-	      }
-	    }
-	  };
-
-	  cmds[map["Shift-F2"] = "prevBookmark"] = function(cm) {
-	    var marks = cm.state.sublimeBookmarks;
-	    if (marks) while (marks.length) {
-	      marks.unshift(marks.pop());
-	      var found = marks[marks.length - 1].find();
-	      if (!found)
-	        marks.pop();
-	      else
-	        return cm.setSelection(found.from, found.to);
-	    }
-	  };
-
-	  cmds[map[ctrl + "F2"] = "toggleBookmark"] = function(cm) {
-	    var ranges = cm.listSelections();
-	    var marks = cm.state.sublimeBookmarks || (cm.state.sublimeBookmarks = []);
-	    for (var i = 0; i < ranges.length; i++) {
-	      var from = ranges[i].from(), to = ranges[i].to();
-	      var found = cm.findMarks(from, to);
-	      for (var j = 0; j < found.length; j++) {
-	        if (found[j].sublimeBookmark) {
-	          found[j].clear();
-	          for (var k = 0; k < marks.length; k++)
-	            if (marks[k] == found[j])
-	              marks.splice(k--, 1);
-	          break;
-	        }
-	      }
-	      if (j == found.length)
-	        marks.push(cm.markText(from, to, {sublimeBookmark: true, clearWhenEmpty: false}));
-	    }
-	  };
-
-	  cmds[map["Shift-" + ctrl + "F2"] = "clearBookmarks"] = function(cm) {
-	    var marks = cm.state.sublimeBookmarks;
-	    if (marks) for (var i = 0; i < marks.length; i++) marks[i].clear();
-	    marks.length = 0;
-	  };
-
-	  cmds[map["Alt-F2"] = "selectBookmarks"] = function(cm) {
-	    var marks = cm.state.sublimeBookmarks, ranges = [];
-	    if (marks) for (var i = 0; i < marks.length; i++) {
-	      var found = marks[i].find();
-	      if (!found)
-	        marks.splice(i--, 0);
-	      else
-	        ranges.push({anchor: found.from, head: found.to});
-	    }
-	    if (ranges.length)
-	      cm.setSelections(ranges, 0);
-	  };
-
-	  map["Alt-Q"] = "wrapLines";
-
-	  var cK = ctrl + "K ";
-
-	  function modifyWordOrSelection(cm, mod) {
-	    cm.operation(function() {
-	      var ranges = cm.listSelections(), indices = [], replacements = [];
-	      for (var i = 0; i < ranges.length; i++) {
-	        var range = ranges[i];
-	        if (range.empty()) { indices.push(i); replacements.push(""); }
-	        else replacements.push(mod(cm.getRange(range.from(), range.to())));
-	      }
-	      cm.replaceSelections(replacements, "around", "case");
-	      for (var i = indices.length - 1, at; i >= 0; i--) {
-	        var range = ranges[indices[i]];
-	        if (at && CodeMirror.cmpPos(range.head, at) > 0) continue;
-	        var word = wordAt(cm, range.head);
-	        at = word.from;
-	        cm.replaceRange(mod(word.word), word.from, word.to);
-	      }
-	    });
-	  }
-
-	  map[cK + ctrl + "Backspace"] = "delLineLeft";
-
-	  cmds[map["Backspace"] = "smartBackspace"] = function(cm) {
-	    if (cm.somethingSelected()) return CodeMirror.Pass;
-
-	    cm.operation(function() {
-	      var cursors = cm.listSelections();
-	      var indentUnit = cm.getOption("indentUnit");
-
-	      for (var i = cursors.length - 1; i >= 0; i--) {
-	        var cursor = cursors[i].head;
-	        var toStartOfLine = cm.getRange({line: cursor.line, ch: 0}, cursor);
-	        var column = CodeMirror.countColumn(toStartOfLine, null, cm.getOption("tabSize"));
-
-	        // Delete by one character by default
-	        var deletePos = cm.findPosH(cursor, -1, "char", false);
-
-	        if (toStartOfLine && !/\S/.test(toStartOfLine) && column % indentUnit == 0) {
-	          var prevIndent = new Pos(cursor.line,
-	            CodeMirror.findColumn(toStartOfLine, column - indentUnit, indentUnit));
-
-	          // Smart delete only if we found a valid prevIndent location
-	          if (prevIndent.ch != cursor.ch) deletePos = prevIndent;
-	        }
-
-	        cm.replaceRange("", deletePos, cursor, "+delete");
-	      }
-	    });
-	  };
-
-	  cmds[map[cK + ctrl + "K"] = "delLineRight"] = function(cm) {
-	    cm.operation(function() {
-	      var ranges = cm.listSelections();
-	      for (var i = ranges.length - 1; i >= 0; i--)
-	        cm.replaceRange("", ranges[i].anchor, Pos(ranges[i].to().line), "+delete");
-	      cm.scrollIntoView();
-	    });
-	  };
-
-	  cmds[map[cK + ctrl + "U"] = "upcaseAtCursor"] = function(cm) {
-	    modifyWordOrSelection(cm, function(str) { return str.toUpperCase(); });
-	  };
-	  cmds[map[cK + ctrl + "L"] = "downcaseAtCursor"] = function(cm) {
-	    modifyWordOrSelection(cm, function(str) { return str.toLowerCase(); });
-	  };
-
-	  cmds[map[cK + ctrl + "Space"] = "setSublimeMark"] = function(cm) {
-	    if (cm.state.sublimeMark) cm.state.sublimeMark.clear();
-	    cm.state.sublimeMark = cm.setBookmark(cm.getCursor());
-	  };
-	  cmds[map[cK + ctrl + "A"] = "selectToSublimeMark"] = function(cm) {
-	    var found = cm.state.sublimeMark && cm.state.sublimeMark.find();
-	    if (found) cm.setSelection(cm.getCursor(), found);
-	  };
-	  cmds[map[cK + ctrl + "W"] = "deleteToSublimeMark"] = function(cm) {
-	    var found = cm.state.sublimeMark && cm.state.sublimeMark.find();
-	    if (found) {
-	      var from = cm.getCursor(), to = found;
-	      if (CodeMirror.cmpPos(from, to) > 0) { var tmp = to; to = from; from = tmp; }
-	      cm.state.sublimeKilled = cm.getRange(from, to);
-	      cm.replaceRange("", from, to);
-	    }
-	  };
-	  cmds[map[cK + ctrl + "X"] = "swapWithSublimeMark"] = function(cm) {
-	    var found = cm.state.sublimeMark && cm.state.sublimeMark.find();
-	    if (found) {
-	      cm.state.sublimeMark.clear();
-	      cm.state.sublimeMark = cm.setBookmark(cm.getCursor());
-	      cm.setCursor(found);
-	    }
-	  };
-	  cmds[map[cK + ctrl + "Y"] = "sublimeYank"] = function(cm) {
-	    if (cm.state.sublimeKilled != null)
-	      cm.replaceSelection(cm.state.sublimeKilled, null, "paste");
-	  };
-
-	  map[cK + ctrl + "G"] = "clearBookmarks";
-	  cmds[map[cK + ctrl + "C"] = "showInCenter"] = function(cm) {
-	    var pos = cm.cursorCoords(null, "local");
-	    cm.scrollTo(null, (pos.top + pos.bottom) / 2 - cm.getScrollInfo().clientHeight / 2);
-	  };
-
-	  var selectLinesCombo = mac ? "Ctrl-Shift-" : "Ctrl-Alt-";
-	  cmds[map[selectLinesCombo + "Up"] = "selectLinesUpward"] = function(cm) {
-	    cm.operation(function() {
-	      var ranges = cm.listSelections();
-	      for (var i = 0; i < ranges.length; i++) {
-	        var range = ranges[i];
-	        if (range.head.line > cm.firstLine())
-	          cm.addSelection(Pos(range.head.line - 1, range.head.ch));
-	      }
-	    });
-	  };
-	  cmds[map[selectLinesCombo + "Down"] = "selectLinesDownward"] = function(cm) {
-	    cm.operation(function() {
-	      var ranges = cm.listSelections();
-	      for (var i = 0; i < ranges.length; i++) {
-	        var range = ranges[i];
-	        if (range.head.line < cm.lastLine())
-	          cm.addSelection(Pos(range.head.line + 1, range.head.ch));
-	      }
-	    });
-	  };
-
-	  function getTarget(cm) {
-	    var from = cm.getCursor("from"), to = cm.getCursor("to");
-	    if (CodeMirror.cmpPos(from, to) == 0) {
-	      var word = wordAt(cm, from);
-	      if (!word.word) return;
-	      from = word.from;
-	      to = word.to;
-	    }
-	    return {from: from, to: to, query: cm.getRange(from, to), word: word};
-	  }
-
-	  function findAndGoTo(cm, forward) {
-	    var target = getTarget(cm);
-	    if (!target) return;
-	    var query = target.query;
-	    var cur = cm.getSearchCursor(query, forward ? target.to : target.from);
-
-	    if (forward ? cur.findNext() : cur.findPrevious()) {
-	      cm.setSelection(cur.from(), cur.to());
-	    } else {
-	      cur = cm.getSearchCursor(query, forward ? Pos(cm.firstLine(), 0)
-	                                              : cm.clipPos(Pos(cm.lastLine())));
-	      if (forward ? cur.findNext() : cur.findPrevious())
-	        cm.setSelection(cur.from(), cur.to());
-	      else if (target.word)
-	        cm.setSelection(target.from, target.to);
-	    }
-	  };
-	  cmds[map[ctrl + "F3"] = "findUnder"] = function(cm) { findAndGoTo(cm, true); };
-	  cmds[map["Shift-" + ctrl + "F3"] = "findUnderPrevious"] = function(cm) { findAndGoTo(cm,false); };
-	  cmds[map["Alt-F3"] = "findAllUnder"] = function(cm) {
-	    var target = getTarget(cm);
-	    if (!target) return;
-	    var cur = cm.getSearchCursor(target.query);
-	    var matches = [];
-	    var primaryIndex = -1;
-	    while (cur.findNext()) {
-	      matches.push({anchor: cur.from(), head: cur.to()});
-	      if (cur.from().line <= target.from.line && cur.from().ch <= target.from.ch)
-	        primaryIndex++;
-	    }
-	    cm.setSelections(matches, primaryIndex);
-	  };
-
-	  map["Shift-" + ctrl + "["] = "fold";
-	  map["Shift-" + ctrl + "]"] = "unfold";
-	  map[cK + ctrl + "0"] = map[cK + ctrl + "J"] = "unfoldAll";
-
-	  map[ctrl + "I"] = "findIncremental";
-	  map["Shift-" + ctrl + "I"] = "findIncrementalReverse";
-	  map[ctrl + "H"] = "replace";
-	  map["F3"] = "findNext";
-	  map["Shift-F3"] = "findPrev";
-
-	  CodeMirror.normalizeKeyMap(map);
-	});
-
-
-/***/ },
-/* 277 */
-/***/ function(module, exports, __webpack_require__) {
-
-	// CodeMirror, copyright (c) by Marijn Haverbeke and others
-	// Distributed under an MIT license: http://codemirror.net/LICENSE
-
-	(function(mod) {
-	  if (true) // CommonJS
-	    mod(__webpack_require__(267));
-	  else if (typeof define == "function" && define.amd) // AMD
-	    define(["../../lib/codemirror"], mod);
-	  else // Plain browser env
-	    mod(CodeMirror);
-	})(function(CodeMirror) {
-	  "use strict";
-	  var Pos = CodeMirror.Pos;
-
-	  function SearchCursor(doc, query, pos, caseFold) {
-	    this.atOccurrence = false; this.doc = doc;
-	    if (caseFold == null && typeof query == "string") caseFold = false;
-
-	    pos = pos ? doc.clipPos(pos) : Pos(0, 0);
-	    this.pos = {from: pos, to: pos};
-
-	    // The matches method is filled in based on the type of query.
-	    // It takes a position and a direction, and returns an object
-	    // describing the next occurrence of the query, or null if no
-	    // more matches were found.
-	    if (typeof query != "string") { // Regexp match
-	      if (!query.global) query = new RegExp(query.source, query.ignoreCase ? "ig" : "g");
-	      this.matches = function(reverse, pos) {
-	        if (reverse) {
-	          query.lastIndex = 0;
-	          var line = doc.getLine(pos.line).slice(0, pos.ch), cutOff = 0, match, start;
-	          for (;;) {
-	            query.lastIndex = cutOff;
-	            var newMatch = query.exec(line);
-	            if (!newMatch) break;
-	            match = newMatch;
-	            start = match.index;
-	            cutOff = match.index + (match[0].length || 1);
-	            if (cutOff == line.length) break;
-	          }
-	          var matchLen = (match && match[0].length) || 0;
-	          if (!matchLen) {
-	            if (start == 0 && line.length == 0) {match = undefined;}
-	            else if (start != doc.getLine(pos.line).length) {
-	              matchLen++;
-	            }
-	          }
-	        } else {
-	          query.lastIndex = pos.ch;
-	          var line = doc.getLine(pos.line), match = query.exec(line);
-	          var matchLen = (match && match[0].length) || 0;
-	          var start = match && match.index;
-	          if (start + matchLen != line.length && !matchLen) matchLen = 1;
-	        }
-	        if (match && matchLen)
-	          return {from: Pos(pos.line, start),
-	                  to: Pos(pos.line, start + matchLen),
-	                  match: match};
-	      };
-	    } else { // String query
-	      var origQuery = query;
-	      if (caseFold) query = query.toLowerCase();
-	      var fold = caseFold ? function(str){return str.toLowerCase();} : function(str){return str;};
-	      var target = query.split("\n");
-	      // Different methods for single-line and multi-line queries
-	      if (target.length == 1) {
-	        if (!query.length) {
-	          // Empty string would match anything and never progress, so
-	          // we define it to match nothing instead.
-	          this.matches = function() {};
-	        } else {
-	          this.matches = function(reverse, pos) {
-	            if (reverse) {
-	              var orig = doc.getLine(pos.line).slice(0, pos.ch), line = fold(orig);
-	              var match = line.lastIndexOf(query);
-	              if (match > -1) {
-	                match = adjustPos(orig, line, match);
-	                return {from: Pos(pos.line, match), to: Pos(pos.line, match + origQuery.length)};
-	              }
-	             } else {
-	               var orig = doc.getLine(pos.line).slice(pos.ch), line = fold(orig);
-	               var match = line.indexOf(query);
-	               if (match > -1) {
-	                 match = adjustPos(orig, line, match) + pos.ch;
-	                 return {from: Pos(pos.line, match), to: Pos(pos.line, match + origQuery.length)};
-	               }
-	            }
-	          };
-	        }
-	      } else {
-	        var origTarget = origQuery.split("\n");
-	        this.matches = function(reverse, pos) {
-	          var last = target.length - 1;
-	          if (reverse) {
-	            if (pos.line - (target.length - 1) < doc.firstLine()) return;
-	            if (fold(doc.getLine(pos.line).slice(0, origTarget[last].length)) != target[target.length - 1]) return;
-	            var to = Pos(pos.line, origTarget[last].length);
-	            for (var ln = pos.line - 1, i = last - 1; i >= 1; --i, --ln)
-	              if (target[i] != fold(doc.getLine(ln))) return;
-	            var line = doc.getLine(ln), cut = line.length - origTarget[0].length;
-	            if (fold(line.slice(cut)) != target[0]) return;
-	            return {from: Pos(ln, cut), to: to};
-	          } else {
-	            if (pos.line + (target.length - 1) > doc.lastLine()) return;
-	            var line = doc.getLine(pos.line), cut = line.length - origTarget[0].length;
-	            if (fold(line.slice(cut)) != target[0]) return;
-	            var from = Pos(pos.line, cut);
-	            for (var ln = pos.line + 1, i = 1; i < last; ++i, ++ln)
-	              if (target[i] != fold(doc.getLine(ln))) return;
-	            if (fold(doc.getLine(ln).slice(0, origTarget[last].length)) != target[last]) return;
-	            return {from: from, to: Pos(ln, origTarget[last].length)};
-	          }
-	        };
-	      }
-	    }
-	  }
-
-	  SearchCursor.prototype = {
-	    findNext: function() {return this.find(false);},
-	    findPrevious: function() {return this.find(true);},
-
-	    find: function(reverse) {
-	      var self = this, pos = this.doc.clipPos(reverse ? this.pos.from : this.pos.to);
-	      function savePosAndFail(line) {
-	        var pos = Pos(line, 0);
-	        self.pos = {from: pos, to: pos};
-	        self.atOccurrence = false;
-	        return false;
-	      }
-
-	      for (;;) {
-	        if (this.pos = this.matches(reverse, pos)) {
-	          this.atOccurrence = true;
-	          return this.pos.match || true;
-	        }
-	        if (reverse) {
-	          if (!pos.line) return savePosAndFail(0);
-	          pos = Pos(pos.line-1, this.doc.getLine(pos.line-1).length);
-	        }
-	        else {
-	          var maxLine = this.doc.lineCount();
-	          if (pos.line == maxLine - 1) return savePosAndFail(maxLine);
-	          pos = Pos(pos.line + 1, 0);
-	        }
-	      }
-	    },
-
-	    from: function() {if (this.atOccurrence) return this.pos.from;},
-	    to: function() {if (this.atOccurrence) return this.pos.to;},
-
-	    replace: function(newText, origin) {
-	      if (!this.atOccurrence) return;
-	      var lines = CodeMirror.splitLines(newText);
-	      this.doc.replaceRange(lines, this.pos.from, this.pos.to, origin);
-	      this.pos.to = Pos(this.pos.from.line + lines.length - 1,
-	                        lines[lines.length - 1].length + (lines.length == 1 ? this.pos.from.ch : 0));
-	    }
-	  };
-
-	  // Maps a position in a case-folded line back to a position in the original line
-	  // (compensating for codepoints increasing in number during folding)
-	  function adjustPos(orig, folded, pos) {
-	    if (orig.length == folded.length) return pos;
-	    for (var pos1 = Math.min(pos, orig.length);;) {
-	      var len1 = orig.slice(0, pos1).toLowerCase().length;
-	      if (len1 < pos) ++pos1;
-	      else if (len1 > pos) --pos1;
-	      else return pos1;
-	    }
-	  }
-
-	  CodeMirror.defineExtension("getSearchCursor", function(query, pos, caseFold) {
-	    return new SearchCursor(this.doc, query, pos, caseFold);
-	  });
-	  CodeMirror.defineDocExtension("getSearchCursor", function(query, pos, caseFold) {
-	    return new SearchCursor(this, query, pos, caseFold);
-	  });
-
-	  CodeMirror.defineExtension("selectMatches", function(query, caseFold) {
-	    var ranges = [];
-	    var cur = this.getSearchCursor(query, this.getCursor("from"), caseFold);
-	    while (cur.findNext()) {
-	      if (CodeMirror.cmpPos(cur.to(), this.getCursor("to")) > 0) break;
-	      ranges.push({anchor: cur.from(), head: cur.to()});
-	    }
-	    if (ranges.length)
-	      this.setSelections(ranges, 0);
-	  });
-	});
-
-
-/***/ },
-/* 278 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	var _codemirror = __webpack_require__(267);
-
-	var _codemirror2 = _interopRequireDefault(_codemirror);
-
-	var _getHintsAtPosition = __webpack_require__(279);
-
-	var _getHintsAtPosition2 = _interopRequireDefault(_getHintsAtPosition);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 * Registers a "hint" helper for CodeMirror.
-	 *
-	 * Using CodeMirror's "hint" addon: https://codemirror.net/demo/complete.html
-	 * Given an editor, this helper will take the token at the cursor and return a
-	 * list of suggested tokens.
-	 *
-	 * Options:
-	 *
-	 *   - schema: GraphQLSchema provides the hinter with positionally relevant info
-	 *
-	 * Additional Events:
-	 *
-	 *   - hasCompletion (codemirror, data, token) - signaled when the hinter has a
-	 *     new list of completion suggestions.
-	 *
-	 */
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	_codemirror2.default.registerHelper('hint', 'graphql', function (editor, options) {
-	  var schema = options.schema;
-	  if (!schema) {
-	    return;
-	  }
-
-	  var cur = editor.getCursor();
-	  var token = editor.getTokenAt(cur);
-	  var results = (0, _getHintsAtPosition2.default)(schema, editor.getValue(), cur, token);
-	  if (results && results.list && results.list.length > 0) {
-	    results.from = _codemirror2.default.Pos(results.from.line, results.from.column);
-	    results.to = _codemirror2.default.Pos(results.to.line, results.to.column);
-	    _codemirror2.default.signal(editor, 'hasCompletion', editor, results, token);
-	  }
-
-	  return results;
-	});
-
-/***/ },
-/* 279 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.default = getHintsAtPosition;
-
-	var _graphql = __webpack_require__(185);
-
-	var _introspection = __webpack_require__(208);
-
-	var _forEachState = __webpack_require__(280);
-
-	var _forEachState2 = _interopRequireDefault(_forEachState);
-
-	var _hintList = __webpack_require__(281);
-
-	var _hintList2 = _interopRequireDefault(_hintList);
-
-	var _objectValues = __webpack_require__(282);
-
-	var _objectValues2 = _interopRequireDefault(_objectValues);
-
-	var _runParser = __webpack_require__(283);
-
-	var _runParser2 = _interopRequireDefault(_runParser);
-
-	var _Rules = __webpack_require__(286);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 * Given GraphQLSchema, sourceText, and context of the current position within
-	 * the source text, provide a list of typeahead entries.
-	 *
-	 * Options:
-	 *   - schema: GraphQLSchema
-	 *   - sourceText: string. A raw source text used to get fragmentDefinitions
-	 *                 in a source.
-	 *   - cursor: { line: Number, column: Number }. A current cursor position.
-	 *   - token: ContextToken. Includes a context for the current cursor position.
-	 *     Includes the token string/style (type), the start/end position, and the
-	 *     state at the end of the token.
-	 *
-	 */
-
-	function getHintsAtPosition(schema, sourceText, cursor, token) {
-	  var typeInfo = getTypeInfo(schema, token.state);
-	  var state = token.state;
-	  var kind = state.kind;
-	  var step = state.step;
-
-	  if (token.type === 'comment') {
-	    return;
-	  }
-
-	  // Definition kinds
-	  if (kind === 'Document') {
-	    return (0, _hintList2.default)(cursor, token, [{ text: 'query' }, { text: 'mutation' }, { text: 'subscription' }, { text: 'fragment' }, { text: '{' }]);
-	  }
-
-	  // Field names
-	  if (kind === 'SelectionSet' || kind === 'Field' || kind === 'AliasedField') {
-	    if (typeInfo.parentType) {
-	      var fields = typeInfo.parentType.getFields ? (0, _objectValues2.default)(typeInfo.parentType.getFields()) : [];
-	      if ((0, _graphql.isAbstractType)(typeInfo.parentType)) {
-	        fields.push(_introspection.TypeNameMetaFieldDef);
-	      }
-	      if (typeInfo.parentType === schema.getQueryType()) {
-	        fields.push(_introspection.SchemaMetaFieldDef, _introspection.TypeMetaFieldDef);
-	      }
-	      return (0, _hintList2.default)(cursor, token, fields.map(function (field) {
-	        return {
-	          text: field.name,
-	          type: field.type,
-	          description: field.description
-	        };
-	      }));
-	    }
-	  }
-
-	  // Argument names
-	  if (kind === 'Arguments' || kind === 'Argument' && step === 0) {
-	    var argDefs = typeInfo.argDefs;
-	    if (argDefs) {
-	      return (0, _hintList2.default)(cursor, token, argDefs.map(function (argDef) {
-	        return {
-	          text: argDef.name,
-	          type: argDef.type,
-	          description: argDef.description
-	        };
-	      }));
-	    }
-	  }
-
-	  // Input Object fields
-	  if (kind === 'ObjectValue' || kind === 'ObjectField' && step === 0) {
-	    if (typeInfo.objectFieldDefs) {
-	      var objectFields = (0, _objectValues2.default)(typeInfo.objectFieldDefs);
-	      return (0, _hintList2.default)(cursor, token, objectFields.map(function (field) {
-	        return {
-	          text: field.name,
-	          type: field.type,
-	          description: field.description
-	        };
-	      }));
-	    }
-	  }
-
-	  // Input values: Enum and Boolean
-	  if (kind === 'EnumValue' || kind === 'ListValue' && step === 1 || kind === 'ObjectField' && step === 2 || kind === 'Argument' && step === 2) {
-	    var _ret = function () {
-	      var namedInputType = (0, _graphql.getNamedType)(typeInfo.inputType);
-	      if (namedInputType instanceof _graphql.GraphQLEnumType) {
-	        var valueMap = namedInputType.getValues();
-	        var values = (0, _objectValues2.default)(valueMap);
-	        return {
-	          v: (0, _hintList2.default)(cursor, token, values.map(function (value) {
-	            return {
-	              text: value.name,
-	              type: namedInputType,
-	              description: value.description
-	            };
-	          }))
-	        };
-	      } else if (namedInputType === _graphql.GraphQLBoolean) {
-	        return {
-	          v: (0, _hintList2.default)(cursor, token, [{ text: 'true', type: _graphql.GraphQLBoolean, description: 'Not false.' }, { text: 'false', type: _graphql.GraphQLBoolean, description: 'Not true.' }])
-	        };
-	      }
-	    }();
-
-	    if (typeof _ret === "object") return _ret.v;
-	  }
-
-	  // Fragment type conditions
-	  if (kind === 'TypeCondition' && step === 1 || kind === 'NamedType' && state.prevState.kind === 'TypeCondition') {
-	    var possibleTypes = void 0;
-	    if (typeInfo.parentType) {
-	      if ((0, _graphql.isAbstractType)(typeInfo.parentType)) {
-	        (function () {
-	          // Collect both the possible Object types as well as the interfaces
-	          // they implement.
-	          var possibleObjTypes = schema.getPossibleTypes(typeInfo.parentType);
-	          var possibleIfaceMap = Object.create(null);
-	          possibleObjTypes.forEach(function (type) {
-	            type.getInterfaces().forEach(function (iface) {
-	              possibleIfaceMap[iface.name] = iface;
-	            });
-	          });
-	          possibleTypes = possibleObjTypes.concat((0, _objectValues2.default)(possibleIfaceMap));
-	        })();
-	      } else {
-	        // The parent type is a non-abstract Object type, so the only possible
-	        // type that can be used is that same type.
-	        possibleTypes = [typeInfo.parentType];
-	      }
-	    } else {
-	      var typeMap = schema.getTypeMap();
-	      possibleTypes = (0, _objectValues2.default)(typeMap).filter(_graphql.isCompositeType);
-	    }
-	    return (0, _hintList2.default)(cursor, token, possibleTypes.map(function (type) {
-	      return {
-	        text: type.name,
-	        description: type.description
-	      };
-	    }));
-	  }
-
-	  // Fragment spread names
-	  if (kind === 'FragmentSpread' && step === 1) {
-	    var _ret3 = function () {
-	      var typeMap = schema.getTypeMap();
-	      var defState = getDefinitionState(token.state);
-	      var fragments = getFragmentDefinitions(sourceText);
-
-	      // Filter down to only the fragments which may exist here.
-	      var relevantFrags = fragments.filter(function (frag) {
-	        return (
-	          // Only include fragments with known types.
-	          typeMap[frag.typeCondition.name.value] &&
-	          // Only include fragments which are not cyclic.
-	          !(defState && defState.kind === 'FragmentDefinition' && defState.name === frag.name.value) &&
-	          // Only include fragments which could possibly be spread here.
-	          (0, _graphql.doTypesOverlap)(schema, typeInfo.parentType, typeMap[frag.typeCondition.name.value])
-	        );
-	      });
-
-	      return {
-	        v: (0, _hintList2.default)(cursor, token, relevantFrags.map(function (frag) {
-	          return {
-	            text: frag.name.value,
-	            type: typeMap[frag.typeCondition.name.value],
-	            description: 'fragment ' + frag.name.value + ' on ' + frag.typeCondition.name.value
-	          };
-	        }))
-	      };
-	    }();
-
-	    if (typeof _ret3 === "object") return _ret3.v;
-	  }
-
-	  // Variable definition types
-	  if (kind === 'VariableDefinition' && step === 2 || kind === 'ListType' && step === 1 || kind === 'NamedType' && (state.prevState.kind === 'VariableDefinition' || state.prevState.kind === 'ListType')) {
-	    var inputTypeMap = schema.getTypeMap();
-	    var inputTypes = (0, _objectValues2.default)(inputTypeMap).filter(_graphql.isInputType);
-	    return (0, _hintList2.default)(cursor, token, inputTypes.map(function (type) {
-	      return {
-	        text: type.name,
-	        description: type.description
-	      };
-	    }));
-	  }
-
-	  // Directive names
-	  if (kind === 'Directive') {
-	    var directives = schema.getDirectives().filter(function (directive) {
-	      return canUseDirective(state.prevState.kind, directive);
-	    });
-	    return (0, _hintList2.default)(cursor, token, directives.map(function (directive) {
-	      return {
-	        text: directive.name,
-	        description: directive.description
-	      };
-	    }));
-	  }
-	} /**
-	   *  Copyright (c) 2015, Facebook, Inc.
-	   *  All rights reserved.
-	   *
-	   *  This source code is licensed under the BSD-style license found in the
-	   *  LICENSE file in the root directory of this source tree. An additional grant
-	   *  of patent rights can be found in the PATENTS file in the same directory.
-	   */
-
-	function canUseDirective(kind, directive) {
-	  var locations = directive.locations;
-	  switch (kind) {
-	    case 'Query':
-	      return locations.indexOf('QUERY') !== -1;
-	    case 'Mutation':
-	      return locations.indexOf('MUTATION') !== -1;
-	    case 'Subscription':
-	      return locations.indexOf('SUBSCRIPTION') !== -1;
-	    case 'Field':
-	    case 'AliasedField':
-	      return locations.indexOf('FIELD') !== -1;
-	    case 'FragmentDefinition':
-	      return locations.indexOf('FRAGMENT_DEFINITION') !== -1;
-	    case 'FragmentSpread':
-	      return locations.indexOf('FRAGMENT_SPREAD') !== -1;
-	    case 'InlineFragment':
-	      return locations.indexOf('INLINE_FRAGMENT') !== -1;
-	  }
-	  return false;
-	}
-
-	// Utility for collecting rich type information given any token's state
-	// from the graphql-mode parser.
-	function getTypeInfo(schema, tokenState) {
-	  var info = {
-	    type: null,
-	    parentType: null,
-	    inputType: null,
-	    directiveDef: null,
-	    fieldDef: null,
-	    argDef: null,
-	    argDefs: null,
-	    objectFieldDefs: null
-	  };
-
-	  (0, _forEachState2.default)(tokenState, function (state) {
-	    switch (state.kind) {
-	      case 'Query':
-	      case 'ShortQuery':
-	        info.type = schema.getQueryType();
-	        break;
-	      case 'Mutation':
-	        info.type = schema.getMutationType();
-	        break;
-	      case 'Subscription':
-	        info.type = schema.getSubscriptionType();
-	        break;
-	      case 'InlineFragment':
-	      case 'FragmentDefinition':
-	        if (state.type) {
-	          info.type = schema.getType(state.type);
-	        }
-	        break;
-	      case 'Field':
-	        info.fieldDef = info.type && state.name ? getFieldDef(schema, info.parentType, state.name) : null;
-	        info.type = info.fieldDef && info.fieldDef.type;
-	        break;
-	      case 'SelectionSet':
-	        info.parentType = (0, _graphql.getNamedType)(info.type);
-	        break;
-	      case 'Directive':
-	        info.directiveDef = state.name && schema.getDirective(state.name);
-	        break;
-	      case 'Arguments':
-	        info.argDefs = state.prevState.kind === 'Field' ? info.fieldDef && info.fieldDef.args : state.prevState.kind === 'Directive' ? info.directiveDef && info.directiveDef.args : state.prevState.kind === 'AliasedField' ? state.prevState.name && getFieldDef(schema, info.parentType, state.prevState.name).args : null;
-	        break;
-	      case 'Argument':
-	        info.argDef = null;
-	        if (info.argDefs) {
-	          for (var i = 0; i < info.argDefs.length; i++) {
-	            if (info.argDefs[i].name === state.name) {
-	              info.argDef = info.argDefs[i];
-	              break;
-	            }
-	          }
-	        }
-	        info.inputType = info.argDef && info.argDef.type;
-	        break;
-	      case 'ListValue':
-	        var nullableType = (0, _graphql.getNullableType)(info.inputType);
-	        info.inputType = nullableType instanceof _graphql.GraphQLList ? nullableType.ofType : null;
-	        break;
-	      case 'ObjectValue':
-	        var objectType = (0, _graphql.getNamedType)(info.inputType);
-	        info.objectFieldDefs = objectType instanceof _graphql.GraphQLInputObjectType ? objectType.getFields() : null;
-	        break;
-	      case 'ObjectField':
-	        var objectField = state.name && info.objectFieldDefs ? info.objectFieldDefs[state.name] : null;
-	        info.inputType = objectField && objectField.type;
-	        break;
-	    }
-	  });
-
-	  return info;
-	}
-
-	// Finds all fragment definition ASTs in a source.
-	function getFragmentDefinitions(sourceText) {
-	  var fragmentDefs = [];
-	  (0, _runParser2.default)(sourceText, {
-	    eatWhitespace: function eatWhitespace(stream) {
-	      return stream.eatWhile(_Rules.isIgnored);
-	    },
-	    LexRules: _Rules.LexRules,
-	    ParseRules: _Rules.ParseRules
-	  }, function (stream, state) {
-	    if (state.kind === 'FragmentDefinition' && state.name && state.type) {
-	      fragmentDefs.push({
-	        kind: 'FragmentDefinition',
-	        name: {
-	          kind: 'Name',
-	          value: state.name
-	        },
-	        typeCondition: {
-	          kind: 'NamedType',
-	          name: {
-	            kind: 'Name',
-	            value: state.type
-	          }
-	        }
-	      });
-	    }
-	  });
-
-	  return fragmentDefs;
-	}
-
-	// Utility for returning the state representing the Definition this token state
-	// is within, if any.
-	function getDefinitionState(tokenState) {
-	  var definitionState = void 0;
-
-	  (0, _forEachState2.default)(tokenState, function (state) {
-	    switch (state.kind) {
-	      case 'Query':
-	      case 'ShortQuery':
-	      case 'Mutation':
-	      case 'Subscription':
-	      case 'FragmentDefinition':
-	        definitionState = state;
-	        break;
-	    }
-	  });
-
-	  return definitionState;
-	}
-
-	// Gets the field definition given a type and field name
-	function getFieldDef(schema, type, fieldName) {
-	  if (fieldName === _introspection.SchemaMetaFieldDef.name && schema.getQueryType() === type) {
-	    return _introspection.SchemaMetaFieldDef;
-	  }
-	  if (fieldName === _introspection.TypeMetaFieldDef.name && schema.getQueryType() === type) {
-	    return _introspection.TypeMetaFieldDef;
-	  }
-	  if (fieldName === _introspection.TypeNameMetaFieldDef.name && (0, _graphql.isCompositeType)(type)) {
-	    return _introspection.TypeNameMetaFieldDef;
-	  }
-	  if (type.getFields) {
-	    return type.getFields()[fieldName];
-	  }
-	}
-
-/***/ },
-/* 280 */
-/***/ function(module, exports) {
-
-	"use strict";
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.default = forEachState;
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	// Utility for iterating through a CodeMirror parse state stack bottom-up.
-	function forEachState(stack, fn) {
-	  var reverseStateStack = [];
-	  var state = stack;
-	  while (state && state.kind) {
-	    reverseStateStack.push(state);
-	    state = state.prevState;
-	  }
-	  for (var i = reverseStateStack.length - 1; i >= 0; i--) {
-	    fn(reverseStateStack[i]);
-	  }
-	}
-
-/***/ },
-/* 281 */
-/***/ function(module, exports) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.default = hintList;
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	// Create the expected hint response given a possible list and a token
-	function hintList(cursor, token, list) {
-	  var hints = filterAndSortList(list, normalizeText(token.string));
-	  if (!hints) {
-	    return;
-	  }
-
-	  var tokenStart = token.type !== null && /"|\w/.test(token.string[0]) ? token.start : token.end;
-
-	  var results = {
-	    list: hints,
-	    from: { line: cursor.line, column: tokenStart },
-	    to: { line: cursor.line, column: token.end }
-	  };
-
-	  return results;
-	}
-
-	// Given a list of hint entries and currently typed text, sort and filter to
-	// provide a concise list.
-	function filterAndSortList(list, text) {
-	  var sorted = !text ? list : list.map(function (entry) {
-	    return {
-	      proximity: getProximity(normalizeText(entry.text), text),
-	      entry: entry
-	    };
-	  }).filter(function (pair) {
-	    return pair.proximity <= 2;
-	  }).sort(function (a, b) {
-	    return a.proximity - b.proximity || a.entry.text.length - b.entry.text.length;
-	  }).map(function (pair) {
-	    return pair.entry;
-	  });
-
-	  return sorted.length > 0 ? sorted : list;
-	}
-
-	function normalizeText(text) {
-	  return text.toLowerCase().replace(/\W/g, '');
-	}
-
-	// Determine a numeric proximity for a suggestion based on current text.
-	function getProximity(suggestion, text) {
-	  // start with lexical distance
-	  var proximity = lexicalDistance(text, suggestion);
-	  if (suggestion.length > text.length) {
-	    // do not penalize long suggestions.
-	    proximity -= suggestion.length - text.length - 1;
-	    // penalize suggestions not starting with this phrase
-	    proximity += suggestion.indexOf(text) === 0 ? 0 : 0.5;
-	  }
-	  return proximity;
-	}
-
-	/**
-	 * Computes the lexical distance between strings A and B.
-	 *
-	 * The "distance" between two strings is given by counting the minimum number
-	 * of edits needed to transform string A into string B. An edit can be an
-	 * insertion, deletion, or substitution of a single character, or a swap of two
-	 * adjacent characters.
-	 *
-	 * This distance can be useful for detecting typos in input or sorting
-	 *
-	 * @param {string} a
-	 * @param {string} b
-	 * @return {int} distance in number of edits
-	 */
-	function lexicalDistance(a, b) {
-	  var i = void 0;
-	  var j = void 0;
-	  var d = [];
-	  var aLength = a.length;
-	  var bLength = b.length;
-
-	  for (i = 0; i <= aLength; i++) {
-	    d[i] = [i];
-	  }
-
-	  for (j = 1; j <= bLength; j++) {
-	    d[0][j] = j;
-	  }
-
-	  for (i = 1; i <= aLength; i++) {
-	    for (j = 1; j <= bLength; j++) {
-	      var cost = a[i - 1] === b[j - 1] ? 0 : 1;
-
-	      d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
-
-	      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
-	        d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + cost);
-	      }
-	    }
-	  }
-
-	  return d[aLength][bLength];
-	}
-
-/***/ },
-/* 282 */
-/***/ function(module, exports) {
-
-	"use strict";
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.default = objectValues;
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function objectValues(object) {
-	  var keys = Object.keys(object);
-	  var len = keys.length;
-	  var values = new Array(len);
-	  for (var i = 0; i < len; ++i) {
-	    values[i] = object[keys[i]];
-	  }
-	  return values;
-	}
-
-/***/ },
-/* 283 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.default = runParser;
-
-	var _CharacterStream = __webpack_require__(284);
-
-	var _CharacterStream2 = _interopRequireDefault(_CharacterStream);
-
-	var _onlineParser = __webpack_require__(285);
-
-	var _onlineParser2 = _interopRequireDefault(_onlineParser);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function runParser(sourceText, parserOptions, callbackFn) {
-	  var parser = (0, _onlineParser2.default)(parserOptions);
-	  var state = parser.startState();
-	  var lines = sourceText.split('\n');
-
-	  lines.forEach(function (line) {
-	    var stream = new _CharacterStream2.default(line);
-	    while (!stream.eol()) {
-	      var style = parser.token(stream, state);
-	      callbackFn(stream, state, style);
-	    }
-	  });
-	}
-
-/***/ },
-/* 284 */
-/***/ function(module, exports) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	/**
-	 * CharacterStream implements a stream of character tokens given a source text.
-	 * The API design follows that of CodeMirror.StringStream.
-	 *
-	 * Required:
-	 *
-	 *      sourceText: (string), A raw GraphQL source text. Works best if a line
-	 *        is supplied.
-	 *
-	 */
-
-	var CharacterStream = function () {
-	  function CharacterStream(sourceText) {
-	    _classCallCheck(this, CharacterStream);
-
-	    this._start = 0;
-	    this._pos = 0;
-	    this._sourceText = sourceText;
-	  }
-
-	  CharacterStream.prototype.getStartOfToken = function getStartOfToken() {
-	    return this._start;
-	  };
-
-	  CharacterStream.prototype.getCurrentPosition = function getCurrentPosition() {
-	    return this._pos;
-	  };
-
-	  CharacterStream.prototype._testNextCharacter = function _testNextCharacter(pattern) {
-	    var character = this._sourceText.charAt(this._pos);
-	    return typeof pattern === 'string' ? character === pattern : pattern.test ? pattern.test(character) : pattern(character);
-	  };
-
-	  CharacterStream.prototype.eol = function eol() {
-	    return this._sourceText.length === this._pos;
-	  };
-
-	  CharacterStream.prototype.sol = function sol() {
-	    return this._pos === 0;
-	  };
-
-	  CharacterStream.prototype.peek = function peek() {
-	    return this._sourceText.charAt(this._pos) ? this._sourceText.charAt(this._pos) : null;
-	  };
-
-	  CharacterStream.prototype.next = function next() {
-	    var char = this._sourceText.charAt(this._pos);
-	    this._pos++;
-	    return char;
-	  };
-
-	  CharacterStream.prototype.eat = function eat(pattern) {
-	    var isMatched = this._testNextCharacter(pattern);
-	    if (isMatched) {
-	      this._start = this._pos;
-	      this._pos++;
-	      return this._sourceText.charAt(this._pos - 1);
-	    }
-	    return undefined;
-	  };
-
-	  CharacterStream.prototype.eatWhile = function eatWhile(match) {
-	    var isMatched = this._testNextCharacter(match);
-	    var didEat = false;
-
-	    // If a match, treat the total upcoming matches as one token
-	    if (isMatched) {
-	      didEat = isMatched;
-	      this._start = this._pos;
-	    }
-
-	    while (isMatched) {
-	      this._pos++;
-	      isMatched = this._testNextCharacter(match);
-	      didEat = true;
-	    }
-
-	    return didEat;
-	  };
-
-	  CharacterStream.prototype.eatSpace = function eatSpace() {
-	    return this.eatWhile(/[\s\u00a0]/);
-	  };
-
-	  CharacterStream.prototype.skipToEnd = function skipToEnd() {
-	    this._pos = this._sourceText.length;
-	  };
-
-	  CharacterStream.prototype.skipTo = function skipTo(position) {
-	    this._pos = position;
-	  };
-
-	  CharacterStream.prototype.match = function match(pattern) {
-	    var consume = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-	    var caseFold = arguments[2];
-
-	    var token = null;
-	    var match = null;
-
-	    switch (typeof pattern) {
-	      case 'string':
-	        var regex = new RegExp(pattern, caseFold ? 'i' : '');
-	        match = regex.test(this._sourceText.substr(this._pos, pattern.length));
-	        token = pattern;
-	        break;
-	      case 'object': // RegExp
-	      case 'function':
-	        match = this._sourceText.slice(this._pos).match(pattern);
-	        token = match && match[0];
-	        break;
-	    }
-
-	    if (match && (typeof pattern === 'string' || match.index === 0)) {
-	      if (consume) {
-	        this._start = this._pos;
-	        this._pos += token.length;
-	      }
-	      return match;
-	    }
-
-	    // No match available.
-	    return false;
-	  };
-
-	  CharacterStream.prototype.backUp = function backUp(num) {
-	    this._pos -= num;
-	  };
-
-	  CharacterStream.prototype.column = function column() {
-	    return this._pos;
-	  };
-
-	  CharacterStream.prototype.indentation = function indentation() {
-	    var match = this._sourceText.match(/\s*/);
-	    var indent = 0;
-	    if (match && match.index === 0) {
-	      var whitespaces = match[0];
-	      var pos = 0;
-	      while (whitespaces.length > pos) {
-	        if (whitespaces.charCodeAt(pos) === 9) {
-	          indent += 2;
-	        } else {
-	          indent++;
-	        }
-	        pos++;
-	      }
-	    }
-
-	    return indent;
-	  };
-
-	  CharacterStream.prototype.current = function current() {
-	    return this._sourceText.slice(this._start, this._pos);
-	  };
-
-	  return CharacterStream;
-	}();
-
-	exports.default = CharacterStream;
-
-/***/ },
-/* 285 */
-/***/ function(module, exports) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.default = onlineParser;
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	/**
-	 * Builds an online immutable parser, designed to be used as part of a syntax
-	 * highlighting and code intelligence tools.
-	 *
-	 * Options:
-	 *
-	 *     eatWhitespace: (
-	 *       stream: Stream | CodeMirror.StringStream | CharacterStream
-	 *     ) => boolean
-	 *       Use CodeMirror API.
-	 *
-	 *     LexRules: { [name: string]: RegExp }, Includes `Punctuation`.
-	 *
-	 *     ParseRules: { [name: string]: Array<Rule> }, Includes `Document`.
-	 *
-	 *     editorConfig: { [name: string]: mixed }, Provides an editor-specific
-	 *       configurations set.
-	 *
-	 */
-
-	function onlineParser(options) {
-	  return {
-	    startState: function startState() {
-	      var initialState = { level: 0 };
-	      pushRule(options.ParseRules, initialState, 'Document');
-	      return initialState;
-	    },
-	    token: function token(stream, state) {
-	      return getToken(stream, state, options);
-	    }
-	  };
-	}
-
-	function getToken(stream, state, options) {
-	  var LexRules = options.LexRules,
-	      ParseRules = options.ParseRules,
-	      eatWhitespace = options.eatWhitespace,
-	      editorConfig = options.editorConfig;
-
-	  if (state.needsAdvance) {
-	    state.needsAdvance = false;
-	    advanceRule(state, true);
-	  }
-
-	  // Remember initial indentation
-	  if (stream.sol()) {
-	    var tabSize = editorConfig && editorConfig.tabSize || 2;
-	    state.indentLevel = Math.floor(stream.indentation() / tabSize);
-	  }
-
-	  // Consume spaces and ignored characters
-	  if (eatWhitespace(stream)) {
-	    return 'ws';
-	  }
-
-	  // Peek a character forward and skip the entire line if it's a comment line
-	  if (stream.peek() === '#') {
-	    stream.skipToEnd();
-	    return 'comment';
-	  }
-
-	  // Get a matched token from the stream, using lex
-	  var token = lex(LexRules, stream);
-
-	  // If there's no matching token, skip ahead.
-	  if (!token) {
-	    stream.match(/\S+/);
-	    return 'invalidchar';
-	  }
-
-	  // Save state before continuing.
-	  saveState(state);
-
-	  // Handle changes in expected indentation level
-	  if (token.kind === 'Punctuation') {
-	    if (/^[{([]/.test(token.value)) {
-	      // Push on the stack of levels one level deeper than the current level.
-	      state.levels = (state.levels || []).concat(state.indentLevel + 1);
-	    } else if (/^[})\]]/.test(token.value)) {
-	      // Pop from the stack of levels.
-	      // If the top of the stack is lower than the current level, lower the
-	      // current level to match.
-	      var levels = state.levels = (state.levels || []).slice(0, -1);
-	      if (levels.length > 0 && levels[levels.length - 1] < state.indentLevel) {
-	        state.indentLevel = levels[levels.length - 1];
-	      }
-	    }
-	  }
-
-	  while (state.rule) {
-	    // If this is a forking rule, determine what rule to use based on
-	    // the current token, otherwise expect based on the current step.
-	    var expected = typeof state.rule === 'function' ? state.step === 0 ? state.rule(token, stream) : null : state.rule[state.step];
-
-	    // Seperator between list elements if necessary.
-	    if (state.needsSeperator) {
-	      expected = expected && expected.separator;
-	    }
-
-	    if (expected) {
-	      // Un-wrap optional/list ParseRules.
-	      if (expected.ofRule) {
-	        expected = expected.ofRule;
-	      }
-
-	      // A string represents a Rule
-	      if (typeof expected === 'string') {
-	        pushRule(ParseRules, state, expected);
-	        continue;
-	      }
-
-	      // Otherwise, match a Terminal.
-	      if (expected.match && expected.match(token)) {
-	        if (expected.update) {
-	          expected.update(state, token);
-	        }
-
-	        // If this token was a punctuator, advance the parse rule, otherwise
-	        // mark the state to be advanced before the next token. This ensures
-	        // that tokens which can be appended to keep the appropriate state.
-	        if (token.kind === 'Punctuation') {
-	          advanceRule(state, true);
-	        } else {
-	          state.needsAdvance = true;
-	        }
-
-	        return expected.style;
-	      }
-	    }
-
-	    unsuccessful(state);
-	  }
-
-	  // The parser does not know how to interpret this token, do not affect state.
-	  restoreState(state);
-	  return 'invalidchar';
-	}
-
-	function assign(to, from) {
-	  var keys = Object.keys(from);
-	  for (var i = 0; i < keys.length; i++) {
-	    to[keys[i]] = from[keys[i]];
-	  }
-	  return to;
-	}
-
-	var stateCache = {};
-
-	// Save the current state in the cache.
-	function saveState(state) {
-	  assign(stateCache, state);
-	}
-
-	// Restore from the state cache.
-	function restoreState(state) {
-	  assign(state, stateCache);
-	}
-
-	// Push a new rule onto the state.
-	function pushRule(ParseRules, state, ruleKind) {
-	  if (!ParseRules[ruleKind]) {
-	    throw new TypeError('Unknown rule: ' + ruleKind);
-	  }
-	  state.prevState = assign({}, state);
-	  state.kind = ruleKind;
-	  state.name = null;
-	  state.type = null;
-	  state.rule = ParseRules[ruleKind];
-	  state.step = 0;
-	  state.needsSeperator = false;
-	}
-
-	// Pop the current rule from the state.
-	function popRule(state) {
-	  state.kind = state.prevState.kind;
-	  state.name = state.prevState.name;
-	  state.type = state.prevState.type;
-	  state.rule = state.prevState.rule;
-	  state.step = state.prevState.step;
-	  state.needsSeperator = state.prevState.needsSeperator;
-	  state.prevState = state.prevState.prevState;
-	}
-
-	// Advance the step of the current rule.
-	function advanceRule(state, successful) {
-	  // If this is advancing successfully and the current state is a list, give
-	  // it an opportunity to repeat itself.
-	  if (isList(state)) {
-	    if (state.rule[state.step].separator) {
-	      state.needsSeperator = !state.needsSeperator;
-	      // If the next list iteration might accept a non-separator, then give it
-	      // an opportunity to repeat.
-	      if (!state.needsSeperator) {
-	        return;
-	      }
-	    }
-	    // If this was a successful list parse, then allow it to repeat itself.
-	    if (successful) {
-	      return;
-	    }
-	  }
-
-	  // Advance the step in the rule. If the rule is completed, pop
-	  // the rule and advance the parent rule as well (recursively).
-	  state.needsSeperator = false;
-	  state.step++;
-	  // While the current rule is completed.
-	  while (state.rule && !(Array.isArray(state.rule) && state.step < state.rule.length)) {
-	    popRule(state);
-
-	    if (state.rule) {
-	      // Do not advance a List step so it has the opportunity to repeat itself.
-	      if (isList(state)) {
-	        if (state.rule[state.step].separator) {
-	          state.needsSeperator = !state.needsSeperator;
-	        }
-	      } else {
-	        state.needsSeperator = false;
-	        state.step++;
-	      }
-	    }
-	  }
-	}
-
-	function isList(state) {
-	  return Array.isArray(state.rule) && state.rule[state.step].isList;
-	}
-
-	// Unwind the state after an unsuccessful match.
-	function unsuccessful(state) {
-	  // Fall back to the parent rule until you get to an optional or list rule or
-	  // until the entire stack of rules is empty.
-	  while (state.rule && !(Array.isArray(state.rule) && state.rule[state.step].ofRule)) {
-	    popRule(state);
-	  }
-
-	  // If there is still a rule, it must be an optional or list rule.
-	  // Consider this rule a success so that we may move past it.
-	  if (state.rule) {
-	    advanceRule(state, false);
-	  }
-	}
-
-	// Given a stream, returns a { kind, value } pair, or null.
-	function lex(LexRules, stream) {
-	  var kinds = Object.keys(LexRules);
-	  for (var i = 0; i < kinds.length; i++) {
-	    var match = stream.match(LexRules[kinds[i]]);
-	    if (match) {
-	      return { kind: kinds[i], value: match[0] };
-	    }
-	  }
-	}
-
-/***/ },
-/* 286 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.ParseRules = exports.LexRules = exports.isIgnored = undefined;
-
-	var _RuleHelpers = __webpack_require__(287);
-
-	/**
-	 * Whitespace tokens defined in GraphQL spec.
-	 */
-	var isIgnored = exports.isIgnored = function isIgnored(ch) {
-	  return ch === ' ' || ch === '\t' || ch === ',' || ch === '\n' || ch === '\r' || ch === '\uFEFF';
-	};
-
-	/**
-	 * The lexer rules. These are exactly as described by the spec.
-	 */
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	var LexRules = exports.LexRules = {
-	  // The Name token.
-	  Name: /^[_A-Za-z][_0-9A-Za-z]*/,
-
-	  // All Punctuation used in GraphQL
-	  Punctuation: /^(?:!|\$|\(|\)|\.\.\.|:|=|@|\[|]|\{|\||\})/,
-
-	  // Combines the IntValue and FloatValue tokens.
-	  Number: /^-?(?:0|(?:[1-9][0-9]*))(?:\.[0-9]*)?(?:[eE][+-]?[0-9]+)?/,
-
-	  // Note the closing quote is made optional as an IDE experience improvment.
-	  String: /^"(?:[^"\\]|\\(?:"|\/|\\|b|f|n|r|t|u[0-9a-fA-F]{4}))*"?/
-	};
-
-	/**
-	 * The parser rules. These are very close to, but not exactly the same as the
-	 * spec. Minor deviations allow for a simpler implementation. The resulting
-	 * parser can parse everything the spec declares possible.
-	 */
-	var ParseRules = exports.ParseRules = {
-	  Document: [(0, _RuleHelpers.list)('Definition')],
-	  Definition: function Definition(token) {
-	    switch (token.value) {
-	      case '{':
-	        return 'ShortQuery';
-	      case 'query':
-	        return 'Query';
-	      case 'mutation':
-	        return 'Mutation';
-	      case 'subscription':
-	        return 'Subscription';
-	      case 'fragment':
-	        return 'FragmentDefinition';
-	      case 'schema':
-	        return 'SchemaDef';
-	      case 'scalar':
-	        return 'ScalarDef';
-	      case 'type':
-	        return 'ObjectTypeDef';
-	      case 'interface':
-	        return 'InterfaceDef';
-	      case 'union':
-	        return 'UnionDef';
-	      case 'enum':
-	        return 'EnumDef';
-	      case 'input':
-	        return 'InputDef';
-	      case 'extend':
-	        return 'ExtendDef';
-	      case 'directive':
-	        return 'DirectiveDef';
-	    }
-	  },
-
-	  // Note: instead of "Operation", these rules have been separated out.
-	  ShortQuery: ['SelectionSet'],
-	  Query: [word('query'), (0, _RuleHelpers.opt)(name('def')), (0, _RuleHelpers.opt)('VariableDefinitions'), (0, _RuleHelpers.list)('Directive'), 'SelectionSet'],
-	  Mutation: [word('mutation'), (0, _RuleHelpers.opt)(name('def')), (0, _RuleHelpers.opt)('VariableDefinitions'), (0, _RuleHelpers.list)('Directive'), 'SelectionSet'],
-	  Subscription: [word('subscription'), (0, _RuleHelpers.opt)(name('def')), (0, _RuleHelpers.opt)('VariableDefinitions'), (0, _RuleHelpers.list)('Directive'), 'SelectionSet'],
-	  VariableDefinitions: [(0, _RuleHelpers.p)('('), (0, _RuleHelpers.list)('VariableDefinition'), (0, _RuleHelpers.p)(')')],
-	  VariableDefinition: ['Variable', (0, _RuleHelpers.p)(':'), 'Type', (0, _RuleHelpers.opt)('DefaultValue')],
-	  Variable: [(0, _RuleHelpers.p)('$', 'variable'), name('variable')],
-	  DefaultValue: [(0, _RuleHelpers.p)('='), 'Value'],
-	  SelectionSet: [(0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('Selection'), (0, _RuleHelpers.p)('}')],
-	  Selection: function Selection(token, stream) {
-	    return token.value === '...' ? stream.match(/[\s\u00a0,]*(on\b|@|{)/, false) ? 'InlineFragment' : 'FragmentSpread' : stream.match(/[\s\u00a0,]*:/, false) ? 'AliasedField' : 'Field';
-	  },
-
-	  // Note: this minor deviation of "AliasedField" simplifies the lookahead.
-	  AliasedField: [name('property'), (0, _RuleHelpers.p)(':'), name('qualifier'), (0, _RuleHelpers.opt)('Arguments'), (0, _RuleHelpers.list)('Directive'), (0, _RuleHelpers.opt)('SelectionSet')],
-	  Field: [name('property'), (0, _RuleHelpers.opt)('Arguments'), (0, _RuleHelpers.list)('Directive'), (0, _RuleHelpers.opt)('SelectionSet')],
-	  Arguments: [(0, _RuleHelpers.p)('('), (0, _RuleHelpers.list)('Argument'), (0, _RuleHelpers.p)(')')],
-	  Argument: [name('attribute'), (0, _RuleHelpers.p)(':'), 'Value'],
-	  FragmentSpread: [(0, _RuleHelpers.p)('...'), name('def'), (0, _RuleHelpers.list)('Directive')],
-	  InlineFragment: [(0, _RuleHelpers.p)('...'), (0, _RuleHelpers.opt)('TypeCondition'), (0, _RuleHelpers.list)('Directive'), 'SelectionSet'],
-	  FragmentDefinition: [word('fragment'), (0, _RuleHelpers.opt)((0, _RuleHelpers.butNot)(name('def'), [word('on')])), 'TypeCondition', (0, _RuleHelpers.list)('Directive'), 'SelectionSet'],
-	  TypeCondition: [word('on'), type('atom')],
-	  // Variables could be parsed in cases where only Const is expected by spec.
-	  Value: function Value(token) {
-	    switch (token.kind) {
-	      case 'Number':
-	        return 'NumberValue';
-	      case 'String':
-	        return 'StringValue';
-	      case 'Punctuation':
-	        switch (token.value) {
-	          case '[':
-	            return 'ListValue';
-	          case '{':
-	            return 'ObjectValue';
-	          case '$':
-	            return 'Variable';
-	        }
-	        return null;
-	      case 'Name':
-	        switch (token.value) {
-	          case 'true':case 'false':
-	            return 'BooleanValue';
-	        }
-	        if (token.value === 'null') {
-	          return 'NullValue';
-	        }
-	        return 'EnumValue';
-	    }
-	  },
-
-	  NumberValue: [(0, _RuleHelpers.t)('Number', 'number')],
-	  StringValue: [(0, _RuleHelpers.t)('String', 'string')],
-	  BooleanValue: [(0, _RuleHelpers.t)('Name', 'builtin')],
-	  NullValue: [(0, _RuleHelpers.t)('Name', 'keyword')],
-	  EnumValue: [name('string-2')],
-	  ListValue: [(0, _RuleHelpers.p)('['), (0, _RuleHelpers.list)('Value'), (0, _RuleHelpers.p)(']')],
-	  ObjectValue: [(0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('ObjectField'), (0, _RuleHelpers.p)('}')],
-	  ObjectField: [name('attribute'), (0, _RuleHelpers.p)(':'), 'Value'],
-	  Type: function Type(token) {
-	    return token.value === '[' ? 'ListType' : 'NamedType';
-	  },
-
-	  // NonNullType has been merged into ListType and NamedType to simplify.
-	  ListType: [(0, _RuleHelpers.p)('['), 'Type', (0, _RuleHelpers.p)(']'), (0, _RuleHelpers.opt)((0, _RuleHelpers.p)('!'))],
-	  NamedType: [name('atom'), (0, _RuleHelpers.opt)((0, _RuleHelpers.p)('!'))],
-	  Directive: [(0, _RuleHelpers.p)('@', 'meta'), name('meta'), (0, _RuleHelpers.opt)('Arguments')],
-	  // GraphQL schema language
-	  SchemaDef: [word('schema'), (0, _RuleHelpers.list)('Directive'), (0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('OperationTypeDef'), (0, _RuleHelpers.p)('}')],
-	  OperationTypeDef: [name('keyword'), (0, _RuleHelpers.p)(':'), name('atom')],
-	  ScalarDef: [word('scalar'), name('atom'), (0, _RuleHelpers.list)('Directive')],
-	  ObjectTypeDef: [word('type'), name('atom'), (0, _RuleHelpers.opt)('Implements'), (0, _RuleHelpers.list)('Directive'), (0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('FieldDef'), (0, _RuleHelpers.p)('}')],
-	  Implements: [word('implements'), (0, _RuleHelpers.list)(name('atom'))],
-	  FieldDef: [name('property'), (0, _RuleHelpers.opt)('ArgumentsDef'), (0, _RuleHelpers.p)(':'), 'Type', (0, _RuleHelpers.list)('Directive')],
-	  ArgumentsDef: [(0, _RuleHelpers.p)('('), (0, _RuleHelpers.list)('InputValueDef'), (0, _RuleHelpers.p)(')')],
-	  InputValueDef: [name('attribute'), (0, _RuleHelpers.p)(':'), 'Type', (0, _RuleHelpers.opt)('DefaultValue'), (0, _RuleHelpers.list)('Directive')],
-	  InterfaceDef: [word('interface'), name('atom'), (0, _RuleHelpers.list)('Directive'), (0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('FieldDef'), (0, _RuleHelpers.p)('}')],
-	  UnionDef: [word('union'), name('atom'), (0, _RuleHelpers.list)('Directive'), (0, _RuleHelpers.p)('='), name('atom'), (0, _RuleHelpers.list)('UnionMember')],
-	  UnionMember: [(0, _RuleHelpers.p)('|'), name('atom')],
-	  EnumDef: [word('enum'), name('atom'), (0, _RuleHelpers.list)('Directive'), (0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('EnumValueDef'), (0, _RuleHelpers.p)('}')],
-	  EnumValueDef: [name('string-2'), (0, _RuleHelpers.list)('Directive')],
-	  InputDef: [word('input'), name('atom'), (0, _RuleHelpers.list)('Directive'), (0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('InputValueDef'), (0, _RuleHelpers.p)('}')],
-	  ExtendDef: [word('extend'), 'ObjectTypeDef'],
-	  DirectiveDef: [word('directive'), (0, _RuleHelpers.p)('@', 'meta'), name('meta'), (0, _RuleHelpers.opt)('ArgumentsDef'), word('on'), name('string-2'), (0, _RuleHelpers.list)('DirectiveLocation')],
-	  DirectiveLocation: [(0, _RuleHelpers.p)('|'), name('string-2')]
-	};
-
-	// A keyword Token.
-	function word(value) {
-	  return {
-	    style: 'keyword',
-	    match: function match(token) {
-	      return token.kind === 'Name' && token.value === value;
-	    }
-	  };
-	}
-
-	// A Name Token which will decorate the state with a `name`.
-	function name(style) {
-	  return {
-	    style: style,
-	    match: function match(token) {
-	      return token.kind === 'Name';
-	    },
-	    update: function update(state, token) {
-	      state.name = token.value;
-	    }
-	  };
-	}
-
-	// A Name Token which will decorate the previous state with a `type`.
-	function type(style) {
-	  return {
-	    style: style,
-	    match: function match(token) {
-	      return token.kind === 'Name';
-	    },
-	    update: function update(state, token) {
-	      state.prevState.type = token.value;
-	    }
-	  };
-	}
-
-/***/ },
-/* 287 */
-/***/ function(module, exports) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.opt = opt;
-	exports.list = list;
-	exports.butNot = butNot;
-	exports.t = t;
-	exports.p = p;
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-	// These functions help build matching rules for ParseRules.
-
-	// An optional rule.
-	function opt(ofRule) {
-	  return { ofRule: ofRule };
-	}
-
-	// A list of another rule.
-	function list(ofRule, separator) {
-	  return { ofRule: ofRule, isList: true, separator: separator };
-	}
-
-	// An constraint described as `but not` in the GraphQL spec.
-	function butNot(rule, exclusions) {
-	  var ruleMatch = rule.match;
-	  rule.match = function (token) {
-	    return ruleMatch(token) && exclusions.every(function (exclusion) {
-	      return !exclusion.match(token);
-	    });
-	  };
-	  return rule;
-	}
-
-	// Token of a kind
-	function t(kind, style) {
-	  return { style: style, match: function match(token) {
-	      return token.kind === kind;
-	    } };
-	}
-
-	// Punctuator
-	function p(value, style) {
-	  return {
-	    style: style || 'punctuation',
-	    match: function match(token) {
-	      return token.kind === 'Punctuation' && token.value === value;
-	    }
-	  };
-	}
-
-/***/ },
-/* 288 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	var _codemirror = __webpack_require__(267);
-
-	var _codemirror2 = _interopRequireDefault(_codemirror);
-
-	var _graphql = __webpack_require__(185);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 * Registers a "lint" helper for CodeMirror.
-	 *
-	 * Using CodeMirror's "lint" addon: https://codemirror.net/demo/lint.html
-	 * Given the text within an editor, this helper will take that text and return
-	 * a list of linter issues, derived from GraphQL's parse and validate steps.
-	 *
-	 * Options:
-	 *
-	 *   - schema: GraphQLSchema provides the linter with positionally relevant info
-	 *
-	 */
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	_codemirror2.default.registerHelper('lint', 'graphql', function (text, options, editor) {
-	  var schema = options.schema;
-	  try {
-	    var ast = (0, _graphql.parse)(text);
-	    var errors = schema ? (0, _graphql.validate)(schema, ast) : [];
-	    return mapCat(errors, function (error) {
-	      return errorAnnotations(editor, error);
-	    });
-	  } catch (error) {
-	    var location = error.locations[0];
-	    var pos = _codemirror2.default.Pos(location.line - 1, location.column);
-	    var token = editor.getTokenAt(pos);
-	    return [{
-	      message: error.message,
-	      severity: 'error',
-	      type: 'syntax',
-	      from: _codemirror2.default.Pos(location.line - 1, token.start),
-	      to: _codemirror2.default.Pos(location.line - 1, token.end)
-	    }];
-	  }
-	});
-
-	function errorAnnotations(editor, error) {
-	  return error.nodes.map(function (node) {
-	    var highlightNode = node.kind !== 'Variable' && node.name ? node.name : node.variable ? node.variable : node;
-	    return {
-	      message: error.message,
-	      severity: 'error',
-	      type: 'validation',
-	      from: editor.posFromIndex(highlightNode.loc.start),
-	      to: editor.posFromIndex(highlightNode.loc.end)
-	    };
-	  });
-	}
-
-	// General utility for map-cating (aka flat-mapping).
-	function mapCat(array, mapper) {
-	  return Array.prototype.concat.apply([], array.map(mapper));
-	}
-
-/***/ },
-/* 289 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	var _codemirror = __webpack_require__(267);
-
-	var _codemirror2 = _interopRequireDefault(_codemirror);
-
-	var _onlineParser = __webpack_require__(285);
-
-	var _onlineParser2 = _interopRequireDefault(_onlineParser);
-
-	var _Rules = __webpack_require__(286);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 * The GraphQL mode is defined as a tokenizer along with a list of rules, each
-	 * of which is either a function or an array.
-	 *
-	 *   * Function: Provided a token and the stream, returns an expected next step.
-	 *   * Array: A list of steps to take in order.
-	 *
-	 * A step is either another rule, or a terminal description of a token. If it
-	 * is a rule, that rule is pushed onto the stack and the parsing continues from
-	 * that point.
-	 *
-	 * If it is a terminal description, the token is checked against it using a
-	 * `match` function. If the match is successful, the token is colored and the
-	 * rule is stepped forward. If the match is unsuccessful, the remainder of the
-	 * rule is skipped and the previous rule is advanced.
-	 *
-	 * This parsing algorithm allows for incremental online parsing within various
-	 * levels of the syntax tree and results in a structured `state` linked-list
-	 * which contains the relevant information to produce valuable typeaheads.
-	 */
-	_codemirror2.default.defineMode('graphql', function (config) {
-	  var parser = (0, _onlineParser2.default)({
-	    eatWhitespace: function eatWhitespace(stream) {
-	      return stream.eatWhile(_Rules.isIgnored);
-	    },
-	    LexRules: _Rules.LexRules,
-	    ParseRules: _Rules.ParseRules,
-	    editorConfig: { tabSize: config.tabSize }
-	  });
-
-	  return {
-	    config: config,
-	    startState: parser.startState,
-	    token: parser.token,
-	    indent: indent,
-	    electricInput: /^\s*[})\]]/,
-	    fold: 'brace',
-	    lineComment: '#',
-	    closeBrackets: {
-	      pairs: '()[]{}""',
-	      explode: '()[]{}'
-	    }
-	  };
-	}); /**
-	     *  Copyright (c) 2015, Facebook, Inc.
-	     *  All rights reserved.
-	     *
-	     *  This source code is licensed under the BSD-style license found in the
-	     *  LICENSE file in the root directory of this source tree. An additional grant
-	     *  of patent rights can be found in the PATENTS file in the same directory.
-	     */
-
-	function indent(state, textAfter) {
-	  var levels = state.levels;
-	  // If there is no stack of levels, use the current level.
-	  // Otherwise, use the top level, pre-emptively dedenting for close braces.
-	  var level = !levels || levels.length === 0 ? state.indentLevel : levels[levels.length - 1] - (this.electricInput.test(textAfter) ? 1 : 0);
-	  return level * this.config.indentUnit;
-	}
-
-/***/ },
-/* 290 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.VariableEditor = undefined;
-
-	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-	var _react = __webpack_require__(1);
-
-	var _react2 = _interopRequireDefault(_react);
-
-	var _reactDom = __webpack_require__(32);
-
-	var _reactDom2 = _interopRequireDefault(_reactDom);
-
-	var _onHasCompletion = __webpack_require__(265);
-
-	var _onHasCompletion2 = _interopRequireDefault(_onHasCompletion);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /**
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  Copyright (c) 2015, Facebook, Inc.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  All rights reserved.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  This source code is licensed under the license found in the
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  LICENSE-examples file in the root directory of this source tree.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
-
-	/**
-	 * VariableEditor
-	 *
-	 * An instance of CodeMirror for editing variables defined in QueryEditor.
-	 *
-	 * Props:
-	 *
-	 *   - variableToType: A mapping of variable name to GraphQLType.
-	 *   - value: The text of the editor.
-	 *   - onEdit: A function called when the editor changes, given the edited text.
-	 *
-	 */
-	var VariableEditor = exports.VariableEditor = function (_React$Component) {
-	  _inherits(VariableEditor, _React$Component);
-
-	  function VariableEditor(props) {
-	    _classCallCheck(this, VariableEditor);
-
-	    // Keep a cached version of the value, this cache will be updated when the
-	    // editor is updated, which can later be used to protect the editor from
-	    // unnecessary updates during the update lifecycle.
-	    var _this = _possibleConstructorReturn(this, (VariableEditor.__proto__ || Object.getPrototypeOf(VariableEditor)).call(this));
-
-	    _this._onKeyUp = function (cm, event) {
-	      var code = event.keyCode;
-	      if (code >= 65 && code <= 90 || // letters
-	      !event.shiftKey && code >= 48 && code <= 57 || // numbers
-	      event.shiftKey && code === 189 || // underscore
-	      event.shiftKey && code === 222 // "
-	      ) {
-	          _this.editor.execCommand('autocomplete');
-	        }
-	    };
-
-	    _this._onEdit = function () {
-	      if (!_this.ignoreChangeEvent) {
-	        _this.cachedValue = _this.editor.getValue();
-	        if (_this.props.onEdit) {
-	          _this.props.onEdit(_this.cachedValue);
-	        }
-	      }
-	    };
-
-	    _this._onHasCompletion = function (cm, data) {
-	      (0, _onHasCompletion2.default)(cm, data, _this.props.onHintInformationRender);
-	    };
-
-	    _this.cachedValue = props.value || '';
-	    return _this;
-	  }
-
-	  _createClass(VariableEditor, [{
-	    key: 'componentDidMount',
-	    value: function componentDidMount() {
-	      var _this2 = this;
-
-	      // Lazily require to ensure requiring GraphiQL outside of a Browser context
-	      // does not produce an error.
-	      var CodeMirror = __webpack_require__(267);
-	      __webpack_require__(268);
-	      __webpack_require__(270);
-	      __webpack_require__(271);
-	      __webpack_require__(274);
-	      __webpack_require__(272);
-	      __webpack_require__(275);
-	      __webpack_require__(276);
-	      __webpack_require__(291);
-	      __webpack_require__(292);
-	      __webpack_require__(294);
-
-	      this.editor = CodeMirror(_reactDom2.default.findDOMNode(this), {
-	        value: this.props.value || '',
-	        lineNumbers: true,
-	        tabSize: 2,
-	        mode: 'graphql-variables',
-	        theme: 'graphiql',
-	        keyMap: 'sublime',
-	        autoCloseBrackets: true,
-	        matchBrackets: true,
-	        showCursorWhenSelecting: true,
-	        foldGutter: {
-	          minFoldSize: 4
-	        },
-	        lint: {
-	          variableToType: this.props.variableToType
-	        },
-	        hintOptions: {
-	          variableToType: this.props.variableToType
-	        },
-	        gutters: ['CodeMirror-linenumbers', 'CodeMirror-foldgutter'],
-	        extraKeys: {
-	          'Cmd-Space': function CmdSpace() {
-	            return _this2.editor.showHint({ completeSingle: false });
-	          },
-	          'Ctrl-Space': function CtrlSpace() {
-	            return _this2.editor.showHint({ completeSingle: false });
-	          },
-	          'Alt-Space': function AltSpace() {
-	            return _this2.editor.showHint({ completeSingle: false });
-	          },
-	          'Shift-Space': function ShiftSpace() {
-	            return _this2.editor.showHint({ completeSingle: false });
-	          },
-
-	          'Cmd-Enter': function CmdEnter() {
-	            if (_this2.props.onRunQuery) {
-	              _this2.props.onRunQuery();
-	            }
-	          },
-	          'Ctrl-Enter': function CtrlEnter() {
-	            if (_this2.props.onRunQuery) {
-	              _this2.props.onRunQuery();
-	            }
-	          },
-
-	          // Editor improvements
-	          'Ctrl-Left': 'goSubwordLeft',
-	          'Ctrl-Right': 'goSubwordRight',
-	          'Alt-Left': 'goGroupLeft',
-	          'Alt-Right': 'goGroupRight'
-	        }
-	      });
-
-	      this.editor.on('change', this._onEdit);
-	      this.editor.on('keyup', this._onKeyUp);
-	      this.editor.on('hasCompletion', this._onHasCompletion);
-	    }
-	  }, {
-	    key: 'componentDidUpdate',
-	    value: function componentDidUpdate(prevProps) {
-	      var CodeMirror = __webpack_require__(267);
-
-	      // Ensure the changes caused by this update are not interpretted as
-	      // user-input changes which could otherwise result in an infinite
-	      // event loop.
-	      this.ignoreChangeEvent = true;
-	      if (this.props.variableToType !== prevProps.variableToType) {
-	        this.editor.options.lint.variableToType = this.props.variableToType;
-	        this.editor.options.hintOptions.variableToType = this.props.variableToType;
-	        CodeMirror.signal(this.editor, 'change', this.editor);
-	      }
-	      if (this.props.value !== prevProps.value && this.props.value !== this.cachedValue) {
-	        this.cachedValue = this.props.value;
-	        this.editor.setValue(this.props.value);
-	      }
-	      this.ignoreChangeEvent = false;
-	    }
-	  }, {
-	    key: 'componentWillUnmount',
-	    value: function componentWillUnmount() {
-	      this.editor.off('change', this._onEdit);
-	      this.editor.off('keyup', this._onKeyUp);
-	      this.editor.off('hasCompletion', this._onHasCompletion);
-	      this.editor = null;
-	    }
-	  }, {
-	    key: 'render',
-	    value: function render() {
-	      return _react2.default.createElement('div', { className: 'codemirrorWrap' });
-	    }
-
-	    /**
-	     * Public API for retrieving the CodeMirror instance from this
-	     * React component.
-	     */
-
-	  }, {
-	    key: 'getCodeMirror',
-	    value: function getCodeMirror() {
-	      return this.editor;
-	    }
-	  }]);
-
-	  return VariableEditor;
-	}(_react2.default.Component);
-
-	VariableEditor.propTypes = {
-	  variableToType: _react.PropTypes.object,
-	  value: _react.PropTypes.string,
-	  onEdit: _react.PropTypes.func,
-	  onHintInformationRender: _react.PropTypes.func,
-	  onRunQuery: _react.PropTypes.func
-	};
-
-/***/ },
-/* 291 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	var _codemirror = __webpack_require__(267);
-
-	var _codemirror2 = _interopRequireDefault(_codemirror);
-
-	var _graphql = __webpack_require__(185);
-
-	var _forEachState = __webpack_require__(280);
-
-	var _forEachState2 = _interopRequireDefault(_forEachState);
-
-	var _hintList = __webpack_require__(281);
-
-	var _hintList2 = _interopRequireDefault(_hintList);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 * Registers a "hint" helper for CodeMirror.
-	 *
-	 * Using CodeMirror's "hint" addon: https://codemirror.net/demo/complete.html
-	 * Given an editor, this helper will take the token at the cursor and return a
-	 * list of suggested tokens.
-	 *
-	 * Options:
-	 *
-	 *   - variableToType: { [variable: string]: GraphQLInputType }
-	 *
-	 * Additional Events:
-	 *
-	 *   - hasCompletion (codemirror, data, token) - signaled when the hinter has a
-	 *     new list of completion suggestions.
-	 *
-	 */
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	_codemirror2.default.registerHelper('hint', 'graphql-variables', function (editor, options) {
-	  var cur = editor.getCursor();
-	  var token = editor.getTokenAt(cur);
-
-	  var results = getVariablesHint(cur, token, options);
-	  if (results && results.list && results.list.length > 0) {
-	    results.from = _codemirror2.default.Pos(results.from.line, results.from.column);
-	    results.to = _codemirror2.default.Pos(results.to.line, results.to.column);
-	    _codemirror2.default.signal(editor, 'hasCompletion', editor, results, token);
-	  }
-
-	  return results;
-	});
-
-	function getVariablesHint(cur, token, options) {
-	  var state = token.state;
-	  var kind = state.kind;
-	  var step = state.step;
-
-	  // Variables can only be an object literal.
-	  if (kind === 'Document' && step === 0) {
-	    return (0, _hintList2.default)(cur, token, [{ text: '{' }]);
-	  }
-
-	  var variableToType = options.variableToType;
-	  if (!variableToType) {
-	    return;
-	  }
-
-	  var typeInfo = getTypeInfo(variableToType, token.state);
-
-	  // Top level should typeahead possible variables.
-	  if (kind === 'Document' || kind === 'Variable' && step === 0) {
-	    var variableNames = Object.keys(variableToType);
-	    return (0, _hintList2.default)(cur, token, variableNames.map(function (name) {
-	      return {
-	        text: '"' + name + '": ',
-	        type: variableToType[name]
-	      };
-	    }));
-	  }
-
-	  // Input Object fields
-	  if (kind === 'ObjectValue' || kind === 'ObjectField' && step === 0) {
-	    if (typeInfo.fields) {
-	      var inputFields = Object.keys(typeInfo.fields).map(function (fieldName) {
-	        return typeInfo.fields[fieldName];
-	      });
-	      return (0, _hintList2.default)(cur, token, inputFields.map(function (field) {
-	        return {
-	          text: '"' + field.name + '": ',
-	          type: field.type,
-	          description: field.description
-	        };
-	      }));
-	    }
-	  }
-
-	  // Input values.
-	  if (kind === 'StringValue' || kind === 'NumberValue' || kind === 'BooleanValue' || kind === 'NullValue' || kind === 'ListValue' && step === 1 || kind === 'ObjectField' && step === 2 || kind === 'Variable' && step === 2) {
-	    var _ret = function () {
-	      var namedInputType = (0, _graphql.getNamedType)(typeInfo.type);
-	      if (namedInputType instanceof _graphql.GraphQLInputObjectType) {
-	        return {
-	          v: (0, _hintList2.default)(cur, token, [{ text: '{' }])
-	        };
-	      } else if (namedInputType instanceof _graphql.GraphQLEnumType) {
-	        var _ret2 = function () {
-	          var valueMap = namedInputType.getValues();
-	          var values = Object.keys(valueMap).map(function (name) {
-	            return valueMap[name];
-	          });
-	          return {
-	            v: {
-	              v: (0, _hintList2.default)(cur, token, values.map(function (value) {
-	                return {
-	                  text: '"' + value.name + '"',
-	                  type: namedInputType,
-	                  description: value.description
-	                };
-	              }))
-	            }
-	          };
-	        }();
-
-	        if (typeof _ret2 === "object") return _ret2.v;
-	      } else if (namedInputType === _graphql.GraphQLBoolean) {
-	        return {
-	          v: (0, _hintList2.default)(cur, token, [{ text: 'true', type: _graphql.GraphQLBoolean, description: 'Not false.' }, { text: 'false', type: _graphql.GraphQLBoolean, description: 'Not true.' }])
-	        };
-	      }
-	    }();
-
-	    if (typeof _ret === "object") return _ret.v;
-	  }
-	}
-
-	// Utility for collecting rich type information given any token's state
-	// from the graphql-variables-mode parser.
-	function getTypeInfo(variableToType, tokenState) {
-	  var info = {
-	    type: null,
-	    fields: null
-	  };
-
-	  (0, _forEachState2.default)(tokenState, function (state) {
-	    if (state.kind === 'Variable') {
-	      info.type = variableToType[state.name];
-	    } else if (state.kind === 'ListValue') {
-	      var nullableType = (0, _graphql.getNullableType)(info.type);
-	      info.type = nullableType instanceof _graphql.GraphQLList ? nullableType.ofType : null;
-	    } else if (state.kind === 'ObjectValue') {
-	      var objectType = (0, _graphql.getNamedType)(info.type);
-	      info.fields = objectType instanceof _graphql.GraphQLInputObjectType ? objectType.getFields() : null;
-	    } else if (state.kind === 'ObjectField') {
-	      var objectField = state.name && info.fields ? info.fields[state.name] : null;
-	      info.type = objectField && objectField.type;
-	    }
-	  });
-
-	  return info;
-	}
-
-/***/ },
-/* 292 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	var _codemirror = __webpack_require__(267);
-
-	var _codemirror2 = _interopRequireDefault(_codemirror);
-
-	var _graphql = __webpack_require__(185);
-
-	var _jsonParse = __webpack_require__(293);
-
-	var _jsonParse2 = _interopRequireDefault(_jsonParse);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 * Registers a "lint" helper for CodeMirror.
-	 *
-	 * Using CodeMirror's "lint" addon: https://codemirror.net/demo/lint.html
-	 * Given the text within an editor, this helper will take that text and return
-	 * a list of linter issues ensuring that correct variables were provided.
-	 *
-	 * Options:
-	 *
-	 *   - variableToType: { [variable: string]: GraphQLInputType }
-	 *
-	 */
-	_codemirror2.default.registerHelper('lint', 'graphql-variables', function (text, options, editor) {
-	  // If there's no text, do nothing.
-	  if (!text) {
-	    return [];
-	  }
-
-	  // First, linter needs to determine if there are any parsing errors.
-	  var ast = void 0;
-	  try {
-	    ast = (0, _jsonParse2.default)(text);
-	  } catch (syntaxError) {
-	    if (syntaxError.stack) {
-	      throw syntaxError;
-	    }
-	    return [lintError(editor, syntaxError, syntaxError.message)];
-	  }
-
-	  // If there are not yet known variables, do nothing.
-	  var variableToType = options.variableToType;
-	  if (!variableToType) {
-	    return [];
-	  }
-
-	  // Then highlight any issues with the provided variables.
-	  return validateVariables(editor, variableToType, ast);
-	});
-
-	// Given a variableToType object, a source text, and a JSON AST, produces a
-	// list of CodeMirror annotations for any variable validation errors.
-	/* eslint-disable max-len */
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function validateVariables(editor, variableToType, variablesAST) {
-	  var errors = [];
-
-	  variablesAST.members.forEach(function (member) {
-	    var variableName = member.key.value;
-	    var type = variableToType[variableName];
-	    if (!type) {
-	      errors.push(lintError(editor, member.key, 'Variable "$' + variableName + '" does not appear in any GraphQL query.'));
-	    } else {
-	      validateValue(type, member.value).forEach(function (_ref) {
-	        var node = _ref[0],
-	            message = _ref[1];
-
-	        errors.push(lintError(editor, node, message));
-	      });
-	    }
-	  });
-
-	  return errors;
-	}
-
-	// Returns a list of validation errors in the form Array<[Node, String]>.
-	function validateValue(type, valueAST) {
-	  // Validate non-nullable values.
-	  if (type instanceof _graphql.GraphQLNonNull) {
-	    if (valueAST.kind === 'Null') {
-	      return [[valueAST, 'Type "' + type + '" is non-nullable and cannot be null.']];
-	    }
-	    return validateValue(type.ofType, valueAST);
-	  }
-
-	  if (valueAST.kind === 'Null') {
-	    return [];
-	  }
-
-	  // Validate lists of values, accepting a non-list as a list of one.
-	  if (type instanceof _graphql.GraphQLList) {
-	    var _ret = function () {
-	      var itemType = type.ofType;
-	      if (valueAST.kind === 'Array') {
-	        return {
-	          v: mapCat(valueAST.values, function (item) {
-	            return validateValue(itemType, item);
-	          })
-	        };
-	      }
-	      return {
-	        v: validateValue(itemType, valueAST)
-	      };
-	    }();
-
-	    if (typeof _ret === "object") return _ret.v;
-	  }
-
-	  // Validate input objects.
-	  if (type instanceof _graphql.GraphQLInputObjectType) {
-	    var _ret2 = function () {
-	      if (valueAST.kind !== 'Object') {
-	        return {
-	          v: [[valueAST, 'Type "' + type + '" must be an Object.']]
-	        };
-	      }
-
-	      // Validate each field in the input object.
-	      var providedFields = Object.create(null);
-	      var fieldErrors = mapCat(valueAST.members, function (member) {
-	        var fieldName = member.key.value;
-	        providedFields[fieldName] = true;
-	        var inputField = type.getFields()[fieldName];
-	        if (!inputField) {
-	          return [[member.key, 'Type "' + type + '" does not have a field "' + fieldName + '".']];
-	        }
-	        var fieldType = inputField ? inputField.type : undefined;
-	        return validateValue(fieldType, member.value);
-	      });
-
-	      // Look for missing non-nullable fields.
-	      Object.keys(type.getFields()).forEach(function (fieldName) {
-	        if (!providedFields[fieldName]) {
-	          var fieldType = type.getFields()[fieldName].type;
-	          if (fieldType instanceof _graphql.GraphQLNonNull) {
-	            fieldErrors.push([valueAST, 'Object of type "' + type + '" is missing required field "' + fieldName + '".']);
-	          }
-	        }
-	      });
-
-	      return {
-	        v: fieldErrors
-	      };
-	    }();
-
-	    if (typeof _ret2 === "object") return _ret2.v;
-	  }
-
-	  // Validate common scalars.
-	  if (type.name === 'Boolean' && valueAST.kind !== 'Boolean' || type.name === 'String' && valueAST.kind !== 'String' || type.name === 'ID' && valueAST.kind !== 'Number' && valueAST.kind !== 'String' || type.name === 'Float' && valueAST.kind !== 'Number' || type.name === 'Int' && (valueAST.kind !== 'Number' || (valueAST.value | 0) !== valueAST.value)) {
-	    return [[valueAST, 'Expected value of type "' + type + '".']];
-	  }
-
-	  // Validate enums and custom scalars.
-	  if (type instanceof _graphql.GraphQLEnumType || type instanceof _graphql.GraphQLScalarType) {
-	    if (valueAST.kind !== 'String' && valueAST.kind !== 'Number' && valueAST.kind !== 'Boolean' && valueAST.kind !== 'Null' || isNullish(type.parseValue(valueAST.value))) {
-	      return [[valueAST, 'Expected value of type "' + type + '".']];
-	    }
-	  }
-
-	  return [];
-	}
-
-	// Give a parent text, an AST node with location, and a message, produces a
-	// CodeMirror annotation object.
-	function lintError(editor, node, message) {
-	  return {
-	    message: message,
-	    severity: 'error',
-	    type: 'validation',
-	    from: editor.posFromIndex(node.start),
-	    to: editor.posFromIndex(node.end)
-	  };
-	}
-
-	function isNullish(value) {
-	  return value === null || value === undefined || value !== value;
-	}
-
-	function mapCat(array, mapper) {
-	  return Array.prototype.concat.apply([], array.map(mapper));
-	}
-
-/***/ },
-/* 293 */
-/***/ function(module, exports) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.default = jsonParse;
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	/**
-	 * This JSON parser simply walks the input, generating an AST. Use this in lieu
-	 * of JSON.parse if you need character offset parse errors and an AST parse tree
-	 * with location information.
-	 *
-	 * If an error is encountered, a SyntaxError will be thrown, with properties:
-	 *
-	 *   - message: string
-	 *   - start: int - the start inclusive offset of the syntax error
-	 *   - end: int - the end exclusive offset of the syntax error
-	 *
-	 */
-	function jsonParse(str) {
-	  string = str;
-	  strLen = str.length;
-	  start = end = lastEnd = -1;
-	  ch();
-	  lex();
-	  var ast = parseObj();
-	  expect('EOF');
-	  return ast;
-	}
-
-	var string = void 0;
-	var strLen = void 0;
-	var start = void 0;
-	var end = void 0;
-	var lastEnd = void 0;
-	var code = void 0;
-	var kind = void 0;
-
-	function parseObj() {
-	  var nodeStart = start;
-	  var members = [];
-	  expect('{');
-	  if (!skip('}')) {
-	    do {
-	      members.push(parseMember());
-	    } while (skip(','));
-	    expect('}');
-	  }
-	  return {
-	    kind: 'Object',
-	    start: nodeStart,
-	    end: lastEnd,
-	    members: members
-	  };
-	}
-
-	function parseMember() {
-	  var nodeStart = start;
-	  var key = kind === 'String' ? curToken() : null;
-	  expect('String');
-	  expect(':');
-	  var value = parseVal();
-	  return {
-	    kind: 'Member',
-	    start: nodeStart,
-	    end: lastEnd,
-	    key: key,
-	    value: value
-	  };
-	}
-
-	function parseArr() {
-	  var nodeStart = start;
-	  var values = [];
-	  expect('[');
-	  if (!skip(']')) {
-	    do {
-	      values.push(parseVal());
-	    } while (skip(','));
-	    expect(']');
-	  }
-	  return {
-	    kind: 'Array',
-	    start: nodeStart,
-	    end: lastEnd,
-	    values: values
-	  };
-	}
-
-	function parseVal() {
-	  switch (kind) {
-	    case '[':
-	      return parseArr();
-	    case '{':
-	      return parseObj();
-	    case 'String':
-	    case 'Number':
-	    case 'Boolean':
-	    case 'Null':
-	      var token = curToken();
-	      lex();
-	      return token;
-	  }
-	  return expect('Value');
-	}
-
-	function curToken() {
-	  return { kind: kind, start: start, end: end, value: JSON.parse(string.slice(start, end)) };
-	}
-
-	function expect(str) {
-	  if (kind === str) {
-	    lex();
-	    return;
-	  }
-
-	  var found = void 0;
-	  if (kind === 'EOF') {
-	    found = '[end of file]';
-	  } else if (end - start > 1) {
-	    found = '`' + string.slice(start, end) + '`';
-	  } else {
-	    var match = string.slice(start).match(/^.+?\b/);
-	    found = '`' + (match ? match[0] : string[start]) + '`';
-	  }
-
-	  throw syntaxError('Expected ' + str + ' but found ' + found + '.');
-	}
-
-	function syntaxError(message) {
-	  return { message: message, start: start, end: end };
-	}
-
-	function skip(k) {
-	  if (kind === k) {
-	    lex();
-	    return true;
-	  }
-	}
-
-	function ch() {
-	  if (end < strLen) {
-	    end++;
-	    code = end === strLen ? 0 : string.charCodeAt(end);
-	  }
-	}
-
-	function lex() {
-	  lastEnd = end;
-
-	  while (code === 9 || code === 10 || code === 13 || code === 32) {
-	    ch();
-	  }
-
-	  if (code === 0) {
-	    kind = 'EOF';
-	    return;
-	  }
-
-	  start = end;
-
-	  switch (code) {
-	    // "
-	    case 34:
-	      kind = 'String';
-	      return readString();
-	    // -, 0-9
-	    case 45:
-	    case 48:case 49:case 50:case 51:case 52:
-	    case 53:case 54:case 55:case 56:case 57:
-	      kind = 'Number';
-	      return readNumber();
-	    // f
-	    case 102:
-	      if (string.slice(start, start + 5) !== 'false') {
-	        break;
-	      }
-	      end += 4;ch();
-
-	      kind = 'Boolean';
-	      return;
-	    // n
-	    case 110:
-	      if (string.slice(start, start + 4) !== 'null') {
-	        break;
-	      }
-	      end += 3;ch();
-
-	      kind = 'Null';
-	      return;
-	    // t
-	    case 116:
-	      if (string.slice(start, start + 4) !== 'true') {
-	        break;
-	      }
-	      end += 3;ch();
-
-	      kind = 'Boolean';
-	      return;
-	  }
-
-	  kind = string[start];
-	  ch();
-	}
-
-	function readString() {
-	  ch();
-	  while (code !== 34 && code > 31) {
-	    if (code === 92) {
-	      // \
-	      ch();
-	      switch (code) {
-	        case 34: // "
-	        case 47: // /
-	        case 92: // \
-	        case 98: // b
-	        case 102: // f
-	        case 110: // n
-	        case 114: // r
-	        case 116:
-	          // t
-	          ch();
-	          break;
-	        case 117:
-	          // u
-	          ch();
-	          readHex();
-	          readHex();
-	          readHex();
-	          readHex();
-	          break;
-	        default:
-	          throw syntaxError('Bad character escape sequence.');
-	      }
-	    } else if (end === strLen) {
-	      throw syntaxError('Unterminated string.');
-	    } else {
-	      ch();
-	    }
-	  }
-
-	  if (code === 34) {
-	    ch();
-	    return;
-	  }
-
-	  throw syntaxError('Unterminated string.');
-	}
-
-	function readHex() {
-	  if (code >= 48 && code <= 57 || // 0-9
-	  code >= 65 && code <= 70 || // A-F
-	  code >= 97 && code <= 102 // a-f
-	  ) {
-	      return ch();
-	    }
-	  throw syntaxError('Expected hexadecimal digit.');
-	}
-
-	function readNumber() {
-	  if (code === 45) {
-	    // -
-	    ch();
-	  }
-
-	  if (code === 48) {
-	    // 0
-	    ch();
-	  } else {
-	    readDigits();
-	  }
-
-	  if (code === 46) {
-	    // .
-	    ch();
-	    readDigits();
-	  }
-
-	  if (code === 69 || code === 101) {
-	    // E e
-	    ch();
-	    if (code === 43 || code === 45) {
-	      // + -
-	      ch();
-	    }
-	    readDigits();
-	  }
-	}
-
-	function readDigits() {
-	  if (code < 48 || code > 57) {
-	    // 0 - 9
-	    throw syntaxError('Expected decimal digit.');
-	  }
-	  do {
-	    ch();
-	  } while (code >= 48 && code <= 57); // 0 - 9
-	}
-
-/***/ },
-/* 294 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	var _codemirror = __webpack_require__(267);
-
-	var _codemirror2 = _interopRequireDefault(_codemirror);
-
-	var _onlineParser = __webpack_require__(285);
-
-	var _onlineParser2 = _interopRequireDefault(_onlineParser);
-
-	var _RuleHelpers = __webpack_require__(287);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 * This mode defines JSON, but provides a data-laden parser state to enable
-	 * better code intelligence.
-	 */
-	_codemirror2.default.defineMode('graphql-variables', function (config) {
-	  var parser = (0, _onlineParser2.default)({
-	    eatWhitespace: function eatWhitespace(stream) {
-	      return stream.eatSpace();
-	    },
-	    LexRules: LexRules,
-	    ParseRules: ParseRules,
-	    editorConfig: { tabSize: config.tabSize }
-	  });
-
-	  return {
-	    config: config,
-	    startState: parser.startState,
-	    token: parser.token,
-	    indent: indent,
-	    electricInput: /^\s*[}\]]/,
-	    fold: 'brace',
-	    closeBrackets: {
-	      pairs: '[]{}""',
-	      explode: '[]{}'
-	    }
-	  };
-	}); /**
-	     *  Copyright (c) 2015, Facebook, Inc.
-	     *  All rights reserved.
-	     *
-	     *  This source code is licensed under the BSD-style license found in the
-	     *  LICENSE file in the root directory of this source tree. An additional grant
-	     *  of patent rights can be found in the PATENTS file in the same directory.
-	     */
-
-	function indent(state, textAfter) {
-	  var levels = state.levels;
-	  // If there is no stack of levels, use the current level.
-	  // Otherwise, use the top level, pre-emptively dedenting for close braces.
-	  var level = !levels || levels.length === 0 ? state.indentLevel : levels[levels.length - 1] - (this.electricInput.test(textAfter) ? 1 : 0);
-	  return level * this.config.indentUnit;
-	}
-
-	/**
-	 * The lexer rules. These are exactly as described by the spec.
-	 */
-	var LexRules = {
-	  // All Punctuation used in JSON.
-	  Punctuation: /^\[|]|\{|\}|:|,/,
-
-	  // JSON Number.
-	  Number: /^-?(?:0|(?:[1-9][0-9]*))(?:\.[0-9]*)?(?:[eE][+-]?[0-9]+)?/,
-
-	  // JSON String.
-	  String: /^"(?:[^"\\]|\\(?:"|\/|\\|b|f|n|r|t|u[0-9a-fA-F]{4}))*"?/,
-
-	  // JSON literal keywords.
-	  Keyword: /^true|false|null/
-	};
-
-	/**
-	 * The parser rules for JSON.
-	 */
-	var ParseRules = {
-	  Document: [(0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('Variable', (0, _RuleHelpers.p)(',')), (0, _RuleHelpers.p)('}')],
-	  Variable: [namedKey('variable'), (0, _RuleHelpers.p)(':'), 'Value'],
-	  Value: function Value(token) {
-	    switch (token.kind) {
-	      case 'Number':
-	        return 'NumberValue';
-	      case 'String':
-	        return 'StringValue';
-	      case 'Punctuation':
-	        switch (token.value) {
-	          case '[':
-	            return 'ListValue';
-	          case '{':
-	            return 'ObjectValue';
-	        }
-	        return null;
-	      case 'Keyword':
-	        switch (token.value) {
-	          case 'true':case 'false':
-	            return 'BooleanValue';
-	          case 'null':
-	            return 'NullValue';
-	        }
-	        return null;
-	    }
-	  },
-
-	  NumberValue: [(0, _RuleHelpers.t)('Number', 'number')],
-	  StringValue: [(0, _RuleHelpers.t)('String', 'string')],
-	  BooleanValue: [(0, _RuleHelpers.t)('Keyword', 'builtin')],
-	  NullValue: [(0, _RuleHelpers.t)('Keyword', 'keyword')],
-	  ListValue: [(0, _RuleHelpers.p)('['), (0, _RuleHelpers.list)('Value', (0, _RuleHelpers.p)(',')), (0, _RuleHelpers.p)(']')],
-	  ObjectValue: [(0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('ObjectField', (0, _RuleHelpers.p)(',')), (0, _RuleHelpers.p)('}')],
-	  ObjectField: [namedKey('attribute'), (0, _RuleHelpers.p)(':'), 'Value']
-	};
-
-	// A namedKey Token which will decorate the state with a `name`
-	function namedKey(style) {
-	  return {
-	    style: style,
-	    match: function match(token) {
-	      return token.kind === 'String';
-	    },
-	    update: function update(state, token) {
-	      state.name = token.value.slice(1, -1); // Remove quotes.
-	    }
-	  };
-	}
-
-/***/ },
-/* 295 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.ResultViewer = undefined;
-
-	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-	var _react = __webpack_require__(1);
-
-	var _react2 = _interopRequireDefault(_react);
-
-	var _reactDom = __webpack_require__(32);
-
-	var _reactDom2 = _interopRequireDefault(_reactDom);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /**
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  Copyright (c) 2015, Facebook, Inc.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  All rights reserved.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  This source code is licensed under the license found in the
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  LICENSE-examples file in the root directory of this source tree.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
-
-	/**
-	 * ResultViewer
-	 *
-	 * Maintains an instance of CodeMirror for viewing a GraphQL response.
-	 *
-	 * Props:
-	 *
-	 *   - value: The text of the editor.
-	 *
-	 */
-	var ResultViewer = exports.ResultViewer = function (_React$Component) {
-	  _inherits(ResultViewer, _React$Component);
-
-	  function ResultViewer() {
-	    _classCallCheck(this, ResultViewer);
-
-	    return _possibleConstructorReturn(this, (ResultViewer.__proto__ || Object.getPrototypeOf(ResultViewer)).apply(this, arguments));
-	  }
-
-	  _createClass(ResultViewer, [{
-	    key: 'componentDidMount',
-	    value: function componentDidMount() {
-	      // Lazily require to ensure requiring GraphiQL outside of a Browser context
-	      // does not produce an error.
-	      var CodeMirror = __webpack_require__(267);
-	      __webpack_require__(272);
-	      __webpack_require__(274);
-	      __webpack_require__(296);
-	      __webpack_require__(297);
-	      __webpack_require__(276);
-	      __webpack_require__(298);
-
-	      this.viewer = CodeMirror(_reactDom2.default.findDOMNode(this), {
-	        lineWrapping: true,
-	        value: this.props.value || '',
-	        readOnly: true,
-	        theme: 'graphiql',
-	        mode: 'graphql-results',
-	        keyMap: 'sublime',
-	        foldGutter: {
-	          minFoldSize: 4
-	        },
-	        gutters: ['CodeMirror-foldgutter'],
-	        extraKeys: {
-	          // Editor improvements
-	          'Ctrl-Left': 'goSubwordLeft',
-	          'Ctrl-Right': 'goSubwordRight',
-	          'Alt-Left': 'goGroupLeft',
-	          'Alt-Right': 'goGroupRight'
-	        }
-	      });
-	    }
-	  }, {
-	    key: 'shouldComponentUpdate',
-	    value: function shouldComponentUpdate(nextProps) {
-	      return this.props.value !== nextProps.value;
-	    }
-	  }, {
-	    key: 'componentDidUpdate',
-	    value: function componentDidUpdate() {
-	      this.viewer.setValue(this.props.value || '');
-	    }
-	  }, {
-	    key: 'componentWillUnmount',
-	    value: function componentWillUnmount() {
-	      this.viewer = null;
-	    }
-	  }, {
-	    key: 'render',
-	    value: function render() {
-	      return _react2.default.createElement('div', { className: 'result-window' });
-	    }
-
-	    /**
-	     * Public API for retrieving the CodeMirror instance from this
-	     * React component.
-	     */
-
-	  }, {
-	    key: 'getCodeMirror',
-	    value: function getCodeMirror() {
-	      return this.viewer;
-	    }
-	  }]);
-
-	  return ResultViewer;
-	}(_react2.default.Component);
-
-	ResultViewer.propTypes = {
-	  value: _react.PropTypes.string
-	};
-
-/***/ },
-/* 296 */
-/***/ function(module, exports, __webpack_require__) {
-
-	// CodeMirror, copyright (c) by Marijn Haverbeke and others
-	// Distributed under an MIT license: http://codemirror.net/LICENSE
-
-	// Open simple dialogs on top of an editor. Relies on dialog.css.
-
-	(function(mod) {
-	  if (true) // CommonJS
-	    mod(__webpack_require__(267));
-	  else if (typeof define == "function" && define.amd) // AMD
-	    define(["../../lib/codemirror"], mod);
-	  else // Plain browser env
-	    mod(CodeMirror);
-	})(function(CodeMirror) {
-	  function dialogDiv(cm, template, bottom) {
-	    var wrap = cm.getWrapperElement();
-	    var dialog;
-	    dialog = wrap.appendChild(document.createElement("div"));
-	    if (bottom)
-	      dialog.className = "CodeMirror-dialog CodeMirror-dialog-bottom";
-	    else
-	      dialog.className = "CodeMirror-dialog CodeMirror-dialog-top";
-
-	    if (typeof template == "string") {
-	      dialog.innerHTML = template;
-	    } else { // Assuming it's a detached DOM element.
-	      dialog.appendChild(template);
-	    }
-	    return dialog;
-	  }
-
-	  function closeNotification(cm, newVal) {
-	    if (cm.state.currentNotificationClose)
-	      cm.state.currentNotificationClose();
-	    cm.state.currentNotificationClose = newVal;
-	  }
-
-	  CodeMirror.defineExtension("openDialog", function(template, callback, options) {
-	    if (!options) options = {};
-
-	    closeNotification(this, null);
-
-	    var dialog = dialogDiv(this, template, options.bottom);
-	    var closed = false, me = this;
-	    function close(newVal) {
-	      if (typeof newVal == 'string') {
-	        inp.value = newVal;
-	      } else {
-	        if (closed) return;
-	        closed = true;
-	        dialog.parentNode.removeChild(dialog);
-	        me.focus();
-
-	        if (options.onClose) options.onClose(dialog);
-	      }
-	    }
-
-	    var inp = dialog.getElementsByTagName("input")[0], button;
-	    if (inp) {
-	      inp.focus();
-
-	      if (options.value) {
-	        inp.value = options.value;
-	        if (options.selectValueOnOpen !== false) {
-	          inp.select();
-	        }
-	      }
-
-	      if (options.onInput)
-	        CodeMirror.on(inp, "input", function(e) { options.onInput(e, inp.value, close);});
-	      if (options.onKeyUp)
-	        CodeMirror.on(inp, "keyup", function(e) {options.onKeyUp(e, inp.value, close);});
-
-	      CodeMirror.on(inp, "keydown", function(e) {
-	        if (options && options.onKeyDown && options.onKeyDown(e, inp.value, close)) { return; }
-	        if (e.keyCode == 27 || (options.closeOnEnter !== false && e.keyCode == 13)) {
-	          inp.blur();
-	          CodeMirror.e_stop(e);
-	          close();
-	        }
-	        if (e.keyCode == 13) callback(inp.value, e);
-	      });
-
-	      if (options.closeOnBlur !== false) CodeMirror.on(inp, "blur", close);
-	    } else if (button = dialog.getElementsByTagName("button")[0]) {
-	      CodeMirror.on(button, "click", function() {
-	        close();
-	        me.focus();
-	      });
-
-	      if (options.closeOnBlur !== false) CodeMirror.on(button, "blur", close);
-
-	      button.focus();
-	    }
-	    return close;
-	  });
-
-	  CodeMirror.defineExtension("openConfirm", function(template, callbacks, options) {
-	    closeNotification(this, null);
-	    var dialog = dialogDiv(this, template, options && options.bottom);
-	    var buttons = dialog.getElementsByTagName("button");
-	    var closed = false, me = this, blurring = 1;
-	    function close() {
-	      if (closed) return;
-	      closed = true;
-	      dialog.parentNode.removeChild(dialog);
-	      me.focus();
-	    }
-	    buttons[0].focus();
-	    for (var i = 0; i < buttons.length; ++i) {
-	      var b = buttons[i];
-	      (function(callback) {
-	        CodeMirror.on(b, "click", function(e) {
-	          CodeMirror.e_preventDefault(e);
-	          close();
-	          if (callback) callback(me);
-	        });
-	      })(callbacks[i]);
-	      CodeMirror.on(b, "blur", function() {
-	        --blurring;
-	        setTimeout(function() { if (blurring <= 0) close(); }, 200);
-	      });
-	      CodeMirror.on(b, "focus", function() { ++blurring; });
-	    }
-	  });
-
-	  /*
-	   * openNotification
-	   * Opens a notification, that can be closed with an optional timer
-	   * (default 5000ms timer) and always closes on click.
-	   *
-	   * If a notification is opened while another is opened, it will close the
-	   * currently opened one and open the new one immediately.
-	   */
-	  CodeMirror.defineExtension("openNotification", function(template, options) {
-	    closeNotification(this, close);
-	    var dialog = dialogDiv(this, template, options && options.bottom);
-	    var closed = false, doneTimer;
-	    var duration = options && typeof options.duration !== "undefined" ? options.duration : 5000;
-
-	    function close() {
-	      if (closed) return;
-	      closed = true;
-	      clearTimeout(doneTimer);
-	      dialog.parentNode.removeChild(dialog);
-	    }
-
-	    CodeMirror.on(dialog, 'click', function(e) {
-	      CodeMirror.e_preventDefault(e);
-	      close();
-	    });
-
-	    if (duration)
-	      doneTimer = setTimeout(close, duration);
-
-	    return close;
-	  });
-	});
-
-
-/***/ },
-/* 297 */
-/***/ function(module, exports, __webpack_require__) {
-
-	// CodeMirror, copyright (c) by Marijn Haverbeke and others
-	// Distributed under an MIT license: http://codemirror.net/LICENSE
-
-	// Define search commands. Depends on dialog.js or another
-	// implementation of the openDialog method.
-
-	// Replace works a little oddly -- it will do the replace on the next
-	// Ctrl-G (or whatever is bound to findNext) press. You prevent a
-	// replace by making sure the match is no longer selected when hitting
-	// Ctrl-G.
-
-	(function(mod) {
-	  if (true) // CommonJS
-	    mod(__webpack_require__(267), __webpack_require__(277), __webpack_require__(296));
-	  else if (typeof define == "function" && define.amd) // AMD
-	    define(["../../lib/codemirror", "./searchcursor", "../dialog/dialog"], mod);
-	  else // Plain browser env
-	    mod(CodeMirror);
-	})(function(CodeMirror) {
-	  "use strict";
-
-	  function searchOverlay(query, caseInsensitive) {
-	    if (typeof query == "string")
-	      query = new RegExp(query.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"), caseInsensitive ? "gi" : "g");
-	    else if (!query.global)
-	      query = new RegExp(query.source, query.ignoreCase ? "gi" : "g");
-
-	    return {token: function(stream) {
-	      query.lastIndex = stream.pos;
-	      var match = query.exec(stream.string);
-	      if (match && match.index == stream.pos) {
-	        stream.pos += match[0].length || 1;
-	        return "searching";
-	      } else if (match) {
-	        stream.pos = match.index;
-	      } else {
-	        stream.skipToEnd();
-	      }
-	    }};
-	  }
-
-	  function SearchState() {
-	    this.posFrom = this.posTo = this.lastQuery = this.query = null;
-	    this.overlay = null;
-	  }
-
-	  function getSearchState(cm) {
-	    return cm.state.search || (cm.state.search = new SearchState());
-	  }
-
-	  function queryCaseInsensitive(query) {
-	    return typeof query == "string" && query == query.toLowerCase();
-	  }
-
-	  function getSearchCursor(cm, query, pos) {
-	    // Heuristic: if the query string is all lowercase, do a case insensitive search.
-	    return cm.getSearchCursor(query, pos, queryCaseInsensitive(query));
-	  }
-
-	  function persistentDialog(cm, text, deflt, onEnter, onKeyDown) {
-	    cm.openDialog(text, onEnter, {
-	      value: deflt,
-	      selectValueOnOpen: true,
-	      closeOnEnter: false,
-	      onClose: function() { clearSearch(cm); },
-	      onKeyDown: onKeyDown
-	    });
-	  }
-
-	  function dialog(cm, text, shortText, deflt, f) {
-	    if (cm.openDialog) cm.openDialog(text, f, {value: deflt, selectValueOnOpen: true});
-	    else f(prompt(shortText, deflt));
-	  }
-
-	  function confirmDialog(cm, text, shortText, fs) {
-	    if (cm.openConfirm) cm.openConfirm(text, fs);
-	    else if (confirm(shortText)) fs[0]();
-	  }
-
-	  function parseString(string) {
-	    return string.replace(/\\(.)/g, function(_, ch) {
-	      if (ch == "n") return "\n"
-	      if (ch == "r") return "\r"
-	      return ch
-	    })
-	  }
-
-	  function parseQuery(query) {
-	    var isRE = query.match(/^\/(.*)\/([a-z]*)$/);
-	    if (isRE) {
-	      try { query = new RegExp(isRE[1], isRE[2].indexOf("i") == -1 ? "" : "i"); }
-	      catch(e) {} // Not a regular expression after all, do a string search
-	    } else {
-	      query = parseString(query)
-	    }
-	    if (typeof query == "string" ? query == "" : query.test(""))
-	      query = /x^/;
-	    return query;
-	  }
-
-	  var queryDialog =
-	    'Search: <input type="text" style="width: 10em" class="CodeMirror-search-field"/> <span style="color: #888" class="CodeMirror-search-hint">(Use /re/ syntax for regexp search)</span>';
-
-	  function startSearch(cm, state, query) {
-	    state.queryText = query;
-	    state.query = parseQuery(query);
-	    cm.removeOverlay(state.overlay, queryCaseInsensitive(state.query));
-	    state.overlay = searchOverlay(state.query, queryCaseInsensitive(state.query));
-	    cm.addOverlay(state.overlay);
-	    if (cm.showMatchesOnScrollbar) {
-	      if (state.annotate) { state.annotate.clear(); state.annotate = null; }
-	      state.annotate = cm.showMatchesOnScrollbar(state.query, queryCaseInsensitive(state.query));
-	    }
-	  }
-
-	  function doSearch(cm, rev, persistent, immediate) {
-	    var state = getSearchState(cm);
-	    if (state.query) return findNext(cm, rev);
-	    var q = cm.getSelection() || state.lastQuery;
-	    if (persistent && cm.openDialog) {
-	      var hiding = null
-	      var searchNext = function(query, event) {
-	        CodeMirror.e_stop(event);
-	        if (!query) return;
-	        if (query != state.queryText) {
-	          startSearch(cm, state, query);
-	          state.posFrom = state.posTo = cm.getCursor();
-	        }
-	        if (hiding) hiding.style.opacity = 1
-	        findNext(cm, event.shiftKey, function(_, to) {
-	          var dialog
-	          if (to.line < 3 && document.querySelector &&
-	              (dialog = cm.display.wrapper.querySelector(".CodeMirror-dialog")) &&
-	              dialog.getBoundingClientRect().bottom - 4 > cm.cursorCoords(to, "window").top)
-	            (hiding = dialog).style.opacity = .4
-	        })
-	      };
-	      persistentDialog(cm, queryDialog, q, searchNext, function(event, query) {
-	        var keyName = CodeMirror.keyName(event)
-	        var cmd = CodeMirror.keyMap[cm.getOption("keyMap")][keyName]
-	        if (!cmd) cmd = cm.getOption('extraKeys')[keyName]
-	        if (cmd == "findNext" || cmd == "findPrev" ||
-	          cmd == "findPersistentNext" || cmd == "findPersistentPrev") {
-	          CodeMirror.e_stop(event);
-	          startSearch(cm, getSearchState(cm), query);
-	          cm.execCommand(cmd);
-	        } else if (cmd == "find" || cmd == "findPersistent") {
-	          CodeMirror.e_stop(event);
-	          searchNext(query, event);
-	        }
-	      });
-	      if (immediate && q) {
-	        startSearch(cm, state, q);
-	        findNext(cm, rev);
-	      }
-	    } else {
-	      dialog(cm, queryDialog, "Search for:", q, function(query) {
-	        if (query && !state.query) cm.operation(function() {
-	          startSearch(cm, state, query);
-	          state.posFrom = state.posTo = cm.getCursor();
-	          findNext(cm, rev);
-	        });
-	      });
-	    }
-	  }
-
-	  function findNext(cm, rev, callback) {cm.operation(function() {
-	    var state = getSearchState(cm);
-	    var cursor = getSearchCursor(cm, state.query, rev ? state.posFrom : state.posTo);
-	    if (!cursor.find(rev)) {
-	      cursor = getSearchCursor(cm, state.query, rev ? CodeMirror.Pos(cm.lastLine()) : CodeMirror.Pos(cm.firstLine(), 0));
-	      if (!cursor.find(rev)) return;
-	    }
-	    cm.setSelection(cursor.from(), cursor.to());
-	    cm.scrollIntoView({from: cursor.from(), to: cursor.to()}, 20);
-	    state.posFrom = cursor.from(); state.posTo = cursor.to();
-	    if (callback) callback(cursor.from(), cursor.to())
-	  });}
-
-	  function clearSearch(cm) {cm.operation(function() {
-	    var state = getSearchState(cm);
-	    state.lastQuery = state.query;
-	    if (!state.query) return;
-	    state.query = state.queryText = null;
-	    cm.removeOverlay(state.overlay);
-	    if (state.annotate) { state.annotate.clear(); state.annotate = null; }
-	  });}
-
-	  var replaceQueryDialog =
-	    ' <input type="text" style="width: 10em" class="CodeMirror-search-field"/> <span style="color: #888" class="CodeMirror-search-hint">(Use /re/ syntax for regexp search)</span>';
-	  var replacementQueryDialog = 'With: <input type="text" style="width: 10em" class="CodeMirror-search-field"/>';
-	  var doReplaceConfirm = "Replace? <button>Yes</button> <button>No</button> <button>All</button> <button>Stop</button>";
-
-	  function replaceAll(cm, query, text) {
-	    cm.operation(function() {
-	      for (var cursor = getSearchCursor(cm, query); cursor.findNext();) {
-	        if (typeof query != "string") {
-	          var match = cm.getRange(cursor.from(), cursor.to()).match(query);
-	          cursor.replace(text.replace(/\$(\d)/g, function(_, i) {return match[i];}));
-	        } else cursor.replace(text);
-	      }
-	    });
-	  }
-
-	  function replace(cm, all) {
-	    if (cm.getOption("readOnly")) return;
-	    var query = cm.getSelection() || getSearchState(cm).lastQuery;
-	    var dialogText = all ? "Replace all:" : "Replace:"
-	    dialog(cm, dialogText + replaceQueryDialog, dialogText, query, function(query) {
-	      if (!query) return;
-	      query = parseQuery(query);
-	      dialog(cm, replacementQueryDialog, "Replace with:", "", function(text) {
-	        text = parseString(text)
-	        if (all) {
-	          replaceAll(cm, query, text)
-	        } else {
-	          clearSearch(cm);
-	          var cursor = getSearchCursor(cm, query, cm.getCursor("from"));
-	          var advance = function() {
-	            var start = cursor.from(), match;
-	            if (!(match = cursor.findNext())) {
-	              cursor = getSearchCursor(cm, query);
-	              if (!(match = cursor.findNext()) ||
-	                  (start && cursor.from().line == start.line && cursor.from().ch == start.ch)) return;
-	            }
-	            cm.setSelection(cursor.from(), cursor.to());
-	            cm.scrollIntoView({from: cursor.from(), to: cursor.to()});
-	            confirmDialog(cm, doReplaceConfirm, "Replace?",
-	                          [function() {doReplace(match);}, advance,
-	                           function() {replaceAll(cm, query, text)}]);
-	          };
-	          var doReplace = function(match) {
-	            cursor.replace(typeof query == "string" ? text :
-	                           text.replace(/\$(\d)/g, function(_, i) {return match[i];}));
-	            advance();
-	          };
-	          advance();
-	        }
-	      });
-	    });
-	  }
-
-	  CodeMirror.commands.find = function(cm) {clearSearch(cm); doSearch(cm);};
-	  CodeMirror.commands.findPersistent = function(cm) {clearSearch(cm); doSearch(cm, false, true);};
-	  CodeMirror.commands.findPersistentNext = function(cm) {doSearch(cm, false, true, true);};
-	  CodeMirror.commands.findPersistentPrev = function(cm) {doSearch(cm, true, true, true);};
-	  CodeMirror.commands.findNext = doSearch;
-	  CodeMirror.commands.findPrev = function(cm) {doSearch(cm, true);};
-	  CodeMirror.commands.clearSearch = clearSearch;
-	  CodeMirror.commands.replace = replace;
-	  CodeMirror.commands.replaceAll = function(cm) {replace(cm, true);};
-	});
-
-
-/***/ },
-/* 298 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	var _codemirror = __webpack_require__(267);
-
-	var _codemirror2 = _interopRequireDefault(_codemirror);
-
-	var _onlineParser = __webpack_require__(285);
-
-	var _onlineParser2 = _interopRequireDefault(_onlineParser);
-
-	var _RuleHelpers = __webpack_require__(287);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	/**
-	 * This mode defines JSON, but provides a data-laden parser state to enable
-	 * better code intelligence.
-	 */
-	_codemirror2.default.defineMode('graphql-results', function (config) {
-	  var parser = (0, _onlineParser2.default)({
-	    eatWhitespace: function eatWhitespace(stream) {
-	      return stream.eatSpace();
-	    },
-	    LexRules: LexRules,
-	    ParseRules: ParseRules,
-	    editorConfig: { tabSize: config.tabSize }
-	  });
-
-	  return {
-	    config: config,
-	    startState: parser.startState,
-	    token: parser.token,
-	    indent: indent,
-	    electricInput: /^\s*[}\]]/,
-	    fold: 'brace',
-	    closeBrackets: {
-	      pairs: '[]{}""',
-	      explode: '[]{}'
-	    }
-	  };
-	}); /**
-	     *  Copyright (c) 2015, Facebook, Inc.
-	     *  All rights reserved.
-	     *
-	     *  This source code is licensed under the BSD-style license found in the
-	     *  LICENSE file in the root directory of this source tree. An additional grant
-	     *  of patent rights can be found in the PATENTS file in the same directory.
-	     */
-
-	function indent(state, textAfter) {
-	  var levels = state.levels;
-	  // If there is no stack of levels, use the current level.
-	  // Otherwise, use the top level, pre-emptively dedenting for close braces.
-	  var level = !levels || levels.length === 0 ? state.indentLevel : levels[levels.length - 1] - (this.electricInput.test(textAfter) ? 1 : 0);
-	  return level * this.config.indentUnit;
-	}
-
-	/**
-	 * The lexer rules. These are exactly as described by the spec.
-	 */
-	var LexRules = {
-	  // All Punctuation used in JSON.
-	  Punctuation: /^\[|]|\{|\}|:|,/,
-
-	  // JSON Number.
-	  Number: /^-?(?:0|(?:[1-9][0-9]*))(?:\.[0-9]*)?(?:[eE][+-]?[0-9]+)?/,
-
-	  // JSON String.
-	  String: /^"(?:[^"\\]|\\(?:"|\/|\\|b|f|n|r|t|u[0-9a-fA-F]{4}))*"?/,
-
-	  // JSON literal keywords.
-	  Keyword: /^true|false|null/
-	};
-
-	/**
-	 * The parser rules for JSON.
-	 */
-	var ParseRules = {
-	  Document: [(0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('Entry', (0, _RuleHelpers.p)(',')), (0, _RuleHelpers.p)('}')],
-	  Entry: [(0, _RuleHelpers.t)('String', 'def'), (0, _RuleHelpers.p)(':'), 'Value'],
-	  Value: function Value(token) {
-	    switch (token.kind) {
-	      case 'Number':
-	        return 'NumberValue';
-	      case 'String':
-	        return 'StringValue';
-	      case 'Punctuation':
-	        switch (token.value) {
-	          case '[':
-	            return 'ListValue';
-	          case '{':
-	            return 'ObjectValue';
-	        }
-	        return null;
-	      case 'Keyword':
-	        switch (token.value) {
-	          case 'true':case 'false':
-	            return 'BooleanValue';
-	          case 'null':
-	            return 'NullValue';
-	        }
-	        return null;
-	    }
-	  },
-
-	  NumberValue: [(0, _RuleHelpers.t)('Number', 'number')],
-	  StringValue: [(0, _RuleHelpers.t)('String', 'string')],
-	  BooleanValue: [(0, _RuleHelpers.t)('Keyword', 'builtin')],
-	  NullValue: [(0, _RuleHelpers.t)('Keyword', 'keyword')],
-	  ListValue: [(0, _RuleHelpers.p)('['), (0, _RuleHelpers.list)('Value', (0, _RuleHelpers.p)(',')), (0, _RuleHelpers.p)(']')],
-	  ObjectValue: [(0, _RuleHelpers.p)('{'), (0, _RuleHelpers.list)('ObjectField', (0, _RuleHelpers.p)(',')), (0, _RuleHelpers.p)('}')],
-	  ObjectField: [(0, _RuleHelpers.t)('String', 'property'), (0, _RuleHelpers.p)(':'), 'Value']
-	};
-
-/***/ },
-/* 299 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.DocExplorer = undefined;
-
-	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-	var _react = __webpack_require__(1);
-
-	var _react2 = _interopRequireDefault(_react);
-
-	var _marked = __webpack_require__(266);
-
-	var _marked2 = _interopRequireDefault(_marked);
-
-	var _graphql = __webpack_require__(185);
-
-	var _debounce = __webpack_require__(300);
-
-	var _debounce2 = _interopRequireDefault(_debounce);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /**
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  Copyright (c) 2015, Facebook, Inc.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  All rights reserved.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  This source code is licensed under the license found in the
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *  LICENSE-examples file in the root directory of this source tree.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
-
-	/**
-	 * DocExplorer
-	 *
-	 * Shows documentations for GraphQL definitions from the schema.
-	 *
-	 * Props:
-	 *
-	 *   - schema: A required GraphQLSchema instance that provides GraphQL document
-	 *     definitions.
-	 *
-	 * Children:
-	 *
-	 *   - Any provided children will be positioned in the right-hand-side of the
-	 *     top bar. Typically this will be a "close" button for temporary explorer.
-	 *
-	 */
-	var DocExplorer = exports.DocExplorer = function (_React$Component) {
-	  _inherits(DocExplorer, _React$Component);
-
-	  function DocExplorer() {
-	    _classCallCheck(this, DocExplorer);
-
-	    var _this = _possibleConstructorReturn(this, (DocExplorer.__proto__ || Object.getPrototypeOf(DocExplorer)).call(this));
-
-	    _this.handleNavBackClick = function () {
-	      _this.setState({ navStack: _this.state.navStack.slice(0, -1) });
-	    };
-
-	    _this.handleClickTypeOrField = function (typeOrField) {
-	      _this.showDoc(typeOrField);
-	    };
-
-	    _this.handleSearch = function (value) {
-	      _this.showSearch({
-	        name: 'Search Results',
-	        searchValue: value
-	      });
-	    };
-
-	    _this.state = { navStack: [] };
-	    return _this;
-	  }
-
-	  _createClass(DocExplorer, [{
-	    key: 'shouldComponentUpdate',
-	    value: function shouldComponentUpdate(nextProps, nextState) {
-	      return this.props.schema !== nextProps.schema || this.state.navStack !== nextState.navStack || this.state.searchValue !== nextState.searchValue;
-	    }
-	  }, {
-	    key: 'render',
-	    value: function render() {
-	      var schema = this.props.schema;
-	      var navStack = this.state.navStack;
-
-	      var navItem = void 0;
-	      if (navStack.length > 0) {
-	        navItem = navStack[navStack.length - 1];
-	      }
-
-	      var title = void 0;
-	      var content = void 0;
-	      if (navItem) {
-	        if (navItem.name === 'Search Results') {
-	          title = navItem.name;
-	          content = _react2.default.createElement(SearchDoc, {
-	            searchValue: navItem.searchValue,
-	            schema: schema,
-	            onClickType: this.handleClickTypeOrField,
-	            onClickField: this.handleClickTypeOrField
-	          });
-	        } else {
-	          title = navItem.name;
-	          if ((0, _graphql.isType)(navItem)) {
-	            content = _react2.default.createElement(TypeDoc, {
-	              key: navItem.name,
-	              schema: schema,
-	              type: navItem,
-	              onClickType: this.handleClickTypeOrField,
-	              onClickField: this.handleClickTypeOrField
-	            });
-	          } else {
-	            content = _react2.default.createElement(FieldDoc, {
-	              key: navItem.name,
-	              field: navItem,
-	              onClickType: this.handleClickTypeOrField
-	            });
-	          }
-	        }
-	      } else if (schema) {
-	        title = 'Documentation Explorer';
-	        content = _react2.default.createElement(SchemaDoc, { schema: schema, onClickType: this.handleClickTypeOrField });
-	      }
-
-	      var prevName = void 0;
-	      if (navStack.length === 1) {
-	        prevName = 'Schema';
-	      } else if (navStack.length > 1) {
-	        prevName = navStack[navStack.length - 2].name;
-	      }
-
-	      var spinnerDiv = _react2.default.createElement(
-	        'div',
-	        { className: 'spinner-container' },
-	        _react2.default.createElement('div', { className: 'spinner' })
-	      );
-
-	      var shouldSearchBoxAppear = content && (content.type === SearchDoc || content.type === SchemaDoc);
-
-	      return _react2.default.createElement(
-	        'div',
-	        { className: 'doc-explorer' },
-	        _react2.default.createElement(
-	          'div',
-	          { className: 'doc-explorer-title-bar' },
-	          prevName && _react2.default.createElement(
-	            'div',
-	            {
-	              className: 'doc-explorer-back',
-	              onClick: this.handleNavBackClick },
-	            prevName
-	          ),
-	          _react2.default.createElement(
-	            'div',
-	            { className: 'doc-explorer-title' },
-	            title
-	          ),
-	          _react2.default.createElement(
-	            'div',
-	            { className: 'doc-explorer-rhs' },
-	            this.props.children
-	          )
-	        ),
-	        _react2.default.createElement(
-	          'div',
-	          { className: 'doc-explorer-contents' },
-	          _react2.default.createElement(SearchBox, {
-	            isShown: shouldSearchBoxAppear,
-	            onSearch: this.handleSearch
-	          }),
-	          this.props.schema ? content : spinnerDiv
-	        )
-	      );
-	    }
-
-	    // Public API
-
-	  }, {
-	    key: 'showDoc',
-	    value: function showDoc(typeOrField) {
-	      var navStack = this.state.navStack;
-	      var isCurrentlyShown = navStack.length > 0 && navStack[navStack.length - 1] === typeOrField;
-	      if (!isCurrentlyShown) {
-	        navStack = navStack.concat([typeOrField]);
-	      }
-
-	      this.setState({ navStack: navStack });
-	    }
-
-	    // Public API
-
-	  }, {
-	    key: 'showSearch',
-	    value: function showSearch(searchItem) {
-	      var navStack = this.state.navStack;
-	      var lastEntry = navStack.length > 0 && navStack[navStack.length - 1];
-	      if (!lastEntry) {
-	        navStack = navStack.concat([searchItem]);
-	      } else if (lastEntry.searchValue !== searchItem.searchValue) {
-	        navStack = navStack.slice(0, -1).concat([searchItem]);
-	      }
-
-	      this.setState({ navStack: navStack });
-	    }
-	  }]);
-
-	  return DocExplorer;
-	}(_react2.default.Component);
-
-	DocExplorer.propTypes = {
-	  schema: _react.PropTypes.instanceOf(_graphql.GraphQLSchema)
-	};
-
-	var SearchBox = function (_React$Component2) {
-	  _inherits(SearchBox, _React$Component2);
-
-	  function SearchBox(props) {
-	    _classCallCheck(this, SearchBox);
-
-	    var _this2 = _possibleConstructorReturn(this, (SearchBox.__proto__ || Object.getPrototypeOf(SearchBox)).call(this, props));
-
-	    _this2.handleChange = function (event) {
-	      _this2.setState({ value: event.target.value });
-	      _this2._debouncedOnSearch();
-	    };
-
-	    _this2.state = { value: '' };
-
-	    _this2._debouncedOnSearch = (0, _debounce2.default)(200, function () {
-	      _this2.props.onSearch(_this2.state.value);
-	    });
-	    return _this2;
-	  }
-
-	  _createClass(SearchBox, [{
-	    key: 'shouldComponentUpdate',
-	    value: function shouldComponentUpdate(nextProps, nextState) {
-	      return nextProps.isShown !== this.props.isShown || nextState.value !== this.state.value;
-	    }
-	  }, {
-	    key: 'render',
-	    value: function render() {
-	      return _react2.default.createElement(
-	        'div',
-	        null,
-	        this.props.isShown && _react2.default.createElement(
-	          'label',
-	          { className: 'search-box-outer' },
-	          _react2.default.createElement('input', { className: 'search-box-input',
-	            onChange: this.handleChange,
-	            type: 'text',
-	            value: this.state.value,
-	            placeholder: 'Search the schema ...'
-	          })
-	        )
-	      );
-	    }
-	  }]);
-
-	  return SearchBox;
-	}(_react2.default.Component);
-
-	// Render Search Results
-
-
-	SearchBox.propTypes = {
-	  isShown: _react.PropTypes.bool,
-	  onSearch: _react.PropTypes.func
-	};
-
-	var SearchDoc = function (_React$Component3) {
-	  _inherits(SearchDoc, _React$Component3);
-
-	  function SearchDoc() {
-	    _classCallCheck(this, SearchDoc);
-
-	    return _possibleConstructorReturn(this, (SearchDoc.__proto__ || Object.getPrototypeOf(SearchDoc)).apply(this, arguments));
-	  }
-
-	  _createClass(SearchDoc, [{
-	    key: 'shouldComponentUpdate',
-	    value: function shouldComponentUpdate(nextProps) {
-	      return this.props.schema !== nextProps.schema || this.props.searchValue !== nextProps.searchValue;
-	    }
-	  }, {
-	    key: 'render',
-	    value: function render() {
-	      var _this4 = this;
-
-	      var searchValue = this.props.searchValue;
-	      var schema = this.props.schema;
-	      var onClickType = this.props.onClickType;
-	      var onClickField = this.props.onClickField;
-
-	      var typeMap = schema.getTypeMap();
-
-	      var matchedTypes = [];
-	      var matchedFields = [];
-
-	      var typeNames = Object.keys(typeMap);
-	      var _iteratorNormalCompletion = true;
-	      var _didIteratorError = false;
-	      var _iteratorError = undefined;
-
-	      try {
-	        var _loop = function _loop() {
-	          var typeName = _step.value;
-
-	          if (matchedTypes.length + matchedFields.length >= 100) {
-	            return 'break';
-	          }
-
-	          var type = typeMap[typeName];
-	          var matchedOn = [];
-	          if (_this4._isMatch(typeName, searchValue)) {
-	            matchedOn.push('Type Name');
-	          }
-
-	          if (matchedOn.length) {
-	            matchedTypes.push(_react2.default.createElement(
-	              'div',
-	              { className: 'doc-category-item' },
-	              _react2.default.createElement(TypeLink, { type: type, onClick: onClickType })
-	            ));
-	          }
-
-	          if (type.getFields) {
-	            (function () {
-	              var fields = type.getFields();
-	              Object.keys(fields).forEach(function (fieldName) {
-	                var field = fields[fieldName];
-	                if (_this4._isMatch(fieldName, searchValue)) {
-	                  matchedFields.push(_react2.default.createElement(
-	                    'div',
-	                    { className: 'doc-category-item' },
-	                    _react2.default.createElement(
-	                      'a',
-	                      { className: 'field-name',
-	                        onClick: function onClick(event) {
-	                          return onClickField(field, type, event);
-	                        } },
-	                      field.name
-	                    ),
-	                    ' on ',
-	                    _react2.default.createElement(TypeLink, { type: type, onClick: onClickType })
-	                  ));
-	                } else if (field.args && field.args.length) {
-	                  var matches = field.args.filter(function (arg) {
-	                    return _this4._isMatch(arg.name, searchValue);
-	                  });
-	                  if (matches.length > 0) {
-	                    matchedFields.push(_react2.default.createElement(
-	                      'div',
-	                      { className: 'doc-category-item' },
-	                      _react2.default.createElement(
-	                        'a',
-	                        { className: 'field-name',
-	                          onClick: function onClick(event) {
-	                            return onClickField(field, type, event);
-	                          } },
-	                        field.name
-	                      ),
-	                      '(',
-	                      _react2.default.createElement(
-	                        'span',
-	                        null,
-	                        matches.map(function (arg) {
-	                          return _react2.default.createElement(
-	                            'span',
-	                            { className: 'arg', key: arg.name },
-	                            _react2.default.createElement(
-	                              'span',
-	                              { className: 'arg-name' },
-	                              arg.name
-	                            ),
-	                            ': ',
-	                            _react2.default.createElement(TypeLink, { type: arg.type, onClick: onClickType })
-	                          );
-	                        })
-	                      ),
-	                      ')',
-	                      ' on ',
-	                      _react2.default.createElement(TypeLink, { type: type, onClick: onClickType })
-	                    ));
-	                  }
-	                }
-	              });
-	            })();
-	          }
-	        };
-
-	        for (var _iterator = typeNames[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-	          var _ret = _loop();
-
-	          if (_ret === 'break') break;
-	        }
-	      } catch (err) {
-	        _didIteratorError = true;
-	        _iteratorError = err;
-	      } finally {
-	        try {
-	          if (!_iteratorNormalCompletion && _iterator.return) {
-	            _iterator.return();
-	          }
-	        } finally {
-	          if (_didIteratorError) {
-	            throw _iteratorError;
-	          }
-	        }
-	      }
-
-	      if (matchedTypes.length === 0 && matchedFields.length === 0) {
-	        return _react2.default.createElement(
-	          'span',
-	          { className: 'doc-alert-text' },
-	          'No results found.'
-	        );
-	      }
-
-	      return _react2.default.createElement(
-	        'div',
-	        null,
-	        _react2.default.createElement(
-	          'div',
-	          { className: 'doc-category' },
-	          (matchedTypes.length > 0 || matchedFields.length > 0) && _react2.default.createElement(
-	            'div',
-	            { className: 'doc-category-title' },
-	            'search results'
-	          ),
-	          matchedTypes,
-	          matchedFields
-	        )
-	      );
-	    }
-	  }, {
-	    key: '_isMatch',
-	    value: function _isMatch(sourceText, searchValue) {
-	      try {
-	        var escaped = searchValue.replace(/[^_0-9A-Za-z]/g, function (ch) {
-	          return '\\' + ch;
-	        });
-	        return sourceText.search(new RegExp(escaped, 'i')) !== -1;
-	      } catch (e) {
-	        return sourceText.toLowerCase().indexOf(searchValue.toLowerCase()) !== -1;
-	      }
-	    }
-	  }]);
-
-	  return SearchDoc;
-	}(_react2.default.Component);
-
-	// Render the top level Schema
-
-
-	SearchDoc.propTypes = {
-	  schema: _react.PropTypes.object,
-	  searchValue: _react.PropTypes.string,
-	  onClickType: _react.PropTypes.func,
-	  onClickField: _react.PropTypes.func
-	};
-
-	var SchemaDoc = function (_React$Component4) {
-	  _inherits(SchemaDoc, _React$Component4);
-
-	  function SchemaDoc() {
-	    _classCallCheck(this, SchemaDoc);
-
-	    return _possibleConstructorReturn(this, (SchemaDoc.__proto__ || Object.getPrototypeOf(SchemaDoc)).apply(this, arguments));
-	  }
-
-	  _createClass(SchemaDoc, [{
-	    key: 'shouldComponentUpdate',
-	    value: function shouldComponentUpdate(nextProps) {
-	      return this.props.schema !== nextProps.schema;
-	    }
-	  }, {
-	    key: 'render',
-	    value: function render() {
-	      var schema = this.props.schema;
-	      var queryType = schema.getQueryType();
-	      var mutationType = schema.getMutationType && schema.getMutationType();
-	      var subscriptionType = schema.getSubscriptionType && schema.getSubscriptionType();
-
-	      return _react2.default.createElement(
-	        'div',
-	        null,
-	        _react2.default.createElement(MarkdownContent, {
-	          className: 'doc-type-description',
-	          markdown: 'A GraphQL schema provides a root type for each kind of operation.'
-	        }),
-	        _react2.default.createElement(
-	          'div',
-	          { className: 'doc-category' },
-	          _react2.default.createElement(
-	            'div',
-	            { className: 'doc-category-title' },
-	            'root types'
-	          ),
-	          _react2.default.createElement(
-	            'div',
-	            { className: 'doc-category-item' },
-	            _react2.default.createElement(
-	              'span',
-	              { className: 'keyword' },
-	              'query'
-	            ),
-	            ': ',
-	            _react2.default.createElement(TypeLink, { type: queryType, onClick: this.props.onClickType })
-	          ),
-	          mutationType && _react2.default.createElement(
-	            'div',
-	            { className: 'doc-category-item' },
-	            _react2.default.createElement(
-	              'span',
-	              { className: 'keyword' },
-	              'mutation'
-	            ),
-	            ': ',
-	            _react2.default.createElement(TypeLink, { type: mutationType, onClick: this.props.onClickType })
-	          ),
-	          subscriptionType && _react2.default.createElement(
-	            'div',
-	            { className: 'doc-category-item' },
-	            _react2.default.createElement(
-	              'span',
-	              { className: 'keyword' },
-	              'subscription'
-	            ),
-	            ': ',
-	            _react2.default.createElement(TypeLink, {
-	              type: subscriptionType,
-	              onClick: this.props.onClickType
-	            })
-	          )
-	        )
-	      );
-	    }
-	  }]);
-
-	  return SchemaDoc;
-	}(_react2.default.Component);
-
-	// Documentation for a Type
-
-
-	SchemaDoc.propTypes = {
-	  schema: _react.PropTypes.object,
-	  onClickType: _react.PropTypes.func
-	};
-
-	var TypeDoc = function (_React$Component5) {
-	  _inherits(TypeDoc, _React$Component5);
-
-	  function TypeDoc() {
-	    _classCallCheck(this, TypeDoc);
-
-	    return _possibleConstructorReturn(this, (TypeDoc.__proto__ || Object.getPrototypeOf(TypeDoc)).apply(this, arguments));
-	  }
-
-	  _createClass(TypeDoc, [{
-	    key: 'shouldComponentUpdate',
-	    value: function shouldComponentUpdate(nextProps) {
-	      return this.props.type !== nextProps.type || this.props.schema !== nextProps.schema;
-	    }
-	  }, {
-	    key: 'render',
-	    value: function render() {
-	      var schema = this.props.schema;
-	      var type = this.props.type;
-	      var onClickType = this.props.onClickType;
-	      var onClickField = this.props.onClickField;
-
-	      var typesTitle = void 0;
-	      var types = void 0;
-	      if (type instanceof _graphql.GraphQLUnionType) {
-	        typesTitle = 'possible types';
-	        types = schema.getPossibleTypes(type);
-	      } else if (type instanceof _graphql.GraphQLInterfaceType) {
-	        typesTitle = 'implementations';
-	        types = schema.getPossibleTypes(type);
-	      } else if (type instanceof _graphql.GraphQLObjectType) {
-	        typesTitle = 'implements';
-	        types = type.getInterfaces();
-	      }
-
-	      var typesDef = void 0;
-	      if (types && types.length > 0) {
-	        typesDef = _react2.default.createElement(
-	          'div',
-	          { className: 'doc-category' },
-	          _react2.default.createElement(
-	            'div',
-	            { className: 'doc-category-title' },
-	            typesTitle
-	          ),
-	          types.map(function (subtype) {
-	            return _react2.default.createElement(
-	              'div',
-	              { key: subtype.name, className: 'doc-category-item' },
-	              _react2.default.createElement(TypeLink, { type: subtype, onClick: onClickType })
-	            );
-	          })
-	        );
-	      }
-
-	      // InputObject and Object
-	      var fieldsDef = void 0;
-	      if (type.getFields) {
-	        (function () {
-	          var fieldMap = type.getFields();
-	          var fields = Object.keys(fieldMap).map(function (name) {
-	            return fieldMap[name];
-	          });
-	          fieldsDef = _react2.default.createElement(
-	            'div',
-	            { className: 'doc-category' },
-	            _react2.default.createElement(
-	              'div',
-	              { className: 'doc-category-title' },
-	              'fields'
-	            ),
-	            fields.map(function (field) {
-
-	              // Field arguments
-	              var argsDef = void 0;
-	              if (field.args && field.args.length > 0) {
-	                argsDef = field.args.map(function (arg) {
-	                  return _react2.default.createElement(
-	                    'span',
-	                    { className: 'arg', key: arg.name },
-	                    _react2.default.createElement(
-	                      'span',
-	                      { className: 'arg-name' },
-	                      arg.name
-	                    ),
-	                    ': ',
-	                    _react2.default.createElement(TypeLink, { type: arg.type, onClick: onClickType })
-	                  );
-	                });
-	              }
-
-	              return _react2.default.createElement(
-	                'div',
-	                { key: field.name, className: 'doc-category-item' },
-	                _react2.default.createElement(
-	                  'a',
-	                  {
-	                    className: 'field-name',
-	                    onClick: function onClick(event) {
-	                      return onClickField(field, type, event);
-	                    } },
-	                  field.name
-	                ),
-	                argsDef && ['(', _react2.default.createElement(
-	                  'span',
-	                  { key: 'args' },
-	                  argsDef
-	                ), ')'],
-	                ': ',
-	                _react2.default.createElement(TypeLink, { type: field.type, onClick: onClickType }),
-	                (field.isDeprecated || field.deprecationReason) && _react2.default.createElement(
-	                  'span',
-	                  { className: 'doc-alert-text' },
-	                  ' (DEPRECATED)'
-	                )
-	              );
-	            })
-	          );
-	        })();
-	      }
-
-	      var valuesDef = void 0;
-	      if (type instanceof _graphql.GraphQLEnumType) {
-	        valuesDef = _react2.default.createElement(
-	          'div',
-	          { className: 'doc-category' },
-	          _react2.default.createElement(
-	            'div',
-	            { className: 'doc-category-title' },
-	            'values'
-	          ),
-	          type.getValues().map(function (value) {
-	            return _react2.default.createElement(
-	              'div',
-	              { key: value.name, className: 'doc-category-item' },
-	              _react2.default.createElement(
-	                'div',
-	                { className: 'enum-value' },
-	                value.name,
-	                (value.isDeprecated || value.deprecationReason) && _react2.default.createElement(
-	                  'span',
-	                  { className: 'doc-alert-text' },
-	                  ' (DEPRECATED)'
-	                )
-	              ),
-	              _react2.default.createElement(MarkdownContent, {
-	                className: 'doc-value-description',
-	                markdown: value.description
-	              }),
-	              value.deprecationReason && _react2.default.createElement(MarkdownContent, {
-	                className: 'doc-alert-text',
-	                markdown: value.deprecationReason
-	              })
-	            );
-	          })
-	        );
-	      }
-
-	      return _react2.default.createElement(
-	        'div',
-	        null,
-	        _react2.default.createElement(MarkdownContent, {
-	          className: 'doc-type-description',
-	          markdown: type.description || 'No Description'
-	        }),
-	        type instanceof _graphql.GraphQLObjectType && typesDef,
-	        fieldsDef,
-	        valuesDef,
-	        !(type instanceof _graphql.GraphQLObjectType) && typesDef
-	      );
-	    }
-	  }]);
-
-	  return TypeDoc;
-	}(_react2.default.Component);
-
-	// Documentation for a field
-
-
-	TypeDoc.propTypes = {
-	  schema: _react.PropTypes.instanceOf(_graphql.GraphQLSchema),
-	  type: _react.PropTypes.object,
-	  onClickType: _react.PropTypes.func,
-	  onClickField: _react.PropTypes.func
-	};
-
-	var FieldDoc = function (_React$Component6) {
-	  _inherits(FieldDoc, _React$Component6);
-
-	  function FieldDoc() {
-	    _classCallCheck(this, FieldDoc);
-
-	    return _possibleConstructorReturn(this, (FieldDoc.__proto__ || Object.getPrototypeOf(FieldDoc)).apply(this, arguments));
-	  }
-
-	  _createClass(FieldDoc, [{
-	    key: 'shouldComponentUpdate',
-	    value: function shouldComponentUpdate(nextProps) {
-	      return this.props.field !== nextProps.field;
-	    }
-	  }, {
-	    key: 'render',
-	    value: function render() {
-	      var _this8 = this;
-
-	      var field = this.props.field;
-
-	      var argsDef = void 0;
-	      if (field.args && field.args.length > 0) {
-	        argsDef = _react2.default.createElement(
-	          'div',
-	          { className: 'doc-category' },
-	          _react2.default.createElement(
-	            'div',
-	            { className: 'doc-category-title' },
-	            'arguments'
-	          ),
-	          field.args.map(function (arg) {
-	            return _react2.default.createElement(
-	              'div',
-	              { key: arg.name, className: 'doc-category-item' },
-	              _react2.default.createElement(
-	                'div',
-	                null,
-	                _react2.default.createElement(
-	                  'span',
-	                  { className: 'arg-name' },
-	                  arg.name
-	                ),
-	                ': ',
-	                _react2.default.createElement(TypeLink, { type: arg.type, onClick: _this8.props.onClickType })
-	              ),
-	              _react2.default.createElement(MarkdownContent, {
-	                className: 'doc-value-description',
-	                markdown: arg.description
-	              })
-	            );
-	          })
-	        );
-	      }
-
-	      return _react2.default.createElement(
-	        'div',
-	        null,
-	        _react2.default.createElement(MarkdownContent, {
-	          className: 'doc-type-description',
-	          markdown: field.description || 'No Description'
-	        }),
-	        field.deprecationReason && _react2.default.createElement(MarkdownContent, {
-	          className: 'doc-alert-text',
-	          markdown: field.deprecationReason
-	        }),
-	        _react2.default.createElement(
-	          'div',
-	          { className: 'doc-category' },
-	          _react2.default.createElement(
-	            'div',
-	            { className: 'doc-category-title' },
-	            'type'
-	          ),
-	          _react2.default.createElement(TypeLink, { type: field.type, onClick: this.props.onClickType })
-	        ),
-	        argsDef
-	      );
-	    }
-	  }]);
-
-	  return FieldDoc;
-	}(_react2.default.Component);
-
-	// Renders a type link
-
-
-	FieldDoc.propTypes = {
-	  field: _react.PropTypes.object,
-	  onClickType: _react.PropTypes.func
-	};
-
-	var TypeLink = function (_React$Component7) {
-	  _inherits(TypeLink, _React$Component7);
-
-	  function TypeLink() {
-	    _classCallCheck(this, TypeLink);
-
-	    return _possibleConstructorReturn(this, (TypeLink.__proto__ || Object.getPrototypeOf(TypeLink)).apply(this, arguments));
-	  }
-
-	  _createClass(TypeLink, [{
-	    key: 'shouldComponentUpdate',
-	    value: function shouldComponentUpdate(nextProps) {
-	      return this.props.type !== nextProps.type;
-	    }
-	  }, {
-	    key: 'render',
-	    value: function render() {
-	      return renderType(this.props.type, this.props.onClick);
-	    }
-	  }]);
-
-	  return TypeLink;
-	}(_react2.default.Component);
-
-	TypeLink.propTypes = {
-	  type: _react.PropTypes.object,
-	  onClick: _react.PropTypes.func
-	};
-
-
-	function renderType(type, _onClick) {
-	  if (type instanceof _graphql.GraphQLNonNull) {
-	    return _react2.default.createElement(
-	      'span',
-	      null,
-	      renderType(type.ofType, _onClick),
-	      '!'
-	    );
-	  }
-	  if (type instanceof _graphql.GraphQLList) {
-	    return _react2.default.createElement(
-	      'span',
-	      null,
-	      '[',
-	      renderType(type.ofType, _onClick),
-	      ']'
-	    );
-	  }
-	  return _react2.default.createElement(
-	    'a',
-	    { className: 'type-name', onClick: function onClick(event) {
-	        return _onClick(type, event);
-	      } },
-	    type.name
-	  );
-	}
-
-	// Renders arbitrary markdown content
-
-	var MarkdownContent = function (_React$Component8) {
-	  _inherits(MarkdownContent, _React$Component8);
-
-	  function MarkdownContent() {
-	    _classCallCheck(this, MarkdownContent);
-
-	    return _possibleConstructorReturn(this, (MarkdownContent.__proto__ || Object.getPrototypeOf(MarkdownContent)).apply(this, arguments));
-	  }
-
-	  _createClass(MarkdownContent, [{
-	    key: 'shouldComponentUpdate',
-	    value: function shouldComponentUpdate(nextProps) {
-	      return this.props.markdown !== nextProps.markdown;
-	    }
-	  }, {
-	    key: 'render',
-	    value: function render() {
-	      var markdown = this.props.markdown;
-	      if (!markdown) {
-	        return _react2.default.createElement('div', null);
-	      }
-
-	      var html = (0, _marked2.default)(markdown, { sanitize: true });
-	      return _react2.default.createElement('div', {
-	        className: this.props.className,
-	        dangerouslySetInnerHTML: { __html: html }
-	      });
-	    }
-	  }]);
-
-	  return MarkdownContent;
-	}(_react2.default.Component);
-
-	MarkdownContent.propTypes = {
-	  markdown: _react.PropTypes.string,
-	  className: _react.PropTypes.string
-	};
-
-/***/ },
-/* 300 */
-/***/ function(module, exports) {
-
-	"use strict";
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.default = debounce;
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the license found in the
-	 *  LICENSE-examples file in the root directory of this source tree.
-	 */
-
-	/**
-	 * Provided a duration and a function, returns a new function which is called
-	 * `duration` milliseconds after the last call.
-	 */
-	function debounce(duration, fn) {
-	  var timeout = void 0;
-	  return function () {
-	    var _this = this,
-	        _arguments = arguments;
-
-	    clearTimeout(timeout);
-	    timeout = setTimeout(function () {
-	      timeout = null;
-	      fn.apply(_this, _arguments);
-	    }, duration);
-	  };
-	}
-
-/***/ },
-/* 301 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-
-	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /**
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      *  Copyright (c) 2015, Facebook, Inc.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      *  All rights reserved.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      *
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      *  This source code is licensed under the license found in the
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      *  LICENSE-examples file in the root directory of this source tree.
-	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      */
-
-	var _reactDom = __webpack_require__(32);
-
-	var _reactDom2 = _interopRequireDefault(_reactDom);
-
-	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-	/**
-	 * When a containing DOM node's height has been altered, trigger a resize of
-	 * the related CodeMirror instance so that it is always correctly sized.
-	 */
-	var CodeMirrorSizer = function () {
-	  function CodeMirrorSizer() {
-	    _classCallCheck(this, CodeMirrorSizer);
-
-	    this.sizes = [];
-	  }
-
-	  _createClass(CodeMirrorSizer, [{
-	    key: 'updateSizes',
-	    value: function updateSizes(components) {
-	      var _this = this;
-
-	      components.forEach(function (component, i) {
-	        var size = _reactDom2.default.findDOMNode(component).clientHeight;
-	        if (i <= _this.sizes.length && size !== _this.sizes[i]) {
-	          component.getCodeMirror().setSize();
-	        }
-	        _this.sizes[i] = size;
-	      });
-	    }
-	  }]);
-
-	  return CodeMirrorSizer;
-	}();
-
-	exports.default = CodeMirrorSizer;
-
-/***/ },
-/* 302 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.default = getQueryFacts;
-	exports.collectVariables = collectVariables;
-
-	var _graphql = __webpack_require__(185);
-
-	/**
-	 * Provided previous "queryFacts", a GraphQL schema, and a query document
-	 * string, return a set of facts about that query useful for GraphiQL features.
-	 *
-	 * If the query cannot be parsed, returns undefined.
-	 */
-	function getQueryFacts(schema, documentStr) {
-	  if (!documentStr) {
-	    return;
-	  }
-
-	  var documentAST = void 0;
-	  try {
-	    documentAST = (0, _graphql.parse)(documentStr);
-	  } catch (e) {
-	    return;
-	  }
-
-	  var variableToType = schema ? collectVariables(schema, documentAST) : null;
-
-	  // Collect operations by their names.
-	  var operations = [];
-	  documentAST.definitions.forEach(function (def) {
-	    if (def.kind === 'OperationDefinition') {
-	      operations.push(def);
-	    }
-	  });
-
-	  return { variableToType: variableToType, operations: operations };
-	}
-
-	/**
-	 * Provided a schema and a document, produces a `variableToType` Object.
-	 */
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the license found in the
-	 *  LICENSE-examples file in the root directory of this source tree.
-	 */
-
-	function collectVariables(schema, documentAST) {
-	  var variableToType = Object.create(null);
-	  documentAST.definitions.forEach(function (definition) {
-	    if (definition.kind === 'OperationDefinition') {
-	      var variableDefinitions = definition.variableDefinitions;
-	      if (variableDefinitions) {
-	        variableDefinitions.forEach(function (_ref) {
-	          var variable = _ref.variable,
-	              type = _ref.type;
-
-	          var inputType = (0, _graphql.typeFromAST)(schema, type);
-	          if (inputType) {
-	            variableToType[variable.name.value] = inputType;
-	          }
-	        });
-	      }
-	    }
-	  });
-	  return variableToType;
-	}
-
-/***/ },
-/* 303 */
-/***/ function(module, exports) {
-
-	"use strict";
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.default = getSelectedOperationName;
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the license found in the
-	 *  LICENSE-examples file in the root directory of this source tree.
-	 */
-
-	/**
-	 * Provided optional previous operations and selected name, and a next list of
-	 * operations, determine what the next selected operation should be.
-	 */
-	function getSelectedOperationName(prevOperations, prevSelectedOperationName, operations) {
-	  // If there are not enough operations to bother with, return nothing.
-	  if (!operations || operations.length < 1) {
-	    return;
-	  }
-
-	  // If a previous selection still exists, continue to use it.
-	  var names = operations.map(function (op) {
-	    return op.name && op.name.value;
-	  });
-	  if (prevSelectedOperationName && names.indexOf(prevSelectedOperationName) !== -1) {
-	    return prevSelectedOperationName;
-	  }
-
-	  // If a previous selection was the Nth operation, use the same Nth.
-	  if (prevSelectedOperationName && prevOperations) {
-	    var prevNames = prevOperations.map(function (op) {
-	      return op.name && op.name.value;
-	    });
-	    var prevIndex = prevNames.indexOf(prevSelectedOperationName);
-	    if (prevIndex && prevIndex < names.length) {
-	      return names[prevIndex];
-	    }
-	  }
-
-	  // Use the first operation.
-	  return names[0];
-	}
-
-/***/ },
-/* 304 */
-/***/ function(module, exports) {
-
-	"use strict";
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.default = find;
-
-	/* eslint-disable no-undef */
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the BSD-style license found in the
-	 *  LICENSE file in the root directory of this source tree. An additional grant
-	 *  of patent rights can be found in the PATENTS file in the same directory.
-	 */
-
-	function find(list, predicate) {
-	  for (var i = 0; i < list.length; i++) {
-	    if (predicate(list[i])) {
-	      return list[i];
-	    }
-	  }
-	}
-
-/***/ },
-/* 305 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.fillLeafs = fillLeafs;
-
-	var _graphql = __webpack_require__(185);
-
-	/**
-	 * Given a document string which may not be valid due to terminal fields not
-	 * representing leaf values (Spec Section: "Leaf Field Selections"), and a
-	 * function which provides reasonable default field names for a given type,
-	 * this function will attempt to produce a schema which is valid after filling
-	 * in selection sets for the invalid fields.
-	 *
-	 * Note that there is no guarantee that the result will be a valid query, this
-	 * utility represents a "best effort" which may be useful within IDE tools.
-	 */
-	function fillLeafs(schema, docString, getDefaultFieldNames) {
-	  var insertions = [];
-
-	  if (!schema) {
-	    return { insertions: insertions, result: docString };
-	  }
-
-	  var ast = void 0;
-	  try {
-	    ast = (0, _graphql.parse)(docString);
-	  } catch (error) {
-	    return { insertions: insertions, result: docString };
-	  }
-
-	  var fieldNameFn = getDefaultFieldNames || defaultGetDefaultFieldNames;
-	  var typeInfo = new _graphql.TypeInfo(schema);
-	  (0, _graphql.visit)(ast, {
-	    leave: function leave(node) {
-	      typeInfo.leave(node);
-	    },
-	    enter: function enter(node) {
-	      typeInfo.enter(node);
-	      if (node.kind === 'Field' && !node.selectionSet) {
-	        var fieldType = typeInfo.getType();
-	        var selectionSet = buildSelectionSet(fieldType, fieldNameFn);
-	        if (selectionSet) {
-	          var indent = getIndentation(docString, node.loc.start);
-	          insertions.push({
-	            index: node.loc.end,
-	            string: ' ' + (0, _graphql.print)(selectionSet).replace(/\n/g, '\n' + indent)
-	          });
-	        }
-	      }
-	    }
-	  });
-
-	  // Apply the insertions, but also return the insertions metadata.
-	  return {
-	    insertions: insertions,
-	    result: withInsertions(docString, insertions)
-	  };
-	}
-
-	// The default function to use for producing the default fields from a type.
-	// This function first looks for some common patterns, and falls back to
-	// including all leaf-type fields.
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the license found in the
-	 *  LICENSE-examples file in the root directory of this source tree.
-	 */
-
-	function defaultGetDefaultFieldNames(type) {
-	  // If this type cannot access fields, then return an empty set.
-	  if (!type.getFields) {
-	    return [];
-	  }
-
-	  var fields = type.getFields();
-
-	  // Is there an `id` field?
-	  if (fields['id']) {
-	    return ['id'];
-	  }
-
-	  // Is there an `edges` field?
-	  if (fields['edges']) {
-	    return ['edges'];
-	  }
-
-	  // Is there an `node` field?
-	  if (fields['node']) {
-	    return ['node'];
-	  }
-
-	  // Include all leaf-type fields.
-	  var leafFieldNames = [];
-	  Object.keys(fields).forEach(function (fieldName) {
-	    if ((0, _graphql.isLeafType)(fields[fieldName].type)) {
-	      leafFieldNames.push(fieldName);
-	    }
-	  });
-	  return leafFieldNames;
-	}
-
-	// Given a GraphQL type, and a function which produces field names, recursively
-	// generate a SelectionSet which includes default fields.
-	function buildSelectionSet(type, getDefaultFieldNames) {
-	  // Unwrap any non-null or list types.
-	  var namedType = (0, _graphql.getNamedType)(type);
-
-	  // Unknown types and leaf types do not have selection sets.
-	  if (!type || (0, _graphql.isLeafType)(type)) {
-	    return;
-	  }
-
-	  // Get an array of field names to use.
-	  var fieldNames = getDefaultFieldNames(namedType);
-
-	  // If there are no field names to use, return no selection set.
-	  if (!Array.isArray(fieldNames) || fieldNames.length === 0) {
-	    return;
-	  }
-
-	  // Build a selection set of each field, calling buildSelectionSet recursively.
-	  return {
-	    kind: 'SelectionSet',
-	    selections: fieldNames.map(function (fieldName) {
-	      var fieldDef = namedType.getFields()[fieldName];
-	      var fieldType = fieldDef ? fieldDef.type : null;
-	      return {
-	        kind: 'Field',
-	        name: {
-	          kind: 'Name',
-	          value: fieldName
-	        },
-	        selectionSet: buildSelectionSet(fieldType, getDefaultFieldNames)
-	      };
-	    })
-	  };
-	}
-
-	// Given an initial string, and a list of "insertion" { index, string } objects,
-	// return a new string with these insertions applied.
-	function withInsertions(initial, insertions) {
-	  if (insertions.length === 0) {
-	    return initial;
-	  }
-	  var edited = '';
-	  var prevIndex = 0;
-	  insertions.forEach(function (_ref) {
-	    var index = _ref.index,
-	        string = _ref.string;
-
-	    edited += initial.slice(prevIndex, index) + string;
-	    prevIndex = index;
-	  });
-	  edited += initial.slice(prevIndex);
-	  return edited;
-	}
-
-	// Given a string and an index, look backwards to find the string of whitespace
-	// following the next previous line break.
-	function getIndentation(str, index) {
-	  var indentStart = index;
-	  var indentEnd = index;
-	  while (indentStart) {
-	    var c = str.charCodeAt(indentStart - 1);
-	    // line break
-	    if (c === 10 || c === 13 || c === 0x2028 || c === 0x2029) {
-	      break;
-	    }
-	    indentStart--;
-	    // not white space
-	    if (c !== 9 && c !== 11 && c !== 12 && c !== 32 && c !== 160) {
-	      indentEnd = indentStart;
-	    }
-	  }
-	  return str.substring(indentStart, indentEnd);
-	}
-
-/***/ },
-/* 306 */
-/***/ function(module, exports) {
-
-	"use strict";
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-	exports.getLeft = getLeft;
-	exports.getTop = getTop;
-	/**
-	 *  Copyright (c) 2015, Facebook, Inc.
-	 *  All rights reserved.
-	 *
-	 *  This source code is licensed under the license found in the
-	 *  LICENSE-examples file in the root directory of this source tree.
-	 */
-
-	/**
-	 * Utility functions to get a pixel distance from left/top of the window.
-	 */
-
-	function getLeft(initialElem) {
-	  var pt = 0;
-	  var elem = initialElem;
-	  while (elem.offsetParent) {
-	    pt += elem.offsetLeft;
-	    elem = elem.offsetParent;
-	  }
-	  return pt;
-	}
-
-	function getTop(initialElem) {
-	  var pt = 0;
-	  var elem = initialElem;
-	  while (elem.offsetParent) {
-	    pt += elem.offsetTop;
-	    elem = elem.offsetParent;
-	  }
-	  return pt;
-	}
-
-/***/ },
-/* 307 */
-/***/ function(module, exports, __webpack_require__) {
-
-	'use strict';
-
-	Object.defineProperty(exports, "__esModule", {
-	  value: true
-	});
-
-	var _graphql = __webpack_require__(185);
-
-	Object.defineProperty(exports, 'introspectionQuery', {
-	  enumerable: true,
-	  get: function get() {
-	    return _graphql.introspectionQuery;
-	  }
-	});
-
-
-	// Some GraphQL services do not support subscriptions and fail an introspection
-	// query which includes the `subscriptionType` field as the stock introspection
-	// query does. This backup query removes that field.
-	var introspectionQuerySansSubscriptions = exports.introspectionQuerySansSubscriptions = '\n  query IntrospectionQuery {\n    __schema {\n      queryType { name }\n      mutationType { name }\n      types {\n        ...FullType\n      }\n      directives {\n        name\n        description\n        locations\n        args {\n          ...InputValue\n        }\n      }\n    }\n  }\n\n  fragment FullType on __Type {\n    kind\n    name\n    description\n    fields(includeDeprecated: true) {\n      name\n      description\n      args {\n        ...InputValue\n      }\n      type {\n        ...TypeRef\n      }\n      isDeprecated\n      deprecationReason\n    }\n    inputFields {\n      ...InputValue\n    }\n    interfaces {\n      ...TypeRef\n    }\n    enumValues(includeDeprecated: true) {\n      name\n      description\n      isDeprecated\n      deprecationReason\n    }\n    possibleTypes {\n      ...TypeRef\n    }\n  }\n\n  fragment InputValue on __InputValue {\n    name\n    description\n    type { ...TypeRef }\n    defaultValue\n  }\n\n  fragment TypeRef on __Type {\n    kind\n    name\n    ofType {\n      kind\n      name\n      ofType {\n        kind\n        name\n        ofType {\n          kind\n          name\n          ofType {\n            kind\n            name\n            ofType {\n              kind\n              name\n              ofType {\n                kind\n                name\n                ofType {\n                  kind\n                  name\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n';
-
-/***/ },
-/* 308 */
-/***/ function(module, exports, __webpack_require__) {
-
-	// the whatwg-fetch polyfill installs the fetch() function
-	// on the global object (window or self)
-	//
-	// Return that as the export for use in Webpack, Browserify etc.
-	__webpack_require__(309);
-	module.exports = self.fetch.bind(self);
-
-
-/***/ },
-/* 309 */
-/***/ function(module, exports) {
-
-	(function(self) {
-	  'use strict';
-
-	  if (self.fetch) {
-	    return
-	  }
-
-	  var support = {
-	    searchParams: 'URLSearchParams' in self,
-	    iterable: 'Symbol' in self && 'iterator' in Symbol,
-	    blob: 'FileReader' in self && 'Blob' in self && (function() {
-	      try {
-	        new Blob()
-	        return true
-	      } catch(e) {
-	        return false
-	      }
-	    })(),
-	    formData: 'FormData' in self,
-	    arrayBuffer: 'ArrayBuffer' in self
-	  }
-
-	  if (support.arrayBuffer) {
-	    var viewClasses = [
-	      '[object Int8Array]',
-	      '[object Uint8Array]',
-	      '[object Uint8ClampedArray]',
-	      '[object Int16Array]',
-	      '[object Uint16Array]',
-	      '[object Int32Array]',
-	      '[object Uint32Array]',
-	      '[object Float32Array]',
-	      '[object Float64Array]'
-	    ]
-
-	    var isDataView = function(obj) {
-	      return obj && DataView.prototype.isPrototypeOf(obj)
-	    }
-
-	    var isArrayBufferView = ArrayBuffer.isView || function(obj) {
-	      return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
-	    }
-	  }
-
-	  function normalizeName(name) {
-	    if (typeof name !== 'string') {
-	      name = String(name)
-	    }
-	    if (/[^a-z0-9\-#$%&'*+.\^_`|~]/i.test(name)) {
-	      throw new TypeError('Invalid character in header field name')
-	    }
-	    return name.toLowerCase()
-	  }
-
-	  function normalizeValue(value) {
-	    if (typeof value !== 'string') {
-	      value = String(value)
-	    }
-	    return value
-	  }
-
-	  // Build a destructive iterator for the value list
-	  function iteratorFor(items) {
-	    var iterator = {
-	      next: function() {
-	        var value = items.shift()
-	        return {done: value === undefined, value: value}
-	      }
-	    }
-
-	    if (support.iterable) {
-	      iterator[Symbol.iterator] = function() {
-	        return iterator
-	      }
-	    }
-
-	    return iterator
-	  }
-
-	  function Headers(headers) {
-	    this.map = {}
-
-	    if (headers instanceof Headers) {
-	      headers.forEach(function(value, name) {
-	        this.append(name, value)
-	      }, this)
-
-	    } else if (headers) {
-	      Object.getOwnPropertyNames(headers).forEach(function(name) {
-	        this.append(name, headers[name])
-	      }, this)
-	    }
-	  }
-
-	  Headers.prototype.append = function(name, value) {
-	    name = normalizeName(name)
-	    value = normalizeValue(value)
-	    var oldValue = this.map[name]
-	    this.map[name] = oldValue ? oldValue+','+value : value
-	  }
-
-	  Headers.prototype['delete'] = function(name) {
-	    delete this.map[normalizeName(name)]
-	  }
-
-	  Headers.prototype.get = function(name) {
-	    name = normalizeName(name)
-	    return this.has(name) ? this.map[name] : null
-	  }
-
-	  Headers.prototype.has = function(name) {
-	    return this.map.hasOwnProperty(normalizeName(name))
-	  }
-
-	  Headers.prototype.set = function(name, value) {
-	    this.map[normalizeName(name)] = normalizeValue(value)
-	  }
-
-	  Headers.prototype.forEach = function(callback, thisArg) {
-	    for (var name in this.map) {
-	      if (this.map.hasOwnProperty(name)) {
-	        callback.call(thisArg, this.map[name], name, this)
-	      }
-	    }
-	  }
-
-	  Headers.prototype.keys = function() {
-	    var items = []
-	    this.forEach(function(value, name) { items.push(name) })
-	    return iteratorFor(items)
-	  }
-
-	  Headers.prototype.values = function() {
-	    var items = []
-	    this.forEach(function(value) { items.push(value) })
-	    return iteratorFor(items)
-	  }
-
-	  Headers.prototype.entries = function() {
-	    var items = []
-	    this.forEach(function(value, name) { items.push([name, value]) })
-	    return iteratorFor(items)
-	  }
-
-	  if (support.iterable) {
-	    Headers.prototype[Symbol.iterator] = Headers.prototype.entries
-	  }
-
-	  function consumed(body) {
-	    if (body.bodyUsed) {
-	      return Promise.reject(new TypeError('Already read'))
-	    }
-	    body.bodyUsed = true
-	  }
-
-	  function fileReaderReady(reader) {
-	    return new Promise(function(resolve, reject) {
-	      reader.onload = function() {
-	        resolve(reader.result)
-	      }
-	      reader.onerror = function() {
-	        reject(reader.error)
-	      }
-	    })
-	  }
-
-	  function readBlobAsArrayBuffer(blob) {
-	    var reader = new FileReader()
-	    var promise = fileReaderReady(reader)
-	    reader.readAsArrayBuffer(blob)
-	    return promise
-	  }
-
-	  function readBlobAsText(blob) {
-	    var reader = new FileReader()
-	    var promise = fileReaderReady(reader)
-	    reader.readAsText(blob)
-	    return promise
-	  }
-
-	  function readArrayBufferAsText(buf) {
-	    var view = new Uint8Array(buf)
-	    var chars = new Array(view.length)
-
-	    for (var i = 0; i < view.length; i++) {
-	      chars[i] = String.fromCharCode(view[i])
-	    }
-	    return chars.join('')
-	  }
-
-	  function bufferClone(buf) {
-	    if (buf.slice) {
-	      return buf.slice(0)
-	    } else {
-	      var view = new Uint8Array(buf.byteLength)
-	      view.set(new Uint8Array(buf))
-	      return view.buffer
-	    }
-	  }
-
-	  function Body() {
-	    this.bodyUsed = false
-
-	    this._initBody = function(body) {
-	      this._bodyInit = body
-	      if (!body) {
-	        this._bodyText = ''
-	      } else if (typeof body === 'string') {
-	        this._bodyText = body
-	      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
-	        this._bodyBlob = body
-	      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
-	        this._bodyFormData = body
-	      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
-	        this._bodyText = body.toString()
-	      } else if (support.arrayBuffer && support.blob && isDataView(body)) {
-	        this._bodyArrayBuffer = bufferClone(body.buffer)
-	        // IE 10-11 can't handle a DataView body.
-	        this._bodyInit = new Blob([this._bodyArrayBuffer])
-	      } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
-	        this._bodyArrayBuffer = bufferClone(body)
-	      } else {
-	        throw new Error('unsupported BodyInit type')
-	      }
-
-	      if (!this.headers.get('content-type')) {
-	        if (typeof body === 'string') {
-	          this.headers.set('content-type', 'text/plain;charset=UTF-8')
-	        } else if (this._bodyBlob && this._bodyBlob.type) {
-	          this.headers.set('content-type', this._bodyBlob.type)
-	        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
-	          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8')
-	        }
-	      }
-	    }
-
-	    if (support.blob) {
-	      this.blob = function() {
-	        var rejected = consumed(this)
-	        if (rejected) {
-	          return rejected
-	        }
-
-	        if (this._bodyBlob) {
-	          return Promise.resolve(this._bodyBlob)
-	        } else if (this._bodyArrayBuffer) {
-	          return Promise.resolve(new Blob([this._bodyArrayBuffer]))
-	        } else if (this._bodyFormData) {
-	          throw new Error('could not read FormData body as blob')
-	        } else {
-	          return Promise.resolve(new Blob([this._bodyText]))
-	        }
-	      }
-
-	      this.arrayBuffer = function() {
-	        if (this._bodyArrayBuffer) {
-	          return consumed(this) || Promise.resolve(this._bodyArrayBuffer)
-	        } else {
-	          return this.blob().then(readBlobAsArrayBuffer)
-	        }
-	      }
-	    }
-
-	    this.text = function() {
-	      var rejected = consumed(this)
-	      if (rejected) {
-	        return rejected
-	      }
-
-	      if (this._bodyBlob) {
-	        return readBlobAsText(this._bodyBlob)
-	      } else if (this._bodyArrayBuffer) {
-	        return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
-	      } else if (this._bodyFormData) {
-	        throw new Error('could not read FormData body as text')
-	      } else {
-	        return Promise.resolve(this._bodyText)
-	      }
-	    }
-
-	    if (support.formData) {
-	      this.formData = function() {
-	        return this.text().then(decode)
-	      }
-	    }
-
-	    this.json = function() {
-	      return this.text().then(JSON.parse)
-	    }
-
-	    return this
-	  }
-
-	  // HTTP methods whose capitalization should be normalized
-	  var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT']
-
-	  function normalizeMethod(method) {
-	    var upcased = method.toUpperCase()
-	    return (methods.indexOf(upcased) > -1) ? upcased : method
-	  }
-
-	  function Request(input, options) {
-	    options = options || {}
-	    var body = options.body
-
-	    if (typeof input === 'string') {
-	      this.url = input
-	    } else {
-	      if (input.bodyUsed) {
-	        throw new TypeError('Already read')
-	      }
-	      this.url = input.url
-	      this.credentials = input.credentials
-	      if (!options.headers) {
-	        this.headers = new Headers(input.headers)
-	      }
-	      this.method = input.method
-	      this.mode = input.mode
-	      if (!body && input._bodyInit != null) {
-	        body = input._bodyInit
-	        input.bodyUsed = true
-	      }
-	    }
-
-	    this.credentials = options.credentials || this.credentials || 'omit'
-	    if (options.headers || !this.headers) {
-	      this.headers = new Headers(options.headers)
-	    }
-	    this.method = normalizeMethod(options.method || this.method || 'GET')
-	    this.mode = options.mode || this.mode || null
-	    this.referrer = null
-
-	    if ((this.method === 'GET' || this.method === 'HEAD') && body) {
-	      throw new TypeError('Body not allowed for GET or HEAD requests')
-	    }
-	    this._initBody(body)
-	  }
-
-	  Request.prototype.clone = function() {
-	    return new Request(this, { body: this._bodyInit })
-	  }
-
-	  function decode(body) {
-	    var form = new FormData()
-	    body.trim().split('&').forEach(function(bytes) {
-	      if (bytes) {
-	        var split = bytes.split('=')
-	        var name = split.shift().replace(/\+/g, ' ')
-	        var value = split.join('=').replace(/\+/g, ' ')
-	        form.append(decodeURIComponent(name), decodeURIComponent(value))
-	      }
-	    })
-	    return form
-	  }
-
-	  function parseHeaders(rawHeaders) {
-	    var headers = new Headers()
-	    rawHeaders.split('\r\n').forEach(function(line) {
-	      var parts = line.split(':')
-	      var key = parts.shift().trim()
-	      if (key) {
-	        var value = parts.join(':').trim()
-	        headers.append(key, value)
-	      }
-	    })
-	    return headers
-	  }
-
-	  Body.call(Request.prototype)
-
-	  function Response(bodyInit, options) {
-	    if (!options) {
-	      options = {}
-	    }
-
-	    this.type = 'default'
-	    this.status = 'status' in options ? options.status : 200
-	    this.ok = this.status >= 200 && this.status < 300
-	    this.statusText = 'statusText' in options ? options.statusText : 'OK'
-	    this.headers = new Headers(options.headers)
-	    this.url = options.url || ''
-	    this._initBody(bodyInit)
-	  }
-
-	  Body.call(Response.prototype)
-
-	  Response.prototype.clone = function() {
-	    return new Response(this._bodyInit, {
-	      status: this.status,
-	      statusText: this.statusText,
-	      headers: new Headers(this.headers),
-	      url: this.url
-	    })
-	  }
-
-	  Response.error = function() {
-	    var response = new Response(null, {status: 0, statusText: ''})
-	    response.type = 'error'
-	    return response
-	  }
-
-	  var redirectStatuses = [301, 302, 303, 307, 308]
-
-	  Response.redirect = function(url, status) {
-	    if (redirectStatuses.indexOf(status) === -1) {
-	      throw new RangeError('Invalid status code')
-	    }
-
-	    return new Response(null, {status: status, headers: {location: url}})
-	  }
-
-	  self.Headers = Headers
-	  self.Request = Request
-	  self.Response = Response
-
-	  self.fetch = function(input, init) {
-	    return new Promise(function(resolve, reject) {
-	      var request = new Request(input, init)
-	      var xhr = new XMLHttpRequest()
-
-	      xhr.onload = function() {
-	        var options = {
-	          status: xhr.status,
-	          statusText: xhr.statusText,
-	          headers: parseHeaders(xhr.getAllResponseHeaders() || '')
-	        }
-	        options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL')
-	        var body = 'response' in xhr ? xhr.response : xhr.responseText
-	        resolve(new Response(body, options))
-	      }
-
-	      xhr.onerror = function() {
-	        reject(new TypeError('Network request failed'))
-	      }
-
-	      xhr.ontimeout = function() {
-	        reject(new TypeError('Network request failed'))
-	      }
-
-	      xhr.open(request.method, request.url, true)
-
-	      if (request.credentials === 'include') {
-	        xhr.withCredentials = true
-	      }
-
-	      if ('responseType' in xhr && support.blob) {
-	        xhr.responseType = 'blob'
-	      }
-
-	      request.headers.forEach(function(value, name) {
-	        xhr.setRequestHeader(name, value)
-	      })
-
-	      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit)
-	    })
-	  }
-	  self.fetch.polyfill = true
-	})(typeof self !== 'undefined' ? self : this);
-
-
-/***/ },
-/* 310 */
-/***/ function(module, exports, __webpack_require__) {
-
-	// style-loader: Adds some css to the DOM by adding a <style> tag
-
-	// load the styles
-	var content = __webpack_require__(311);
-	if(typeof content === 'string') content = [[module.id, content, '']];
-	// add the styles to the DOM
-	var update = __webpack_require__(313)(content, {});
-	if(content.locals) module.exports = content.locals;
-	// Hot Module Replacement
-	if(false) {
-		// When the styles change, update the <style> tags
-		if(!content.locals) {
-			module.hot.accept("!!./../css-loader/index.js!./graphiql.css", function() {
-				var newContent = require("!!./../css-loader/index.js!./graphiql.css");
-				if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
-				update(newContent);
-			});
-		}
-		// When the module is disposed, remove the <style> tags
-		module.hot.dispose(function() { update(); });
-	}
-
-/***/ },
-/* 311 */
-/***/ function(module, exports, __webpack_require__) {
-
-	exports = module.exports = __webpack_require__(312)();
-	// imports
-
-
-	// module
-	exports.push([module.id, ".graphiql-container {\n  color: #141823;\n  display: -webkit-flex;\n  display: -ms-flexbox;\n  -webkit-flex-direction: row;\n      -ms-flex-direction: row;\n          flex-direction: row;\n  font-family:\n    system,\n    -apple-system,\n    'San Francisco',\n    '.SFNSDisplay-Regular',\n    'Segoe UI',\n    Segoe,\n    'Segoe WP',\n    'Helvetica Neue',\n    helvetica,\n    'Lucida Grande',\n    arial,\n    sans-serif;\n  font-size: 14px;\n  height: 100%;\n  margin: 0;\n  overflow: hidden;\n  width: 100%;\n}\n\n.graphiql-container .editorWrap {\n  display: -webkit-flex;\n  display: -ms-flexbox;\n  display: -ms-flexbox;\n  -webkit-flex-direction: column;\n      -ms-flex-direction: column;\n          flex-direction: column;\n  -webkit-flex: 1;\n      -ms-flex: 1;\n          flex: 1;\n}\n\n.graphiql-container .title {\n  font-size: 18px;\n}\n\n.graphiql-container .title em {\n  font-family: georgia;\n  font-size: 19px;\n}\n\n.graphiql-container .topBarWrap {\n  display: -webkit-flex;\n  display: -ms-flexbox;\n  -webkit-flex-direction: row;\n      -ms-flex-direction: row;\n          flex-direction: row;\n}\n\n.graphiql-container .topBar {\n  -webkit-align-items: center;\n      -ms-align-items: center;\n          align-items: center;\n  background: -webkit-linear-gradient(#f7f7f7, #e2e2e2);\n  background:         linear-gradient(#f7f7f7, #e2e2e2);\n  border-bottom: 1px solid #d0d0d0;\n  cursor: default;\n  display: -webkit-flex;\n  display: -ms-flexbox;\n  height: 34px;\n  padding: 7px 14px 6px;\n  -webkit-flex: 1;\n      -ms-flex: 1;\n          flex: 1;\n  -webkit-flex-direction: row;\n      -ms-flex-direction: row;\n          flex-direction: row;\n  -webkit-user-select: none;\n      -ms-user-select: none;\n          user-select: none;\n}\n\n.graphiql-container .toolbar {\n  overflow-x: auto;\n}\n\n.graphiql-container .docExplorerShow {\n  background: -webkit-linear-gradient(#f7f7f7, #e2e2e2);\n  background:         linear-gradient(#f7f7f7, #e2e2e2);\n  border-bottom: 1px solid #d0d0d0;\n  border-left: 1px solid rgba(0, 0, 0, 0.2);\n  border-right: none;\n  border-top: none;\n  color: #3B5998;\n  cursor: pointer;\n  font-size: 14px;\n  outline: 0;\n  margin: 0;\n  padding: 2px 20px 0 18px;\n}\n\n.graphiql-container .docExplorerShow:before {\n  border-left: 2px solid #3B5998;\n  border-top: 2px solid #3B5998;\n  content: '';\n  display: inline-block;\n  height: 9px;\n  margin: 0 3px -1px 0;\n  position: relative;\n  -webkit-transform: rotate(-45deg);\n      -ms-transform: rotate(-45deg);\n          transform: rotate(-45deg);\n  width: 9px;\n}\n\n.graphiql-container .editorBar {\n  display: -webkit-flex;\n  display: -ms-flexbox;\n  -webkit-flex: 1;\n      -ms-flex: 1;\n          flex: 1;\n  -webkit-flex-direction: row;\n      -ms-flex-direction: row;\n          flex-direction: row;\n}\n\n.graphiql-container .queryWrap {\n  display: -webkit-flex;\n  display: -ms-flexbox;\n  -webkit-flex: 1;\n      -ms-flex: 1;\n          flex: 1;\n  -webkit-flex-direction: column;\n      -ms-flex-direction: column;\n          flex-direction: column;\n}\n\n.graphiql-container .resultWrap {\n  border-left: solid 1px #e0e0e0;\n  display: -webkit-flex;\n  display:         flex;\n  position: relative;\n  -webkit-flex: 1;\n      -ms-flex: 1;\n          flex: 1;\n  -webkit-flex-direction: column;\n      -ms-flex-direction: column;\n          flex-direction: column;\n}\n\n.graphiql-container .docExplorerWrap {\n  background: white;\n  box-shadow: 0 0 8px rgba(0, 0, 0, 0.15);\n  position: relative;\n  z-index: 3;\n}\n\n.graphiql-container .docExplorerResizer {\n  cursor: col-resize;\n  height: 100%;\n  left: -5px;\n  position: absolute;\n  top: 0;\n  width: 10px;\n  z-index: 10;\n}\n\n.graphiql-container .docExplorerHide {\n  cursor: pointer;\n  font-size: 18px;\n  margin: -7px -8px -6px 0;\n  padding: 18px 16px 15px 12px;\n}\n\n.graphiql-container .query-editor {\n  -webkit-flex: 1;\n      -ms-flex: 1;\n          flex: 1;\n  position: relative;\n}\n\n.graphiql-container .variable-editor {\n  display: -webkit-flex;\n  display:     -ms-flex;\n  display:         flex;\n  height: 29px;\n  -webkit-flex-direction: column;\n      -ms-flex-direction: column;\n          flex-direction: column;\n  position: relative;\n}\n\n.graphiql-container .variable-editor-title {\n  background: #eeeeee;\n  border-bottom: 1px solid #d6d6d6;\n  border-top: 1px solid #e0e0e0;\n  color: #777;\n  font-variant: small-caps;\n  font-weight: bold;\n  letter-spacing: 1px;\n  line-height: 14px;\n  padding: 6px 0 8px 43px;\n  text-transform: lowercase;\n  -webkit-user-select: none;\n      -ms-user-select: none;\n          user-select: none;\n}\n\n.graphiql-container .codemirrorWrap {\n  -webkit-flex: 1;\n      -ms-flex: 1;\n          flex: 1;\n  position: relative;\n  height: 100%;\n}\n\n.graphiql-container .result-window {\n  -webkit-flex: 1;\n      -ms-flex: 1;\n          flex: 1;\n  position: relative;\n  height: 100%;\n}\n\n.graphiql-container .footer {\n  background: #f6f7f8;\n  border-left: 1px solid #e0e0e0;\n  border-top: 1px solid #e0e0e0;\n  margin-left: 12px;\n  position: relative;\n}\n\n.graphiql-container .footer:before {\n  background: #eeeeee;\n  bottom: 0;\n  content: \" \";\n  left: -13px;\n  position: absolute;\n  top: -1px;\n  width: 12px;\n}\n\n.graphiql-container .result-window .CodeMirror {\n  background: #f6f7f8;\n}\n\n.graphiql-container .result-window .CodeMirror-gutters {\n  background-color: #eeeeee;\n  border-color: #e0e0e0;\n  cursor: col-resize;\n}\n\n.graphiql-container .result-window .CodeMirror-foldgutter,\n.graphiql-container .result-window .CodeMirror-foldgutter-open:after,\n.graphiql-container .result-window .CodeMirror-foldgutter-folded:after {\n  padding-left: 3px;\n}\n\n.graphiql-container .toolbar-button {\n  background: #fdfdfd;\n  background: -webkit-linear-gradient(#fbfbfb, #f8f8f8);\n  background:         linear-gradient(#fbfbfb, #f8f8f8);\n  border-width: 0.5px;\n  border-style: solid;\n  border-color: #d3d3d3 #d0d0d0 #bababa;\n  border-radius: 4px;\n  box-shadow: 0 1px 1px -1px rgba(0, 0, 0, 0.13), inset 0 1px #fff;\n  color: #444;\n  cursor: pointer;\n  display: inline-block;\n  margin: 0 5px 0;\n  padding: 2px 8px 4px;\n  text-decoration: none;\n}\n\n.graphiql-container .toolbar-button:active {\n  background: -webkit-linear-gradient(#ececec, #d8d8d8);\n  background:         linear-gradient(#ececec, #d8d8d8);\n  border-color: #cacaca #c9c9c9 #b0b0b0;\n  box-shadow:\n    0 1px 0 #fff,\n    inset 0 1px rgba(255, 255, 255, 0.2),\n    inset 0 1px 1px rgba(0, 0, 0, 0.08);\n}\n\n.graphiql-container .toolbar-button.error {\n  background: -webkit-linear-gradient(#fdf3f3, #e6d6d7);\n  background:         linear-gradient(#fdf3f3, #e6d6d7);\n  color: #b00;\n}\n\n.graphiql-container .execute-button-wrap {\n  position: relative;\n  margin: 0 14px 0 28px;\n  height: 34px;\n}\n\n.graphiql-container .execute-button {\n  background: -webkit-linear-gradient(#fdfdfd, #d2d3d6);\n  background:         linear-gradient(#fdfdfd, #d2d3d6);\n  border: 1px solid rgba(0,0,0,0.25);\n  border-radius: 17px;\n  box-shadow: 0 1px 0 #fff;\n  cursor: pointer;\n  fill: #444;\n  height: 34px;\n  margin: 0;\n  padding: 0;\n  width: 34px;\n}\n\n.graphiql-container .execute-button svg {\n  pointer-events: none;\n}\n\n.graphiql-container .execute-button:active {\n  background: -webkit-linear-gradient(#e6e6e6, #c0c0c0);\n  background:         linear-gradient(#e6e6e6, #c0c0c0);\n  box-shadow:\n    0 1px 0 #fff,\n    inset 0 0 2px rgba(0, 0, 0, 0.3),\n    inset 0 0 6px rgba(0, 0, 0, 0.2);\n}\n\n.graphiql-container .execute-button:focus {\n  outline: 0;\n}\n\n.graphiql-container .execute-options {\n  background: #fff;\n  box-shadow:\n    0 0 0 1px rgba(0,0,0,0.1),\n    0 2px 4px rgba(0,0,0,0.25);\n  left: -1px;\n  margin: 0;\n  padding: 8px 0;\n  position: absolute;\n  top: 37px;\n  z-index: 100;\n}\n\n.graphiql-container .execute-options li {\n  padding: 2px 30px 4px 10px;\n  list-style: none;\n  min-width: 100px;\n  cursor: pointer;\n}\n\n.graphiql-container .execute-options li.selected {\n  background: #e10098;\n  color: white;\n}\n\n.graphiql-container .CodeMirror-scroll {\n  -webkit-overflow-scrolling: touch;\n      -ms-overflow-scrolling: touch;\n}\n\n.graphiql-container .CodeMirror {\n  color: #141823;\n  font-family:\n    'Consolas',\n    'Inconsolata',\n    'Droid Sans Mono',\n    'Monaco',\n    monospace;\n  font-size: 13px;\n  height: 100%;\n  left: 0;\n  position: absolute;\n  top: 0;\n  width: 100%;\n}\n\n.graphiql-container .CodeMirror-lines {\n  padding: 20px 0;\n}\n\n.CodeMirror-hint-information .content {\n  -webkit-box-orient: vertical;\n      -ms-box-orient: vertical;\n          box-orient: vertical;\n  color: #141823;\n  display: -webkit-box;\n  font-family: system, -apple-system, 'San Francisco', '.SFNSDisplay-Regular', 'Segoe UI', Segoe, 'Segoe WP', 'Helvetica Neue', helvetica, 'Lucida Grande', arial, sans-serif;\n  font-size: 13px;\n  -webkit-line-clamp: 3;\n          line-clamp: 3;\n  line-height: 16px;\n  max-height: 48px;\n  overflow: hidden;\n  text-overflow: -o-ellipsis-lastline;\n}\n\n.CodeMirror-hint-information .content p:first-child {\n  margin-top: 0;\n}\n\n.CodeMirror-hint-information .content p:last-child {\n  margin-bottom: 0;\n}\n\n.CodeMirror-hint-information .infoType {\n  color: #30a;\n  cursor: pointer;\n  display: inline;\n  margin-right: 0.5em;\n}\n\n.autoInsertedLeaf.cm-property {\n  -webkit-animation-duration: 6s;\n     -moz-animation-duration: 6s;\n      -ms-animation-duration: 6s;\n          animation-duration: 6s;\n  -webkit-animation-name: insertionFade;\n     -moz-animation-name: insertionFade;\n      -ms-animation-name: insertionFade;\n          animation-name: insertionFade;\n  border-bottom: 2px solid rgba(255, 255, 255, 0);\n  border-radius: 2px;\n  margin: -2px -4px -1px;\n  padding: 2px 4px 1px;\n}\n\n@-moz-keyframes insertionFade {\n  from, to {\n    background: rgba(255, 255, 255, 0);\n    border-color: rgba(255, 255, 255, 0);\n  }\n\n  15%, 85% {\n    background: #fbffc9;\n    border-color: #f0f3c0;\n  }\n}\n\n@-webkit-keyframes insertionFade {\n  from, to {\n    background: rgba(255, 255, 255, 0);\n    border-color: rgba(255, 255, 255, 0);\n  }\n\n  15%, 85% {\n    background: #fbffc9;\n    border-color: #f0f3c0;\n  }\n}\n\n@keyframes insertionFade {\n  from, to {\n    background: rgba(255, 255, 255, 0);\n    border-color: rgba(255, 255, 255, 0);\n  }\n\n  15%, 85% {\n    background: #fbffc9;\n    border-color: #f0f3c0;\n  }\n}\n\ndiv.CodeMirror-lint-tooltip {\n  background-color: white;\n  border: 0;\n  border-radius: 2px;\n  color: #141823;\n  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.45);\n  font-family:\n    system,\n    -apple-system,\n    'San Francisco',\n    '.SFNSDisplay-Regular',\n    'Segoe UI',\n    Segoe,\n    'Segoe WP',\n    'Helvetica Neue',\n    helvetica,\n    'Lucida Grande',\n    arial,\n    sans-serif;\n  font-size: 13px;\n  line-height: 16px;\n  opacity: 0;\n  padding: 6px 10px;\n  -webkit-transition: opacity 0.15s;\n     -moz-transition: opacity 0.15s;\n      -ms-transition: opacity 0.15s;\n       -o-transition: opacity 0.15s;\n          transition: opacity 0.15s;\n}\n\ndiv.CodeMirror-lint-message-error, div.CodeMirror-lint-message-warning {\n  padding-left: 23px;\n}\n\n/* COLORS */\n\n.graphiql-container .CodeMirror-foldmarker {\n  border-radius: 4px;\n  background: #08f;\n  background: -webkit-linear-gradient(#43A8FF, #0F83E8);\n  background:    -moz-linear-gradient(#43A8FF, #0F83E8);\n  background:     -ms-linear-gradient(#43A8FF, #0F83E8);\n  background:         linear-gradient(#43A8FF, #0F83E8);\n  box-shadow:\n    0 1px 1px rgba(0, 0, 0, 0.2),\n    inset 0 0 0 1px rgba(0, 0, 0, 0.1);\n  color: white;\n  font-family: arial;\n  font-size: 12px;\n  line-height: 0;\n  margin: 0 3px;\n  padding: 0px 4px 1px;\n  text-shadow: 0 -1px rgba(0, 0, 0, 0.1);\n}\n\n.graphiql-container div.CodeMirror span.CodeMirror-matchingbracket {\n  color: #555;\n  text-decoration: underline;\n}\n\n.graphiql-container div.CodeMirror span.CodeMirror-nonmatchingbracket {\n  color: #f00;\n}\n\n/* Comment */\n.cm-comment {\n  color: #999;\n}\n\n/* Punctuation */\n.cm-punctuation {\n  color: #555;\n}\n\n/* Keyword */\n.cm-keyword {\n  color: #B11A04;\n}\n\n/* OperationName, FragmentName */\n.cm-def {\n  color: #D2054E;\n}\n\n/* FieldName */\n.cm-property {\n  color: #1F61A0;\n}\n\n/* FieldAlias */\n.cm-qualifier {\n  color: #1C92A9;\n}\n\n/* ArgumentName and ObjectFieldName */\n.cm-attribute {\n  color: #8B2BB9;\n}\n\n/* Number */\n.cm-number {\n  color: #2882F9;\n}\n\n/* String */\n.cm-string {\n  color: #D64292;\n}\n\n/* Boolean */\n.cm-builtin {\n  color: #D47509;\n}\n\n/* EnumValue */\n.cm-string-2 {\n  color: #0B7FC7;\n}\n\n/* Variable */\n.cm-variable {\n  color: #397D13;\n}\n\n/* Directive */\n.cm-meta {\n  color: #B33086;\n}\n\n/* Type */\n.cm-atom {\n  color: #CA9800;\n}\n/* BASICS */\n\n.CodeMirror {\n  /* Set height, width, borders, and global font properties here */\n  font-family: monospace;\n  height: 300px;\n  color: black;\n}\n\n/* PADDING */\n\n.CodeMirror-lines {\n  padding: 4px 0; /* Vertical padding around content */\n}\n.CodeMirror pre {\n  padding: 0 4px; /* Horizontal padding of content */\n}\n\n.CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {\n  background-color: white; /* The little square between H and V scrollbars */\n}\n\n/* GUTTER */\n\n.CodeMirror-gutters {\n  border-right: 1px solid #ddd;\n  background-color: #f7f7f7;\n  white-space: nowrap;\n}\n.CodeMirror-linenumbers {}\n.CodeMirror-linenumber {\n  padding: 0 3px 0 5px;\n  min-width: 20px;\n  text-align: right;\n  color: #999;\n  white-space: nowrap;\n}\n\n.CodeMirror-guttermarker { color: black; }\n.CodeMirror-guttermarker-subtle { color: #999; }\n\n/* CURSOR */\n\n.CodeMirror div.CodeMirror-cursor {\n  border-left: 1px solid black;\n}\n/* Shown when moving in bi-directional text */\n.CodeMirror div.CodeMirror-secondarycursor {\n  border-left: 1px solid silver;\n}\n.CodeMirror.cm-fat-cursor div.CodeMirror-cursor {\n  width: auto;\n  border: 0;\n  background: #7e7;\n}\n.CodeMirror.cm-fat-cursor div.CodeMirror-cursors {\n  z-index: 1;\n}\n\n.cm-animate-fat-cursor {\n  width: auto;\n  border: 0;\n  -webkit-animation: blink 1.06s steps(1) infinite;\n  -moz-animation: blink 1.06s steps(1) infinite;\n  -ms-animation: blink 1.06s steps(1) infinite;\n  animation: blink 1.06s steps(1) infinite;\n}\n@-moz-keyframes blink {\n  0% { background: #7e7; }\n  50% { background: none; }\n  100% { background: #7e7; }\n}\n@-webkit-keyframes blink {\n  0% { background: #7e7; }\n  50% { background: none; }\n  100% { background: #7e7; }\n}\n@keyframes blink {\n  0% { background: #7e7; }\n  50% { background: none; }\n  100% { background: #7e7; }\n}\n\n/* Can style cursor different in overwrite (non-insert) mode */\ndiv.CodeMirror-overwrite div.CodeMirror-cursor {}\n\n.cm-tab { display: inline-block; text-decoration: inherit; }\n\n.CodeMirror-ruler {\n  border-left: 1px solid #ccc;\n  position: absolute;\n}\n\n/* DEFAULT THEME */\n\n.cm-s-default .cm-keyword {color: #708;}\n.cm-s-default .cm-atom {color: #219;}\n.cm-s-default .cm-number {color: #164;}\n.cm-s-default .cm-def {color: #00f;}\n.cm-s-default .cm-variable,\n.cm-s-default .cm-punctuation,\n.cm-s-default .cm-property,\n.cm-s-default .cm-operator {}\n.cm-s-default .cm-variable-2 {color: #05a;}\n.cm-s-default .cm-variable-3 {color: #085;}\n.cm-s-default .cm-comment {color: #a50;}\n.cm-s-default .cm-string {color: #a11;}\n.cm-s-default .cm-string-2 {color: #f50;}\n.cm-s-default .cm-meta {color: #555;}\n.cm-s-default .cm-qualifier {color: #555;}\n.cm-s-default .cm-builtin {color: #30a;}\n.cm-s-default .cm-bracket {color: #997;}\n.cm-s-default .cm-tag {color: #170;}\n.cm-s-default .cm-attribute {color: #00c;}\n.cm-s-default .cm-header {color: blue;}\n.cm-s-default .cm-quote {color: #090;}\n.cm-s-default .cm-hr {color: #999;}\n.cm-s-default .cm-link {color: #00c;}\n\n.cm-negative {color: #d44;}\n.cm-positive {color: #292;}\n.cm-header, .cm-strong {font-weight: bold;}\n.cm-em {font-style: italic;}\n.cm-link {text-decoration: underline;}\n.cm-strikethrough {text-decoration: line-through;}\n\n.cm-s-default .cm-error {color: #f00;}\n.cm-invalidchar {color: #f00;}\n\n.CodeMirror-composing { border-bottom: 2px solid; }\n\n/* Default styles for common addons */\n\ndiv.CodeMirror span.CodeMirror-matchingbracket {color: #0f0;}\ndiv.CodeMirror span.CodeMirror-nonmatchingbracket {color: #f22;}\n.CodeMirror-matchingtag { background: rgba(255, 150, 0, .3); }\n.CodeMirror-activeline-background {background: #e8f2ff;}\n\n/* STOP */\n\n/* The rest of this file contains styles related to the mechanics of\n   the editor. You probably shouldn't touch them. */\n\n.CodeMirror {\n  position: relative;\n  overflow: hidden;\n  background: white;\n}\n\n.CodeMirror-scroll {\n  overflow: scroll !important; /* Things will break if this is overridden */\n  /* 30px is the magic margin used to hide the element's real scrollbars */\n  /* See overflow: hidden in .CodeMirror */\n  margin-bottom: -30px; margin-right: -30px;\n  padding-bottom: 30px;\n  height: 100%;\n  outline: none; /* Prevent dragging from highlighting the element */\n  position: relative;\n}\n.CodeMirror-sizer {\n  position: relative;\n  border-right: 30px solid transparent;\n}\n\n/* The fake, visible scrollbars. Used to force redraw during scrolling\n   before actual scrolling happens, thus preventing shaking and\n   flickering artifacts. */\n.CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {\n  position: absolute;\n  z-index: 6;\n  display: none;\n}\n.CodeMirror-vscrollbar {\n  right: 0; top: 0;\n  overflow-x: hidden;\n  overflow-y: scroll;\n}\n.CodeMirror-hscrollbar {\n  bottom: 0; left: 0;\n  overflow-y: hidden;\n  overflow-x: scroll;\n}\n.CodeMirror-scrollbar-filler {\n  right: 0; bottom: 0;\n}\n.CodeMirror-gutter-filler {\n  left: 0; bottom: 0;\n}\n\n.CodeMirror-gutters {\n  position: absolute; left: 0; top: 0;\n  min-height: 100%;\n  z-index: 3;\n}\n.CodeMirror-gutter {\n  white-space: normal;\n  height: 100%;\n  display: inline-block;\n  vertical-align: top;\n  margin-bottom: -30px;\n  /* Hack to make IE7 behave */\n  *zoom:1;\n  *display:inline;\n}\n.CodeMirror-gutter-wrapper {\n  position: absolute;\n  z-index: 4;\n  background: none !important;\n  border: none !important;\n}\n.CodeMirror-gutter-background {\n  position: absolute;\n  top: 0; bottom: 0;\n  z-index: 4;\n}\n.CodeMirror-gutter-elt {\n  position: absolute;\n  cursor: default;\n  z-index: 4;\n}\n.CodeMirror-gutter-wrapper {\n  -webkit-user-select: none;\n  -moz-user-select: none;\n  -ms-user-select: none;\n  user-select: none;\n}\n\n.CodeMirror-lines {\n  cursor: text;\n  min-height: 1px; /* prevents collapsing before first draw */\n}\n.CodeMirror pre {\n  /* Reset some styles that the rest of the page might have set */\n  -moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0;\n  border-width: 0;\n  background: transparent;\n  font-family: inherit;\n  font-size: inherit;\n  margin: 0;\n  white-space: pre;\n  word-wrap: normal;\n  line-height: inherit;\n  color: inherit;\n  z-index: 2;\n  position: relative;\n  overflow: visible;\n  -webkit-tap-highlight-color: transparent;\n  -webkit-font-variant-ligatures: none;\n  font-variant-ligatures: none;\n}\n.CodeMirror-wrap pre {\n  word-wrap: break-word;\n  white-space: pre-wrap;\n  word-break: normal;\n}\n\n.CodeMirror-linebackground {\n  position: absolute;\n  left: 0; right: 0; top: 0; bottom: 0;\n  z-index: 0;\n}\n\n.CodeMirror-linewidget {\n  position: relative;\n  z-index: 2;\n  overflow: auto;\n}\n\n.CodeMirror-widget {}\n\n.CodeMirror-code {\n  outline: none;\n}\n\n/* Force content-box sizing for the elements where we expect it */\n.CodeMirror-scroll,\n.CodeMirror-sizer,\n.CodeMirror-gutter,\n.CodeMirror-gutters,\n.CodeMirror-linenumber {\n  -moz-box-sizing: content-box;\n  box-sizing: content-box;\n}\n\n.CodeMirror-measure {\n  position: absolute;\n  width: 100%;\n  height: 0;\n  overflow: hidden;\n  visibility: hidden;\n}\n\n.CodeMirror-cursor { position: absolute; }\n.CodeMirror-measure pre { position: static; }\n\ndiv.CodeMirror-cursors {\n  visibility: hidden;\n  position: relative;\n  z-index: 3;\n}\ndiv.CodeMirror-dragcursors {\n  visibility: visible;\n}\n\n.CodeMirror-focused div.CodeMirror-cursors {\n  visibility: visible;\n}\n\n.CodeMirror-selected { background: #d9d9d9; }\n.CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; }\n.CodeMirror-crosshair { cursor: crosshair; }\n.CodeMirror-line::selection, .CodeMirror-line > span::selection, .CodeMirror-line > span > span::selection { background: #d7d4f0; }\n.CodeMirror-line::-moz-selection, .CodeMirror-line > span::-moz-selection, .CodeMirror-line > span > span::-moz-selection { background: #d7d4f0; }\n\n.cm-searching {\n  background: #ffa;\n  background: rgba(255, 255, 0, .4);\n}\n\n/* IE7 hack to prevent it from returning funny offsetTops on the spans */\n.CodeMirror span { *vertical-align: text-bottom; }\n\n/* Used to force a border model for a node */\n.cm-force-border { padding-right: .1px; }\n\n@media print {\n  /* Hide the cursor when printing */\n  .CodeMirror div.CodeMirror-cursors {\n    visibility: hidden;\n  }\n}\n\n/* See issue #2901 */\n.cm-tab-wrap-hack:after { content: ''; }\n\n/* Help users use markselection to safely style text background */\nspan.CodeMirror-selectedtext { background: none; }\n\n.CodeMirror-dialog {\n  position: absolute;\n  left: 0; right: 0;\n  background: inherit;\n  z-index: 15;\n  padding: .1em .8em;\n  overflow: hidden;\n  color: inherit;\n}\n\n.CodeMirror-dialog-top {\n  border-bottom: 1px solid #eee;\n  top: 0;\n}\n\n.CodeMirror-dialog-bottom {\n  border-top: 1px solid #eee;\n  bottom: 0;\n}\n\n.CodeMirror-dialog input {\n  border: 1px solid #d3d6db;\n  outline: none;\n  background: transparent;\n  width: 20em;\n  color: inherit;\n  font-family: monospace;\n}\n\n.CodeMirror-dialog button {\n  font-size: 70%;\n}\n.graphiql-container .doc-explorer {\n  background: white;\n}\n\n.graphiql-container .doc-explorer-title-bar {\n  cursor: default;\n  display: -webkit-flex;\n  display: -ms-flexbox;\n  display: flex;\n  height: 34px;\n  line-height: 14px;\n  padding: 8px 8px 5px;\n  position: relative;\n  -webkit-user-select: none;\n          user-select: none;\n}\n\n.graphiql-container .doc-explorer-title {\n  padding: 10px 0 10px 10px;\n  font-weight: bold;\n  text-align: center;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n  overflow-x: hidden;\n  -webkit-flex: 1;\n      -ms-flex: 1;\n          flex: 1;\n}\n\n.graphiql-container .doc-explorer-back {\n  color: #3B5998;\n  cursor: pointer;\n  margin: -7px 0 -6px -8px;\n  overflow-x: hidden;\n  padding: 17px 12px 16px 16px;\n  text-overflow: ellipsis;\n  white-space: nowrap;\n}\n\n.graphiql-container .doc-explorer-back:before {\n  border-left: 2px solid #3B5998;\n  border-top: 2px solid #3B5998;\n  content: '';\n  display: inline-block;\n  height: 9px;\n  margin: 0 3px -1px 0;\n  position: relative;\n  width: 9px;\n  -webkit-transform: rotate(-45deg);\n      -ms-transform: rotate(-45deg);\n          transform: rotate(-45deg);\n}\n\n.graphiql-container .doc-explorer-rhs {\n  position: relative;\n}\n\n.graphiql-container .doc-explorer-contents {\n  background-color: #ffffff;\n  border-top: 1px solid #d6d6d6;\n  bottom: 0;\n  left: 0;\n  min-width: 300px;\n  overflow-y: auto;\n  padding: 20px 15px;\n  position: absolute;\n  right: 0;\n  top: 47px;\n}\n\n.graphiql-container .doc-type-description p:first-child ,\n.graphiql-container .doc-type-description blockquote:first-child {\n  margin-top: 0;\n}\n\n.graphiql-container .doc-explorer-contents a {\n  cursor: pointer;\n  text-decoration: none;\n}\n\n.graphiql-container .doc-explorer-contents a:hover {\n  text-decoration: underline;\n}\n\n.graphiql-container .doc-value-description {\n  padding: 4px 0 8px 12px;\n}\n\n.graphiql-container .doc-category {\n  margin: 20px 0;\n}\n\n.graphiql-container .doc-category-title {\n  border-bottom: 1px solid #e0e0e0;\n  color: #777;\n  cursor: default;\n  font-size: 14px;\n  font-variant: small-caps;\n  font-weight: bold;\n  letter-spacing: 1px;\n  margin: 0 -15px 10px 0;\n  padding: 10px 0;\n  -webkit-user-select: none;\n      -ms-user-select: none;\n          user-select: none;\n}\n\n.graphiql-container .doc-category-item {\n  margin: 12px 0;\n  color: #555;\n}\n\n.graphiql-container .keyword {\n  color: #B11A04;\n}\n\n.graphiql-container .type-name {\n  color: #CA9800;\n}\n\n.graphiql-container .field-name {\n  color: #1F61A0;\n}\n\n.graphiql-container .value-name {\n  color: #0B7FC7;\n}\n\n.graphiql-container .arg-name {\n  color: #8B2BB9;\n}\n\n.graphiql-container .arg:after {\n  content: ', ';\n}\n\n.graphiql-container .arg:last-child:after {\n  content: '';\n}\n\n.graphiql-container .doc-alert-text {\n  color: #F00F00;\n  font-family: 'Consolas', 'Inconsolata', 'Droid Sans Mono', 'Monaco', monospace;\n  font-size: 13px;\n}\n\n.graphiql-container .search-box-outer {\n  border: 1px solid #d3d6db;\n  box-sizing: border-box;\n  display: inline-block;\n  font-size: 12px;\n  height: 24px;\n  margin-bottom: 12px;\n  padding: 3px 8px 5px;\n  vertical-align: middle;\n  width: 100%;\n}\n\n.graphiql-container .search-box-input {\n  border: 0;\n  font-size: 12px;\n  margin: 0;\n  outline: 0;\n  padding: 0;\n  width: 100%;\n}\n.CodeMirror-foldmarker {\n  color: blue;\n  text-shadow: #b9f 1px 1px 2px, #b9f -1px -1px 2px, #b9f 1px -1px 2px, #b9f -1px 1px 2px;\n  font-family: arial;\n  line-height: .3;\n  cursor: pointer;\n}\n.CodeMirror-foldgutter {\n  width: .7em;\n}\n.CodeMirror-foldgutter-open,\n.CodeMirror-foldgutter-folded {\n  cursor: pointer;\n}\n.CodeMirror-foldgutter-open:after {\n  content: \"\\25BE\";\n}\n.CodeMirror-foldgutter-folded:after {\n  content: \"\\25B8\";\n}\n/* The lint marker gutter */\n.CodeMirror-lint-markers {\n  width: 16px;\n}\n\n.CodeMirror-lint-tooltip {\n  background-color: infobackground;\n  border: 1px solid black;\n  border-radius: 4px 4px 4px 4px;\n  color: infotext;\n  font-family: monospace;\n  font-size: 10pt;\n  overflow: hidden;\n  padding: 2px 5px;\n  position: fixed;\n  white-space: pre;\n  white-space: pre-wrap;\n  z-index: 100;\n  max-width: 600px;\n  opacity: 0;\n  transition: opacity .4s;\n  -moz-transition: opacity .4s;\n  -webkit-transition: opacity .4s;\n  -o-transition: opacity .4s;\n  -ms-transition: opacity .4s;\n}\n\n.CodeMirror-lint-mark-error, .CodeMirror-lint-mark-warning {\n  background-position: left bottom;\n  background-repeat: repeat-x;\n}\n\n.CodeMirror-lint-mark-error {\n  background-image:\n  url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAADCAYAAAC09K7GAAAAAXNSR0IArs4c6QAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB9sJDw4cOCW1/KIAAAAZdEVYdENvbW1lbnQAQ3JlYXRlZCB3aXRoIEdJTVBXgQ4XAAAAHElEQVQI12NggIL/DAz/GdA5/xkY/qPKMDAwAADLZwf5rvm+LQAAAABJRU5ErkJggg==\")\n  ;\n}\n\n.CodeMirror-lint-mark-warning {\n  background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAADCAYAAAC09K7GAAAAAXNSR0IArs4c6QAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB9sJFhQXEbhTg7YAAAAZdEVYdENvbW1lbnQAQ3JlYXRlZCB3aXRoIEdJTVBXgQ4XAAAAMklEQVQI12NkgIIvJ3QXMjAwdDN+OaEbysDA4MPAwNDNwMCwiOHLCd1zX07o6kBVGQEAKBANtobskNMAAAAASUVORK5CYII=\");\n}\n\n.CodeMirror-lint-marker-error, .CodeMirror-lint-marker-warning {\n  background-position: center center;\n  background-repeat: no-repeat;\n  cursor: pointer;\n  display: inline-block;\n  height: 16px;\n  width: 16px;\n  vertical-align: middle;\n  position: relative;\n}\n\n.CodeMirror-lint-message-error, .CodeMirror-lint-message-warning {\n  padding-left: 18px;\n  background-position: top left;\n  background-repeat: no-repeat;\n}\n\n.CodeMirror-lint-marker-error, .CodeMirror-lint-message-error {\n  background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAAHlBMVEW7AAC7AACxAAC7AAC7AAAAAAC4AAC5AAD///+7AAAUdclpAAAABnRSTlMXnORSiwCK0ZKSAAAATUlEQVR42mWPOQ7AQAgDuQLx/z8csYRmPRIFIwRGnosRrpamvkKi0FTIiMASR3hhKW+hAN6/tIWhu9PDWiTGNEkTtIOucA5Oyr9ckPgAWm0GPBog6v4AAAAASUVORK5CYII=\");\n}\n\n.CodeMirror-lint-marker-warning, .CodeMirror-lint-message-warning {\n  background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAANlBMVEX/uwDvrwD/uwD/uwD/uwD/uwD/uwD/uwD/uwD6twD/uwAAAADurwD2tQD7uAD+ugAAAAD/uwDhmeTRAAAADHRSTlMJ8mN1EYcbmiixgACm7WbuAAAAVklEQVR42n3PUQqAIBBFUU1LLc3u/jdbOJoW1P08DA9Gba8+YWJ6gNJoNYIBzAA2chBth5kLmG9YUoG0NHAUwFXwO9LuBQL1giCQb8gC9Oro2vp5rncCIY8L8uEx5ZkAAAAASUVORK5CYII=\");\n}\n\n.CodeMirror-lint-marker-multiple {\n  background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAcAAAAHCAMAAADzjKfhAAAACVBMVEUAAAAAAAC/v7914kyHAAAAAXRSTlMAQObYZgAAACNJREFUeNo1ioEJAAAIwmz/H90iFFSGJgFMe3gaLZ0od+9/AQZ0ADosbYraAAAAAElFTkSuQmCC\");\n  background-repeat: no-repeat;\n  background-position: right bottom;\n  width: 100%; height: 100%;\n}\n.graphiql-container .spinner-container {\n  position: absolute;\n  top: 50%;\n  height: 36px;\n  width: 36px;\n  left: 50%;\n  transform: translate(-50%, -50%);\n  z-index: 10;\n}\n\n.graphiql-container .spinner {\n  vertical-align: middle;\n  display: inline-block;\n  height: 24px;\n  width: 24px;\n  position: absolute;\n  -webkit-animation: rotation .6s infinite linear;\n  -moz-animation: rotation .6s infinite linear;\n  -o-animation: rotation .6s infinite linear;\n  animation: rotation .6s infinite linear;\n  border-left: 6px solid rgba(150, 150, 150, .15);\n  border-right: 6px solid rgba(150, 150, 150, .15);\n  border-bottom: 6px solid rgba(150, 150, 150, .15);\n  border-top: 6px solid rgba(150, 150, 150, .8);\n  border-radius: 100%;\n}\n\n@-webkit-keyframes rotation {\n  from { -webkit-transform: rotate(0deg); }\n  to { -webkit-transform: rotate(359deg); }\n}\n\n@-moz-keyframes rotation {\n  from { -moz-transform: rotate(0deg); }\n  to { -moz-transform: rotate(359deg); }\n}\n\n@-o-keyframes rotation {\n  from { -o-transform: rotate(0deg); }\n  to { -o-transform: rotate(359deg); }\n}\n\n@keyframes rotation {\n  from { transform: rotate(0deg); }\n  to { transform: rotate(359deg); }\n}\n.CodeMirror-hints {\n  background: white;\n  -webkit-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.45);\n     -moz-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.45);\n          box-shadow: 0 1px 3px rgba(0, 0, 0, 0.45);\n  font-family: 'Consolas', 'Inconsolata', 'Droid Sans Mono', 'Monaco', monospace;\n  font-size: 13px;\n  list-style: none;\n  margin: 0;\n  margin-left: -6px;\n  max-height: 14.5em;\n  overflow-y: auto;\n  overflow: hidden;\n  padding: 0;\n  position: absolute;\n  z-index: 10;\n}\n\n.CodeMirror-hints-wrapper {\n  background: white;\n  -webkit-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.45);\n     -moz-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.45);\n          box-shadow: 0 1px 3px rgba(0, 0, 0, 0.45);\n  margin-left: -6px;\n  position: absolute;\n  z-index: 10;\n}\n\n.CodeMirror-hints-wrapper .CodeMirror-hints {\n  -webkit-box-shadow: none;\n   -moz-box-shadow: none;\n        box-shadow: none;\n  position: relative;\n  margin-left: 0;\n  z-index: 0;\n}\n\n.CodeMirror-hint {\n  border-top: solid 1px #f7f7f7;\n  color: #141823;\n  cursor: pointer;\n  margin: 0;\n  max-width: 300px;\n  overflow: hidden;\n  padding: 2px 6px;\n  white-space: pre;\n}\n\nli.CodeMirror-hint-active {\n  background-color: #08f;\n  border-top-color: white;\n  color: white;\n}\n\n.CodeMirror-hint-information {\n  border-top: solid 1px #c0c0c0;\n  max-width: 300px;\n  padding: 4px 6px;\n  position: relative;\n  z-index: 1;\n}\n\n.CodeMirror-hint-information:first-child {\n  border-bottom: solid 1px #c0c0c0;\n  border-top: none;\n  margin-bottom: -1px;\n}\n", ""]);
-
-	// exports
-
-
-/***/ },
-/* 312 */
-/***/ function(module, exports) {
-
-	/*
-		MIT License http://www.opensource.org/licenses/mit-license.php
-		Author Tobias Koppers @sokra
-	*/
-	// css base code, injected by the css-loader
-	module.exports = function() {
-		var list = [];
-
-		// return the list of modules as css string
-		list.toString = function toString() {
-			var result = [];
-			for(var i = 0; i < this.length; i++) {
-				var item = this[i];
-				if(item[2]) {
-					result.push("@media " + item[2] + "{" + item[1] + "}");
-				} else {
-					result.push(item[1]);
-				}
-			}
-			return result.join("");
-		};
-
-		// import a list of modules into the list
-		list.i = function(modules, mediaQuery) {
-			if(typeof modules === "string")
-				modules = [[null, modules, ""]];
-			var alreadyImportedModules = {};
-			for(var i = 0; i < this.length; i++) {
-				var id = this[i][0];
-				if(typeof id === "number")
-					alreadyImportedModules[id] = true;
-			}
-			for(i = 0; i < modules.length; i++) {
-				var item = modules[i];
-				// skip already imported module
-				// this implementation is not 100% perfect for weird media query combinations
-				//  when a module is imported multiple times with different media queries.
-				//  I hope this will never occur (Hey this way we have smaller bundles)
-				if(typeof item[0] !== "number" || !alreadyImportedModules[item[0]]) {
-					if(mediaQuery && !item[2]) {
-						item[2] = mediaQuery;
-					} else if(mediaQuery) {
-						item[2] = "(" + item[2] + ") and (" + mediaQuery + ")";
-					}
-					list.push(item);
-				}
-			}
-		};
-		return list;
-	};
-
-
-/***/ },
-/* 313 */
-/***/ function(module, exports, __webpack_require__) {
-
-	/*
-		MIT License http://www.opensource.org/licenses/mit-license.php
-		Author Tobias Koppers @sokra
-	*/
-	var stylesInDom = {},
-		memoize = function(fn) {
-			var memo;
-			return function () {
-				if (typeof memo === "undefined") memo = fn.apply(this, arguments);
-				return memo;
-			};
-		},
-		isOldIE = memoize(function() {
-			return /msie [6-9]\b/.test(window.navigator.userAgent.toLowerCase());
-		}),
-		getHeadElement = memoize(function () {
-			return document.head || document.getElementsByTagName("head")[0];
-		}),
-		singletonElement = null,
-		singletonCounter = 0,
-		styleElementsInsertedAtTop = [];
-
-	module.exports = function(list, options) {
-		if(false) {
-			if(typeof document !== "object") throw new Error("The style-loader cannot be used in a non-browser environment");
-		}
-
-		options = options || {};
-		// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
-		// tags it will allow on a page
-		if (typeof options.singleton === "undefined") options.singleton = isOldIE();
-
-		// By default, add <style> tags to the bottom of <head>.
-		if (typeof options.insertAt === "undefined") options.insertAt = "bottom";
-
-		var styles = listToStyles(list);
-		addStylesToDom(styles, options);
-
-		return function update(newList) {
-			var mayRemove = [];
-			for(var i = 0; i < styles.length; i++) {
-				var item = styles[i];
-				var domStyle = stylesInDom[item.id];
-				domStyle.refs--;
-				mayRemove.push(domStyle);
-			}
-			if(newList) {
-				var newStyles = listToStyles(newList);
-				addStylesToDom(newStyles, options);
-			}
-			for(var i = 0; i < mayRemove.length; i++) {
-				var domStyle = mayRemove[i];
-				if(domStyle.refs === 0) {
-					for(var j = 0; j < domStyle.parts.length; j++)
-						domStyle.parts[j]();
-					delete stylesInDom[domStyle.id];
-				}
-			}
-		};
-	}
-
-	function addStylesToDom(styles, options) {
-		for(var i = 0; i < styles.length; i++) {
-			var item = styles[i];
-			var domStyle = stylesInDom[item.id];
-			if(domStyle) {
-				domStyle.refs++;
-				for(var j = 0; j < domStyle.parts.length; j++) {
-					domStyle.parts[j](item.parts[j]);
-				}
-				for(; j < item.parts.length; j++) {
-					domStyle.parts.push(addStyle(item.parts[j], options));
-				}
-			} else {
-				var parts = [];
-				for(var j = 0; j < item.parts.length; j++) {
-					parts.push(addStyle(item.parts[j], options));
-				}
-				stylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};
-			}
-		}
-	}
-
-	function listToStyles(list) {
-		var styles = [];
-		var newStyles = {};
-		for(var i = 0; i < list.length; i++) {
-			var item = list[i];
-			var id = item[0];
-			var css = item[1];
-			var media = item[2];
-			var sourceMap = item[3];
-			var part = {css: css, media: media, sourceMap: sourceMap};
-			if(!newStyles[id])
-				styles.push(newStyles[id] = {id: id, parts: [part]});
-			else
-				newStyles[id].parts.push(part);
-		}
-		return styles;
-	}
-
-	function insertStyleElement(options, styleElement) {
-		var head = getHeadElement();
-		var lastStyleElementInsertedAtTop = styleElementsInsertedAtTop[styleElementsInsertedAtTop.length - 1];
-		if (options.insertAt === "top") {
-			if(!lastStyleElementInsertedAtTop) {
-				head.insertBefore(styleElement, head.firstChild);
-			} else if(lastStyleElementInsertedAtTop.nextSibling) {
-				head.insertBefore(styleElement, lastStyleElementInsertedAtTop.nextSibling);
-			} else {
-				head.appendChild(styleElement);
-			}
-			styleElementsInsertedAtTop.push(styleElement);
-		} else if (options.insertAt === "bottom") {
-			head.appendChild(styleElement);
-		} else {
-			throw new Error("Invalid value for parameter 'insertAt'. Must be 'top' or 'bottom'.");
-		}
-	}
-
-	function removeStyleElement(styleElement) {
-		styleElement.parentNode.removeChild(styleElement);
-		var idx = styleElementsInsertedAtTop.indexOf(styleElement);
-		if(idx >= 0) {
-			styleElementsInsertedAtTop.splice(idx, 1);
-		}
-	}
-
-	function createStyleElement(options) {
-		var styleElement = document.createElement("style");
-		styleElement.type = "text/css";
-		insertStyleElement(options, styleElement);
-		return styleElement;
-	}
-
-	function createLinkElement(options) {
-		var linkElement = document.createElement("link");
-		linkElement.rel = "stylesheet";
-		insertStyleElement(options, linkElement);
-		return linkElement;
-	}
-
-	function addStyle(obj, options) {
-		var styleElement, update, remove;
-
-		if (options.singleton) {
-			var styleIndex = singletonCounter++;
-			styleElement = singletonElement || (singletonElement = createStyleElement(options));
-			update = applyToSingletonTag.bind(null, styleElement, styleIndex, false);
-			remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true);
-		} else if(obj.sourceMap &&
-			typeof URL === "function" &&
-			typeof URL.createObjectURL === "function" &&
-			typeof URL.revokeObjectURL === "function" &&
-			typeof Blob === "function" &&
-			typeof btoa === "function") {
-			styleElement = createLinkElement(options);
-			update = updateLink.bind(null, styleElement);
-			remove = function() {
-				removeStyleElement(styleElement);
-				if(styleElement.href)
-					URL.revokeObjectURL(styleElement.href);
-			};
-		} else {
-			styleElement = createStyleElement(options);
-			update = applyToTag.bind(null, styleElement);
-			remove = function() {
-				removeStyleElement(styleElement);
-			};
-		}
-
-		update(obj);
-
-		return function updateStyle(newObj) {
-			if(newObj) {
-				if(newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap)
-					return;
-				update(obj = newObj);
-			} else {
-				remove();
-			}
-		};
-	}
-
-	var replaceText = (function () {
-		var textStore = [];
-
-		return function (index, replacement) {
-			textStore[index] = replacement;
-			return textStore.filter(Boolean).join('\n');
-		};
-	})();
-
-	function applyToSingletonTag(styleElement, index, remove, obj) {
-		var css = remove ? "" : obj.css;
-
-		if (styleElement.styleSheet) {
-			styleElement.styleSheet.cssText = replaceText(index, css);
-		} else {
-			var cssNode = document.createTextNode(css);
-			var childNodes = styleElement.childNodes;
-			if (childNodes[index]) styleElement.removeChild(childNodes[index]);
-			if (childNodes.length) {
-				styleElement.insertBefore(cssNode, childNodes[index]);
-			} else {
-				styleElement.appendChild(cssNode);
-			}
-		}
-	}
-
-	function applyToTag(styleElement, obj) {
-		var css = obj.css;
-		var media = obj.media;
-
-		if(media) {
-			styleElement.setAttribute("media", media)
-		}
-
-		if(styleElement.styleSheet) {
-			styleElement.styleSheet.cssText = css;
-		} else {
-			while(styleElement.firstChild) {
-				styleElement.removeChild(styleElement.firstChild);
-			}
-			styleElement.appendChild(document.createTextNode(css));
-		}
-	}
-
-	function updateLink(linkElement, obj) {
-		var css = obj.css;
-		var sourceMap = obj.sourceMap;
-
-		if(sourceMap) {
-			// http://stackoverflow.com/a/26603875
-			css += "\n/*# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + " */";
-		}
-
-		var blob = new Blob([css], { type: "text/css" });
-
-		var oldSrc = linkElement.href;
-
-		linkElement.href = URL.createObjectURL(blob);
-
-		if(oldSrc)
-			URL.revokeObjectURL(oldSrc);
-	}
-
-
-/***/ }
-/******/ ]);
\ No newline at end of file
diff --git a/src/Controller.php b/src/Controller.php
index f985aa912..6082be2ec 100644
--- a/src/Controller.php
+++ b/src/Controller.php
@@ -38,7 +38,7 @@ public function index(HTTPRequest $request)
         }
         $contentType = $request->getHeader('Content-Type') ?: $request->getHeader('content-type');
         $isJson = preg_match('#^application/json\b#', $contentType);
-        if ($isJson) {        	
+        if ($isJson) {
             $rawBody = $request->getBody();
             $data = json_decode($rawBody ?: '', true);
             $query = isset($data['query']) ? $data['query'] : null;
diff --git a/src/FieldCreator.php b/src/FieldCreator.php
index 0d7c5f3f0..c0aaa6f87 100644
--- a/src/FieldCreator.php
+++ b/src/FieldCreator.php
@@ -82,7 +82,7 @@ public function getAttributes()
             $attributes['type'] = $type;
         }
 
-        $resolver = $this->getResolver();        
+        $resolver = $this->getResolver();
         if (isset($resolver)) {
             $attributes['resolve'] = $resolver;
         }
diff --git a/src/Manager.php b/src/Manager.php
index acb2ee966..167bf4eb8 100644
--- a/src/Manager.php
+++ b/src/Manager.php
@@ -13,7 +13,6 @@
 use SilverStripe\Security\Member;
 use SilverStripe\GraphQL\Scaffolding\Interfaces\ScaffoldingProvider;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
-use SilverStripe\Security\Member;
 
 class Manager
 {
@@ -54,10 +53,10 @@ public static function createFromConfig($config)
         /** @var Manager $manager */
         $manager = Injector::inst()->create(self::class);
 
-        if(isset($config['scaffolding'])) {
-        	$scaffolder = SchemaScaffolder::createFromConfig($config['scaffolding']);
+        if (isset($config['scaffolding'])) {
+            $scaffolder = SchemaScaffolder::createFromConfig($config['scaffolding']);
         } else {
-        	$scaffolder = new SchemaScaffolder();
+            $scaffolder = new SchemaScaffolder();
         }
 
         if (isset($config['scaffolding_providers'])) {
@@ -68,7 +67,7 @@ public static function createFromConfig($config)
                         $provider
                     ));
                 }
-
+                
                 $provider = Injector::inst()->create($provider);
 
                 if (!$provider instanceof ScaffoldingProvider) {
@@ -225,12 +224,12 @@ public function getType($name)
 
     /**
      * @param  string  $name
-     * 
+     *
      * @return boolean
      */
     public function hasType($name)
     {
-    	return isset($this->types[$name]);
+        return isset($this->types[$name]);
     }
 
     /**
diff --git a/src/Scaffolding/Scaffolders/ArgumentScaffolder.php b/src/Scaffolding/Scaffolders/ArgumentScaffolder.php
index 53867e62b..f6472dfcb 100644
--- a/src/Scaffolding/Scaffolders/ArgumentScaffolder.php
+++ b/src/Scaffolding/Scaffolders/ArgumentScaffolder.php
@@ -11,134 +11,133 @@
 class ArgumentScaffolder implements Configurable
 {
 
-	/**
-	 * @var string
-	 */
-	public $argName;
-
-	/**	 
-	 * @var string
-	 */
-	protected $description;
-
-	/**
-	 * @var GraphQL\Definition\Type\Type;
-	 */
-	protected $type;
-
-	/**
-	 * @var scalar
-	 */
-	protected $defaultValue;
-
-	/**
-	 * @var  boolean
-	 */
-	protected $required;
-
-	/**
-	 * ArgumentScaffolder constructor
-	 * @param string $argName      Name of the argument
-	 * @param strint $typeStr      A string describing the type (see TypeParser)
-	 */
-	public function __construct($argName, $typeStr)
-	{
-		$this->argName = $argName;
-		
-		$parser = new TypeParser($typeStr);
-		$this->defaultValue = $parser->getDefaultValue();
-		$this->type = $parser->getType();
-		$this->required = $parser->isRequired();
-	}
-
-	/**
-	 * Sets the argument as required
-	 * @param boolean $bool
-	 */
-	public function setRequired($bool)
-	{
-		$this->required = (boolean) $bool;
-
-		return $this;
-	}
-
-	/**
-	 * Sets the argument description
-	 * @param string $description 
-	 */
-	public function setDescription($description)
-	{
-		$this->description = $description;
-
-		return $this;
-	}
-
-	/**
-	 * Sets the default value of the argument
-	 * @param mixed $value
-	 */
-	public function setDefaultValue($value)
-	{
-		$this->defaultValue = $value;
-
-		return $this;
-	}
-
-	/**
-	 * @return string
-	 */
-	public function getDescription()
-	{
-		return $this->description;
-	}
-
-	/**
-	 * @return scalar
-	 */
-	public function getDefaultValue()
-	{
-		return $this->defaultValue;
-	}
-
-	/**
-	 * @return boolean
-	 */
-	public function isRequired()
-	{
-		return $this->required;
-	}
-
-	/**
-	 * Applies an array of configuration to the scaffolder
-	 * @param  array  $config 
-	 * @return void
-	 */
-	public function applyConfig(array $config)
-	{
-		if(isset($config['description'])) {
-			$this->description = $config['description'];
-		}
-
-		if(isset($config['default'])) {
-			$this->defaultValue = $config['default'];
-		}
-
-		if(isset($config['required'])) {
-			$this->required = (boolean) $config['required'];
-		}
-	}
-
-	/**
-	 * Creates an array suitable for a map of args in a field
-	 * @return array
-	 */
-	public function toArray()
-	{
-		return [
-			'description' => $this->description,
-			'type' => $this->required ? Type::nonNull($this->type) : $this->type,
-			'defaultValue' => $this->defaultValue
-		];
-	}
-
-}
\ No newline at end of file
+    /**
+     * @var string
+     */
+    public $argName;
+
+    /**
+     * @var string
+     */
+    protected $description;
+
+    /**
+     * @var GraphQL\Definition\Type\Type;
+     */
+    protected $type;
+
+    /**
+     * @var scalar
+     */
+    protected $defaultValue;
+
+    /**
+     * @var  boolean
+     */
+    protected $required;
+
+    /**
+     * ArgumentScaffolder constructor
+     * @param string $argName      Name of the argument
+     * @param strint $typeStr      A string describing the type (see TypeParser)
+     */
+    public function __construct($argName, $typeStr)
+    {
+        $this->argName = $argName;
+        
+        $parser = new TypeParser($typeStr);
+        $this->defaultValue = $parser->getDefaultValue();
+        $this->type = $parser->getType();
+        $this->required = $parser->isRequired();
+    }
+
+    /**
+     * Sets the argument as required
+     * @param boolean $bool
+     */
+    public function setRequired($bool)
+    {
+        $this->required = (boolean) $bool;
+
+        return $this;
+    }
+
+    /**
+     * Sets the argument description
+     * @param string $description
+     */
+    public function setDescription($description)
+    {
+        $this->description = $description;
+
+        return $this;
+    }
+
+    /**
+     * Sets the default value of the argument
+     * @param mixed $value
+     */
+    public function setDefaultValue($value)
+    {
+        $this->defaultValue = $value;
+
+        return $this;
+    }
+
+    /**
+     * @return string
+     */
+    public function getDescription()
+    {
+        return $this->description;
+    }
+
+    /**
+     * @return scalar
+     */
+    public function getDefaultValue()
+    {
+        return $this->defaultValue;
+    }
+
+    /**
+     * @return boolean
+     */
+    public function isRequired()
+    {
+        return $this->required;
+    }
+
+    /**
+     * Applies an array of configuration to the scaffolder
+     * @param  array  $config
+     * @return void
+     */
+    public function applyConfig(array $config)
+    {
+        if (isset($config['description'])) {
+            $this->description = $config['description'];
+        }
+
+        if (isset($config['default'])) {
+            $this->defaultValue = $config['default'];
+        }
+
+        if (isset($config['required'])) {
+            $this->required = (boolean) $config['required'];
+        }
+    }
+
+    /**
+     * Creates an array suitable for a map of args in a field
+     * @return array
+     */
+    public function toArray()
+    {
+        return [
+            'description' => $this->description,
+            'type' => $this->required ? Type::nonNull($this->type) : $this->type,
+            'defaultValue' => $this->defaultValue
+        ];
+    }
+}
diff --git a/src/Scaffolding/Scaffolders/CRUD/Create.php b/src/Scaffolding/Scaffolders/CRUD/Create.php
index a5a8639c1..1bcd96043 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Create.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Create.php
@@ -91,7 +91,7 @@ protected function generateInputType()
             $result = $instance->obj($dbFieldName);
             $typeName = $result->config()->graphql_type;
             $arr = [
-            	'type' => (new TypeParser($typeName))->getType()
+                'type' => (new TypeParser($typeName))->getType()
             ];
             $fields[$dbFieldName] = $arr;
         }
diff --git a/src/Scaffolding/Scaffolders/CRUD/Read.php b/src/Scaffolding/Scaffolders/CRUD/Read.php
index 05b528e56..d1c6ae25b 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Read.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Read.php
@@ -33,11 +33,11 @@ public function __construct($dataObjectClass)
         parent::__construct($operationName, $this->typeName());
 
         $this->setResolver(function ($object, array $args, $context, $info) {
-            if(!singleton($this->dataObjectClass)->canView($context['currentMember'])) {
-            	throw new Exception(sprintf(
-            		'Cannot create %s',
-            		$this->dataObjectClass
-            	));
+            if (!singleton($this->dataObjectClass)->canView($context['currentMember'])) {
+                throw new Exception(sprintf(
+                    'Cannot create %s',
+                    $this->dataObjectClass
+                ));
             }
             
             $list = DataList::create($this->dataObjectClass);
diff --git a/src/Scaffolding/Scaffolders/CRUD/Update.php b/src/Scaffolding/Scaffolders/CRUD/Update.php
index 33ebba1e5..fa65193f2 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Update.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Update.php
@@ -78,7 +78,7 @@ protected function createArgs()
     {
         return [
             'ID' => [
-            	'type' => Type::nonNull(Type::id())
+                'type' => Type::nonNull(Type::id())
             ],
             'Input' => [
                 'type' => Type::nonNull($this->generateInputType()),
@@ -109,7 +109,7 @@ protected function generateInputType()
             $result = $instance->obj($dbFieldName);
             $typeName = $result->config()->graphql_type;
             $arr = [
-            	'type' => (new TypeParser($typeName))->getType()
+                'type' => (new TypeParser($typeName))->getType()
             ];
             $fields[$dbFieldName] = $arr;
         }
diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
index 34cb8a051..c6a86b0e3 100644
--- a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -89,14 +89,14 @@ public function __construct($dataObjectClass)
     public function addFields(array $fieldData)
     {
         $fields = [];
-        foreach($fieldData as $k => $data) {
-        	$assoc = !is_numeric($k);
-        	$field = ArrayData::create([
-        		'Name' => $assoc ? $k : $data,
-        		'Description' => $assoc ? $data : null
-        	]);
-        	$this->removeField($field->Name);        	
-        	$this->fields->add($field);        	
+        foreach ($fieldData as $k => $data) {
+            $assoc = !is_numeric($k);
+            $field = ArrayData::create([
+                'Name' => $assoc ? $k : $data,
+                'Description' => $assoc ? $data : null
+            ]);
+            $this->removeField($field->Name);
+            $this->fields->add($field);
         }
 
         return $this;
@@ -199,21 +199,21 @@ public function getNestedQueries()
      */
     public function setFieldDescription($field, $description)
     {
-    	$existing = $this->fields->find('Name', $field);
-    	if(!$existing) {
-    		throw new InvalidArgumentException(sprintf(
-    			'Cannot set description of %s. It has not been added to %s.',
-    			$field,
-    			$this->dataObjectClass
-    		));
-    	}
-    	
-    	$this->fields->replace($existing, ArrayData::create([
-    		'Name' => $field,
-    		'Description' => $description
-    	]));
-
-		return $this;
+        $existing = $this->fields->find('Name', $field);
+        if (!$existing) {
+            throw new InvalidArgumentException(sprintf(
+                'Cannot set description of %s. It has not been added to %s.',
+                $field,
+                $this->dataObjectClass
+            ));
+        }
+        
+        $this->fields->replace($existing, ArrayData::create([
+            'Name' => $field,
+            'Description' => $description
+        ]));
+
+        return $this;
     }
 
     /**
@@ -223,17 +223,17 @@ public function setFieldDescription($field, $description)
      */
     public function getFieldDescription($field)
     {
-    	$item = $this->fields->find('Name', $field);
+        $item = $this->fields->find('Name', $field);
 
-    	if(!$item) {
-    		throw new \Exception(sprintf(
-    			'Tried to get field description for %s, but it has not been added to %s',
-    			$field,
-    			$this->dataObjectClass
-    		));
-    	}
+        if (!$item) {
+            throw new \Exception(sprintf(
+                'Tried to get field description for %s, but it has not been added to %s',
+                $field,
+                $this->dataObjectClass
+            ));
+        }
 
-    	return $item->Description;
+        return $item->Description;
     }
 
     /**
@@ -398,16 +398,16 @@ public function applyConfig(array $config)
         }
 
         if (isset($config['fieldDescriptions'])) {
-        	if(!ArrayLib::is_associative($config['fieldDescriptions'])) {
-        		throw new InvalidArgumentException(sprintf(
-        			'"fieldDescripions" must be a map of field name to description. See %s',
-        			$this->dataObjectClass
-        		));
-        	}
-
-        	foreach($config['fieldDescriptions'] as $fieldName => $description) {
-        		$this->setFieldDescription($fieldName, $description);
-        	}
+            if (!ArrayLib::is_associative($config['fieldDescriptions'])) {
+                throw new InvalidArgumentException(sprintf(
+                    '"fieldDescripions" must be a map of field name to description. See %s',
+                    $this->dataObjectClass
+                ));
+            }
+
+            foreach ($config['fieldDescriptions'] as $fieldName => $description) {
+                $this->setFieldDescription($fieldName, $description);
+            }
         }
 
         if (isset($config['operations'])) {
@@ -554,7 +554,7 @@ protected function nestedConnections()
      * @return array
      */
     protected function createFields(Manager $manager)
-    {	
+    {
 
         $fieldMap = [];
         $instance = $this->getDataObjectInstance();
@@ -563,7 +563,7 @@ protected function createFields(Manager $manager)
 
         if (!$this->fields->exists()) {
             $this->addFields(
-            	Config::inst()->get(self::class, 'default_fields')
+                Config::inst()->get(self::class, 'default_fields')
             );
         }
 
@@ -572,7 +572,7 @@ protected function createFields(Manager $manager)
         };
 
         foreach ($this->fields as $fieldData) {
-        	$fieldName = $fieldData->Name;
+            $fieldName = $fieldData->Name;
             if (!ScaffoldingUtil::isValidFieldName($instance, $fieldName)) {
                 throw new InvalidArgumentException(sprintf(
                     'Invalid field "%s" on %s',
@@ -621,5 +621,4 @@ protected function createFields(Manager $manager)
 
         return $fieldMap;
     }
-
 }
diff --git a/src/Scaffolding/Scaffolders/OperationScaffolder.php b/src/Scaffolding/Scaffolders/OperationScaffolder.php
index 19c816fa4..ef5f9deb5 100644
--- a/src/Scaffolding/Scaffolders/OperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/OperationScaffolder.php
@@ -94,9 +94,9 @@ public function __construct($operationName, $typeName, $resolver = null)
     public function addArgs(array $argData)
     {
         $args = [];
-        foreach($argData as $argName => $typeStr) {
-        	$this->removeArg($argName);
-        	$this->args->add(new ArgumentScaffolder($argName, $typeStr));
+        foreach ($argData as $argName => $typeStr) {
+            $this->removeArg($argName);
+            $this->args->add(new ArgumentScaffolder($argName, $typeStr));
         }
 
         return $this;
@@ -120,73 +120,73 @@ public function addArg($argName, $typeStr, $description = null, $defaultValue =
     /**
      * Sets descriptions of arguments
      * [
-     * 	'Email' => 'The email of the user'
+     *  'Email' => 'The email of the user'
      * ]
-     * @param array $argData 
+     * @param array $argData
      * @return  $this
      */
     public function setArgDescriptions(array $argData)
     {
-    	foreach($argData as $argName => $description) {
-    		$arg = $this->args->find('argName', $argName);
-    		if(!$arg) {
-    			throw new InvalidArgumentException(sprintf(
-    				'Tried to set description for %s, but it was not added to %s',
-    				$argName,
-    				$this->operationName
-    			));
-    		}
-
-    		$arg->setDescription($description);
-    	}
-
-    	return $this;
+        foreach ($argData as $argName => $description) {
+            $arg = $this->args->find('argName', $argName);
+            if (!$arg) {
+                throw new InvalidArgumentException(sprintf(
+                    'Tried to set description for %s, but it was not added to %s',
+                    $argName,
+                    $this->operationName
+                ));
+            }
+
+            $arg->setDescription($description);
+        }
+
+        return $this;
     }
 
     /**
      * Sets a single arg description
-     * @param string $argName     
-     * @param string $description 
+     * @param string $argName
+     * @param string $description
      */
     public function setArgDescription($argName, $description)
     {
-    	return $this->setArgDescriptions([$argName => $description]);
+        return $this->setArgDescriptions([$argName => $description]);
     }
 
     /**
      * Sets argument defaults
      * [
-     * 	'Featured' => true
+     *  'Featured' => true
      * ]
      * @param array $argData
      * @return  $this
      */
     public function setArgDefaults(array $argData)
     {
-    	foreach($argData as $argName => $default) {
-    		$arg = $this->args->find('argName', $argName);
-    		if(!$arg) {
-    			throw new InvalidArgumentException(sprintf(
-    				'Tried to set default for %s, but it was not added to %s',
-    				$argName,
-    				$this->operationName
-    			));
-    		}
-
-    		$arg->setDefaultValue($default);
-    	}
-
-    	return $this;    	
+        foreach ($argData as $argName => $default) {
+            $arg = $this->args->find('argName', $argName);
+            if (!$arg) {
+                throw new InvalidArgumentException(sprintf(
+                    'Tried to set default for %s, but it was not added to %s',
+                    $argName,
+                    $this->operationName
+                ));
+            }
+
+            $arg->setDefaultValue($default);
+        }
+
+        return $this;
     }
 
     /**
      * Sets a default for a single arg
-     * @param string $argName 
-     * @param mixed $default 
+     * @param string $argName
+     * @param mixed $default
      */
     public function setArgDefault($argName, $default)
     {
-    	return $this->setArgDefaults([$argName => $default]);
+        return $this->setArgDefaults([$argName => $default]);
     }
 
     /**
@@ -261,34 +261,34 @@ public function setResolver($resolver)
     public function applyConfig(array $config)
     {
         if (isset($config['args'])) {
-        	if(!is_array($config['args'])) {
-        		throw new Exception(sprintf(
-        			'args must be an array on %s',
-        			$this->operationName
-        		));
-        	}
-        	foreach($config['args'] as $argName => $argData) {
-        		if(is_array($argData)) {
-					if(!isset($argData['type'])) {
-						throw new Exception(sprintf(
-							'Argument %s must have a type',
-							$argName
-						));
-					}
-
-        			$scaffolder = new ArgumentScaffolder($argName, $argData['type']);
-        			$scaffolder->applyConfig($argData);
-        			$this->removeArg($argName);
-        			$this->args->add($scaffolder);
-        		} else if(is_string($argData)) {
-        			$this->addArg($argName, $argData);
-        		} else {
-        			throw new Exception(sprintf(
-        				'Arg %s should be mapped to a string or an array',
-        				$argName
-        			));
-        		}
-        	}            
+            if (!is_array($config['args'])) {
+                throw new Exception(sprintf(
+                    'args must be an array on %s',
+                    $this->operationName
+                ));
+            }
+            foreach ($config['args'] as $argName => $argData) {
+                if (is_array($argData)) {
+                    if (!isset($argData['type'])) {
+                        throw new Exception(sprintf(
+                            'Argument %s must have a type',
+                            $argName
+                        ));
+                    }
+
+                    $scaffolder = new ArgumentScaffolder($argName, $argData['type']);
+                    $scaffolder->applyConfig($argData);
+                    $this->removeArg($argName);
+                    $this->args->add($scaffolder);
+                } elseif (is_string($argData)) {
+                    $this->addArg($argName, $argData);
+                } else {
+                    throw new Exception(sprintf(
+                        'Arg %s should be mapped to a string or an array',
+                        $argName
+                    ));
+                }
+            }
         }
         if (isset($config['resolver'])) {
             $this->setResolver($config['resolver']);
@@ -332,8 +332,8 @@ protected function createResolverFunction()
     protected function createArgs()
     {
         $args = [];
-        foreach($this->args as $scaffolder) {
-        	$args[$scaffolder->argName] = $scaffolder->toArray();
+        foreach ($this->args as $scaffolder) {
+            $args[$scaffolder->argName] = $scaffolder->toArray();
         }
 
         return $args;
diff --git a/src/Scaffolding/Util/TypeParser.php b/src/Scaffolding/Util/TypeParser.php
index 1315a4151..7217b3798 100644
--- a/src/Scaffolding/Util/TypeParser.php
+++ b/src/Scaffolding/Util/TypeParser.php
@@ -73,26 +73,26 @@ public function getArgTypeName()
      */
     public function getDefaultValue()
     {
-        if($this->defaultValue === null) {
-        	return null;
+        if ($this->defaultValue === null) {
+            return null;
         }
         
         switch ($this->typeStr) {
-            case Type::ID:                
-                return (int) $this->defaultValue;                
+            case Type::ID:
+                return (int) $this->defaultValue;
             case Type::STRING:
-                return (string) $this->defaultValue;                
-            case Type::BOOLEAN:                
-                return (boolean) $this->defaultValue;                
-            case Type::INT:                
-                return (int) $this->defaultValue;                
-            case Type::FLOAT:                
-                return (float) $this->defaultValue;               
+                return (string) $this->defaultValue;
+            case Type::BOOLEAN:
+                return (boolean) $this->defaultValue;
+            case Type::INT:
+                return (int) $this->defaultValue;
+            case Type::FLOAT:
+                return (float) $this->defaultValue;
         }
 
         throw new InvalidArgumentException(sprintf(
-        	'Invalid type %s',
-        	$this->typeStr
+            'Invalid type %s',
+            $this->typeStr
         ));
     }
 
@@ -109,7 +109,6 @@ public function getType()
                 return Type::int();
             case Type::FLOAT:
                 return Type::float();
-        }    	
+        }
     }
-
 }
diff --git a/tests/ScaffoldingTest.php b/tests/ScaffoldingTest.php
index 2184875b8..3e920bdf6 100644
--- a/tests/ScaffoldingTest.php
+++ b/tests/ScaffoldingTest.php
@@ -993,8 +993,8 @@ public function testCreateOperationInputType()
 
 		$this->assertEquals('Data_Object_FakeCreateInputType', $config['name']);
 		$fieldMap = [];
-		foreach($config['fields'] as $fieldData) {
-			$fieldMap[$fieldData['name']] = $fieldData['type'];
+		foreach($config['fields'] as $name => $fieldData) {
+			$fieldMap[$name] = $fieldData['type'];
 		}
 		$this->assertArrayHasKey('MyField', $fieldMap);
 		$this->assertArrayHasKey('MyInt', $fieldMap);
@@ -1058,8 +1058,8 @@ public function testUpdateOperationInputType()
 
 		$this->assertEquals('Data_Object_FakeUpdateInputType', $config['name']);
 		$fieldMap = [];
-		foreach($config['fields'] as $fieldData) {
-			$fieldMap[$fieldData['name']] = $fieldData['type'];
+		foreach($config['fields'] as $name => $fieldData) {
+			$fieldMap[$name] = $fieldData['type'];
 		}
 		$this->assertArrayHasKey('MyField', $fieldMap);
 		$this->assertArrayHasKey('MyInt', $fieldMap);

From 62cdf22dd48c7dcacdaa32e9b37fe5f234ad7097 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 31 Jan 2017 20:41:26 +1300
Subject: [PATCH 50/66] Code formatting for tests

---
 tests/ConnectionTest.php                |   14 +-
 tests/Fake/DataObjectFake.php           |   31 +-
 tests/Fake/FakeResolver.php             |    5 +-
 tests/Fake/MutationCreatorFake.php      |    2 +-
 tests/Fake/OperationScaffolderFake.php  |    5 +-
 tests/Fake/PaginatedQueryFake.php       |    4 +-
 tests/Fake/RestrictedDataObjectFake.php |   26 +-
 tests/ScaffoldingTest.php               | 2308 ++++++++++++-----------
 tests/TypeCreatorTest.php               |    8 +-
 9 files changed, 1216 insertions(+), 1187 deletions(-)

diff --git a/tests/ConnectionTest.php b/tests/ConnectionTest.php
index 0502b578a..265f638f8 100644
--- a/tests/ConnectionTest.php
+++ b/tests/ConnectionTest.php
@@ -48,10 +48,10 @@ public function setUp()
 
         $this->manager = Manager::createFromConfig($config);
         $this->connection = Connection::create('testConnection')
-            ->setConnectionType(function() {
+            ->setConnectionType(function () {
                 return $this->manager->getType('TypeCreatorFake');
             })
-            ->setConnectionResolver(function() {
+            ->setConnectionResolver(function () {
                 $result = new ArrayList();
                 $result->push([
                     'ID' => 10,
@@ -80,7 +80,7 @@ public function testResolveList()
         $list = DataObjectFake::get();
 
         $connection = Connection::create('testFake')
-            ->setConnectionType(function() {
+            ->setConnectionType(function () {
                 return $this->manager->getType('TypeCreatorFake');
             });
 
@@ -108,7 +108,7 @@ public function testResolveListSort()
 
         $connection = Connection::create('testFake')
             ->setSortableFields(['MyField'])
-            ->setConnectionType(function() {
+            ->setConnectionType(function () {
                 return $this->manager->getType('TypeCreatorFake');
             });
 
@@ -135,7 +135,7 @@ public function testResolveListSortWithCustomMapping()
 
         $connection = Connection::create('testFake')
             ->setSortableFields(['MyFieldAlias' => 'MyField'])
-            ->setConnectionType(function() {
+            ->setConnectionType(function () {
                 return $this->manager->getType('TypeCreatorFake');
             });
 
@@ -164,7 +164,7 @@ public function testSortByInvalidColumnThrowsException()
 
         $connection = Connection::create('testFake')
             ->setSortableFields(['MyField'])
-            ->setConnectionType(function() {
+            ->setConnectionType(function () {
                 return $this->manager->getType('TypeCreatorFake');
             });
 
@@ -206,7 +206,7 @@ public function testCollectionWithLimits()
 
         $connection = Connection::create('testFakeConnection')
             ->setMaximumLimit(1)
-            ->setConnectionType(function() {
+            ->setConnectionType(function () {
                 return $this->manager->getType('TypeCreatorFake');
             });
 
diff --git a/tests/Fake/DataObjectFake.php b/tests/Fake/DataObjectFake.php
index 5c9b586c7..3dc03b3ba 100644
--- a/tests/Fake/DataObjectFake.php
+++ b/tests/Fake/DataObjectFake.php
@@ -13,11 +13,11 @@ class DataObjectFake extends DataObject implements TestOnly
     ];
 
     private static $has_one = [
-    	'Author' => 'SilverStripe\Security\Member'
+        'Author' => 'SilverStripe\Security\Member'
     ];
 
     private static $many_many = [
-    	'Files' => 'SilverStripe\Assets\File'
+        'Files' => 'SilverStripe\Assets\File'
     ];
 
     public $customSetterFieldResult;
@@ -44,12 +44,23 @@ public function customSetterMethod($val)
         $this->customSetterMethodResult = $val;
     }
 
-	public function canCreate($member = null, $context = []) { return true; }
-	
-	public function canEdit($member = null) { return true; }
-	
-	public function canView($member = null) { return true; }
-	
-	public function canDelete($member = null) { return true; }
-
+    public function canCreate($member = null, $context = [])
+    {
+        return true;
+    }
+    
+    public function canEdit($member = null)
+    {
+        return true;
+    }
+    
+    public function canView($member = null)
+    {
+        return true;
+    }
+    
+    public function canDelete($member = null)
+    {
+        return true;
+    }
 }
diff --git a/tests/Fake/FakeResolver.php b/tests/Fake/FakeResolver.php
index 30a62346d..0fa8de9a8 100644
--- a/tests/Fake/FakeResolver.php
+++ b/tests/Fake/FakeResolver.php
@@ -8,7 +8,6 @@ class FakeResolver implements ResolverInterface
 {
     public function resolve($object, $args, $context, $info)
     {
-    	return 'resolved';
+        return 'resolved';
     }
-
-}
\ No newline at end of file
+}
diff --git a/tests/Fake/MutationCreatorFake.php b/tests/Fake/MutationCreatorFake.php
index a3269a41f..f09bc3c47 100644
--- a/tests/Fake/MutationCreatorFake.php
+++ b/tests/Fake/MutationCreatorFake.php
@@ -8,7 +8,7 @@ class MutationCreatorFake extends MutationCreator
 {
     public function type()
     {
-        return function() {
+        return function () {
             return $this->manager->getType('mytype');
         };
     }
diff --git a/tests/Fake/OperationScaffolderFake.php b/tests/Fake/OperationScaffolderFake.php
index 75b4b99c9..79faa3aa2 100644
--- a/tests/Fake/OperationScaffolderFake.php
+++ b/tests/Fake/OperationScaffolderFake.php
@@ -4,4 +4,7 @@
 
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\OperationScaffolder;
 
-class OperationScaffolderFake extends OperationScaffolder {}
\ No newline at end of file
+class OperationScaffolderFake extends OperationScaffolder
+{
+
+}
diff --git a/tests/Fake/PaginatedQueryFake.php b/tests/Fake/PaginatedQueryFake.php
index 0a1c8b8f4..253c4546f 100644
--- a/tests/Fake/PaginatedQueryFake.php
+++ b/tests/Fake/PaginatedQueryFake.php
@@ -18,10 +18,10 @@ public function connection()
                     'type' => Type::string()
                 ]
             ])
-            ->setConnectionType(function()  {
+            ->setConnectionType(function () {
                 return $this->manager->getType('TypeCreatorFake');
             })
-            ->setConnectionResolver(function() {
+            ->setConnectionResolver(function () {
                 $list = DataObjectFake::get();
 
                 return $list;
diff --git a/tests/Fake/RestrictedDataObjectFake.php b/tests/Fake/RestrictedDataObjectFake.php
index 920b9b3f6..53f9e707b 100644
--- a/tests/Fake/RestrictedDataObjectFake.php
+++ b/tests/Fake/RestrictedDataObjectFake.php
@@ -6,11 +6,23 @@
 
 class RestrictedDataObjectFake extends DataObjectFake implements TestOnly
 {
-	public function canCreate($member = null, $context = []) { return false; }
-	
-	public function canEdit($member = null) { return false; }
-	
-	public function canView($member = null) { return false; }
-	
-	public function canDelete($member = null) { return false; }
+    public function canCreate($member = null, $context = [])
+    {
+        return false;
+    }
+    
+    public function canEdit($member = null)
+    {
+        return false;
+    }
+    
+    public function canView($member = null)
+    {
+        return false;
+    }
+    
+    public function canDelete($member = null)
+    {
+        return false;
+    }
 }
diff --git a/tests/ScaffoldingTest.php b/tests/ScaffoldingTest.php
index 3e920bdf6..74fa77934 100644
--- a/tests/ScaffoldingTest.php
+++ b/tests/ScaffoldingTest.php
@@ -48,1144 +48,1148 @@ class ScaffoldingTest extends SapphireTest
         'SilverStripe\GraphQL\Tests\Fake\RestrictedDataObjectFake'
     ];
 
-	public function testDataObjectScaffolderConstructor()
-	{
-		$scaffolder = $this->getFakeScaffolder();
-		$this->assertEquals(DataObjectFake::class, $scaffolder->getDataObjectClass());
-		$this->assertInstanceOf(DataObjectFake::class, $scaffolder->getDataObjectInstance());
-
-		$this->setExpectedExceptionRegExp(
-			InvalidArgumentException::class,
-			'/non-existent classname/'
-		);
-		$scaffolder = new DataObjectScaffolder('fail');
-	}
-
-	public function testDataObjectScaffolderFields()
-	{
-		$scaffolder = $this->getFakeScaffolder();
-		
-		$scaffolder->addField('MyField');
-		$this->assertEquals(['MyField'], $scaffolder->getFields()->column('Name'));
-		
-		$scaffolder->addField('MyField', 'Some description');
-		$this->assertEquals(
-			'Some description',
-			$scaffolder->getFieldDescription('MyField')
-		);
-
-		$scaffolder->addFields([
-			'MyField',
-			'MyInt' => 'Int description'
-		]);
-		
-		$this->assertEquals(['MyField', 'MyInt'], $scaffolder->getFields()->column('Name'));
-		$this->assertNull(
-			$scaffolder->getFieldDescription('MyField')
-		);
-		$this->assertEquals(
-			'Int description',
-			$scaffolder->getFieldDescription('MyInt')
-		);
-
-		$scaffolder->setFieldDescription('MyInt', 'New int description');
-		$this->assertEquals(
-			'New int description',
-			$scaffolder->getFieldDescription('MyInt')
-		);
-
-		$scaffolder = $this->getFakeScaffolder();
-		$scaffolder->addAllFields();
-		$this->assertEquals(
-			['ID','ClassName','LastEdited','Created','MyField','MyInt'],
-			$scaffolder->getFields()->column('Name')
-		);
-
-		$scaffolder = $this->getFakeScaffolder();
-		$scaffolder->addAllFields(true);
-		$this->assertEquals(
-			['ID','ClassName','LastEdited','Created','MyField','MyInt', 'Author'],
-			$scaffolder->getFields()->column('Name')
-		);
-
-		$scaffolder = $this->getFakeScaffolder();
-		$scaffolder->addAllFieldsExcept('MyInt');
-		$this->assertEquals(
-			['ID','ClassName','LastEdited','Created','MyField'],
-			$scaffolder->getFields()->column('Name')
-		);
-
-		$scaffolder = $this->getFakeScaffolder();
-		$scaffolder->addAllFieldsExcept('MyInt', true);
-		$this->assertEquals(
-			['ID','ClassName','LastEdited','Created','MyField','Author'],
-			$scaffolder->getFields()->column('Name')
-		);
-
-		$scaffolder->removeField('ClassName');
-		$this->assertEquals(
-			['ID','LastEdited','Created','MyField','Author'],
-			$scaffolder->getFields()->column('Name')
-		);
-		$scaffolder->removeFields(['LastEdited','Created']);
-		$this->assertEquals(
-			['ID','MyField','Author'],
-			$scaffolder->getFields()->column('Name')
-		);
-	}
-
-
-	public function testDataObjectScaffolderOperations()
-	{
-		$scaffolder = $this->getFakeScaffolder();
-		$op = $scaffolder->operation(SchemaScaffolder::CREATE);
-
-		$this->assertInstanceOf(CRUDInterface::class, $op);
-
-		// Ensure we get back the same reference
-		$op->Test = true;
-		$op = $scaffolder->operation(SchemaScaffolder::CREATE);
-		$this->assertEquals(true, $op->Test);
-
-		// Ensure duplicates aren't created
-		$scaffolder->operation(SchemaScaffolder::DELETE);
-		$this->assertEquals(2, $scaffolder->getOperations()->count());
-
-		$scaffolder->removeOperation(SchemaScaffolder::DELETE);
-		$this->assertEquals(1, $scaffolder->getOperations()->count());
-
-		$this->setExpectedExceptionRegExp(
-			InvalidArgumentException::class,
-			'/Invalid operation/'
-		);
-		$scaffolder = $this->getFakeScaffolder();
-		$scaffolder->operation('fail');
-	}
-
-	public function testDataObjectScaffolderNestedQueries()
-	{
-		$scaffolder = $this->getFakeScaffolder();
-		$query = $scaffolder->nestedQuery('Files');
-
-		$this->assertInstanceOf(QueryScaffolder::class, $query);
-
-		// Ensure we get back the same reference
-		$query->Test = true;
-		$query = $scaffolder->nestedQuery('Files');
-		$this->assertEquals(true, $query->Test);
-
-		// Ensure duplicates aren't created
-		$this->assertEquals(1, $scaffolder->getNestedQueries()->count());
-
-		$this->setExpectedExceptionRegExp(
-			InvalidArgumentException::class,
-			'/returns a DataList or ArrayList/'
-		);
-		$scaffolder = $this->getFakeScaffolder();
-		$scaffolder->nestedQuery('MyField');
-
-	}
-
-	public function testDataObjectScaffolderDependentClasses()
-	{
-		$scaffolder = $this->getFakeScaffolder();
-		$this->assertEquals([], $scaffolder->getDependentClasses());
-		$scaffolder->nestedQuery('Files');
-		$this->assertEquals(
-			[$scaffolder->getDataObjectInstance()->Files()->dataClass()],
-			$scaffolder->getDependentClasses()
-		);
-
-		$scaffolder->addField('Author');
-		$this->assertEquals(
-			[
-				$scaffolder->getDataObjectInstance()->Author()->class,
-				$scaffolder->getDataObjectInstance()->Files()->dataClass()
-			],
-			$scaffolder->getDependentClasses()
-		);
-	}
-
-	public function testDataObjectScaffolderAncestralClasses()
-	{
-		$scaffolder = new DataObjectScaffolder(RedirectorPage::class);
-		$classes = $scaffolder->getAncestralClasses();
-
-		$this->assertEquals([
-			'Page','SilverStripe\CMS\Model\SiteTree'
-		], $classes);
-
-	}
-
-	public function testDataObjectScaffolderApplyConfig()
-	{
-		$observer = $this->getMockBuilder(DataObjectScaffolder::class)
-			->setConstructorArgs([DataObjectFake::class])
-			->setMethods(['addFields','removeFields','operation','nestedQuery', 'setFieldDescription'])
-			->getMock();
-
-		$observer->expects($this->once())
-			->method('addFields')
-			->with($this->equalTo(['ID','MyField','MyInt']));
-
-		$observer->expects($this->once())
-			->method('removeFields')
-			->with($this->equalTo(['ID']));
-
-		$observer->expects($this->exactly(2))
-			->method('operation')
-			->withConsecutive(
-				[$this->equalTo(SchemaScaffolder::CREATE)],
-				[$this->equalTo(SchemaScaffolder::READ)]
-			)
-			->will($this->returnValue(
-				$this->getMockBuilder(Create::class)
-					->disableOriginalConstructor()
-					->getMock()
-			));
-
-		$observer->expects($this->once())
-			->method('nestedQuery')
-			->with($this->equalTo('Files'))
-			->will($this->returnValue(
-				$this->getMockBuilder(QueryScaffolder::class)
-					->disableOriginalConstructor()
-					->getMock()
-			));
-
-		$observer->expects($this->once())
-			->method('setFieldDescription')
-			->with(
-				$this->equalTo('MyField'),
-				$this->equalTo('This is myfield')
-			);
-
-		$observer->applyConfig([
-			'fields' => ['ID', 'MyField','MyInt'],
-			'excludeFields' => ['ID'],
-			'operations' => ['create' => true,'read' => true],
-			'nestedQueries' => ['Files' => true],
-			'fieldDescriptions' => [
-				'MyField' => 'This is myfield'
-			]
-		]);
-
-	}
-
-	public function testDataObjectScaffolderApplyConfigNoFieldsException()
-	{
-		$scaffolder = $this->getFakeScaffolder();
-
-		// Must have "fields" defined
-		$this->setExpectedExceptionRegExp(
-			Exception::class,
-			'/No array of fields/'
-		);
-		$scaffolder->applyConfig([
-			'operations' => ['create' => true]
-		]);
-	}
-
-	public function testDataObjectScaffolderApplyConfigInvalidFieldsException()
-	{
-		$scaffolder = $this->getFakeScaffolder();
-
-		// Invalid fields
-		$this->setExpectedExceptionRegExp(
-			Exception::class,
-			'/Fields must be an array/'
-		);
-		$scaffolder->applyConfig([
-			'fields' => 'fail'
-		]);
-	}
-
-	public function testDataObjectScaffolderApplyConfigInvalidFieldsExceptException()
-	{
-		$scaffolder = $this->getFakeScaffolder();
-
-		// Invalid fieldsExcept
-		$this->setExpectedExceptionRegExp(
-			InvalidArgumentException::class,
-			'/"excludeFields" must be an enumerated list/'
-		);
-		$scaffolder->applyConfig([
-			'fields' => ['MyField'],
-			'excludeFields' => 'fail'
-		]);
-	}
-
-	public function testDataObjectScaffolderApplyConfigInvalidOperationsException()
-	{
-		$scaffolder = $this->getFakeScaffolder();
-
-		// Invalid operations
-		$this->setExpectedExceptionRegExp(
-			Exception::class,
-			'/Operations field must be a map/'
-		);
-		$scaffolder->applyConfig([
-			'fields' => ['MyField'],
-			'operations' => ['create']
-		]);
-	}
-
-	public function testDataObjectScaffolderApplyConfigInvalidNestedQueriesException()
-	{
-		$scaffolder = $this->getFakeScaffolder();
-
-		// Invalid nested queries
-		$this->setExpectedExceptionRegExp(
-			Exception::class,
-			'/"nestedQueries" must be a map of relation name/'
-		);
-		$scaffolder->applyConfig([
-			'fields' => ['MyField'],
-			'nestedQueries' => ['Files']
-		]);
-	}
-
-
-
-	public function testDataObjectScaffolderWildcards()
-	{
-		$scaffolder = $this->getFakeScaffolder();
-		$scaffolder->applyConfig([
-			'fields' => SchemaScaffolder::ALL,
-			'operations' => SchemaScaffolder::ALL
-		]);
-		$ops = $scaffolder->getOperations();
-
-		$this->assertInstanceOf(Create::class, $ops->findByIdentifier(SchemaScaffolder::CREATE));
-		$this->assertInstanceOf(Delete::class, $ops->findByIdentifier(SchemaScaffolder::DELETE));
-		$this->assertInstanceOf(Read::class, $ops->findByIdentifier(SchemaScaffolder::READ));
-		$this->assertInstanceOf(Update::class, $ops->findByIdentifier(SchemaScaffolder::UPDATE));
-
-		$this->assertEquals(
-			['ID','ClassName','LastEdited','Created','MyField','MyInt','Author'],
-			$scaffolder->getFields()->column('Name')
-		);
-	}
-
-	public function testDataObjectScaffolderScaffold()
-	{
-		$scaffolder = $this->getFakeScaffolder();
-		$scaffolder->addFields(['MyField', 'Author'])
-				   ->nestedQuery('Files');
-
-		$objectType = $scaffolder->scaffold(new Manager());
-
-		$this->assertInstanceof(ObjectType::class, $objectType);
-		$config = $objectType->config;
-
-		$this->assertEquals($scaffolder->typeName(), $config['name']);
-		$this->assertEquals(['MyField', 'Author', 'Files'], array_keys($config['fields']));
-	}
-
-	public function testDataObjectScaffolderScaffoldFieldException()
-	{
-		$this->setExpectedExceptionRegExp(
-			InvalidArgumentException::class,
-			'/Invalid field/'
-		);
-		$scaffolder = $this->getFakeScaffolder()
-			->addFields(['not a field'])
-			->scaffold(new Manager());		
-	}
-
-	public function testDataObjectScaffolderScaffoldNestedQueryException()
-	{
-		$this->setExpectedExceptionRegExp(
-			InvalidArgumentException::class,
-			'/returns a list/'
-		);
-		$scaffolder = $this->getFakeScaffolder()
-			->addFields(['Files'])
-			->scaffold(new Manager());
-	}
-
-	public function testDataObjectScaffolderAddToManager()
-	{
-		$manager = new Manager();
-		$scaffolder = $this->getFakeScaffolder()
-			->addFields(['MyField'])
-			->operation(SchemaScaffolder::CREATE)
-				->end()
-			->operation(SchemaScaffolder::READ)
-				->end();
-
-		$scaffolder->addToManager($manager);
-
-		$schema = $manager->schema();
-		$queryConfig = $schema->getQueryType()->config;
-		$mutationConfig = $schema->getMutationType()->config;
-		$types = $schema->getTypeMap();
-
-		$this->assertArrayHasKey(
-			(new Read(DataObjectFake::class))->getName(),
-			$queryConfig['fields']
-		);
-
-		$this->assertArrayHasKey(
-			(new Create(DataObjectFake::class))->getName(),
-			$mutationConfig['fields']
-		);
-
-		$this->assertTrue($manager->hasType($scaffolder->typeName()));
-
-	}
-
-
-	public function testSchemaScaffolderTypes()
-	{
-
-		$scaffolder = new SchemaScaffolder();
-		$type = $scaffolder->type(DataObjectFake::class);
-		$type->Test = true;
-		$type2 = $scaffolder->type(DataObjectFake::class);
-
-		$query = $scaffolder->query('testQuery', DataObjectFake::class);
-		$query->Test = true;
-		$query2 = $scaffolder->query('testQuery', DataObjectFake::class);
-
-		$mutation = $scaffolder->mutation('testMutation', DataObjectFake::class);
-		$mutation->Test = true;
-		$mutation2 = $scaffolder->mutation('testMutation', DataObjectFake::class);
-
-		$this->assertEquals(1, count($scaffolder->getTypes()));
-		$this->assertTrue($type2->Test);
-
-		$this->assertEquals(1, $scaffolder->getQueries()->count());
-		$this->assertTrue($query2->Test);
-
-		$this->assertEquals(1, $scaffolder->getMutations()->count());
-		$this->assertTrue($mutation2->Test);
-
-		$scaffolder->removeQuery('testQuery');
-		$this->assertEquals(0, $scaffolder->getQueries()->count());
-
-		$scaffolder->removeMutation('testMutation');
-		$this->assertEquals(0, $scaffolder->getMutations()->count());
-
-	}
-
-	public function testSchemaScaffolderAddToManager()
-	{
-		Config::inst()->update('Page','db', [
-			'TestPageField' => 'Varchar'
-		]);
-
-		$manager = new Manager();
-		$scaffolder = (new SchemaScaffolder())
-			->type(RedirectorPage::class)
-				->addFields(['Created','TestPageField', 'RedirectionType'])
-				->operation(SchemaScaffolder::CREATE)
-					->end()
-				->operation(SchemaScaffolder::READ)
-					->end()
-				->end()
-			->type(DataObjectFake::class)
-				->addFields(['Author'])
-				->nestedQuery('Files')
-					->end()
-				->end()
-			->query('testQuery', DataObjectFake::class)
-				->end()
-			->mutation('testMutation', DataObjectFake::class)
-				->end();
-
-		$scaffolder->addToManager($manager);
-		$queries = $scaffolder->getQueries();
-		$mutations = $scaffolder->getMutations();
-		$types = $scaffolder->getTypes();
-
-		$classNames = array_map(function($scaffold) {
-			return $scaffold->getDataObjectClass();
-		}, $types);
-
-		$this->assertEquals([
-			RedirectorPage::class,			
-			DataObjectFake::class,			
-			Page::class,
-			SiteTree::class,
-			Member::class,
-			File::class
-		], $classNames);
-
-		$this->assertEquals(
-			['Created', 'TestPageField', 'RedirectionType'],
-			$scaffolder->type(RedirectorPage::class)->getFields()->column('Name')
-		);
-
-		$this->assertEquals(
-			['Created', 'TestPageField'],
-			$scaffolder->type(Page::class)->getFields()->column('Name')
-		);
-
-		$this->assertEquals(
-			['Created'],
-			$scaffolder->type(SiteTree::class)->getFields()->column('Name')
-		);
-
-
-		$this->assertEquals('testQuery', $scaffolder->getQueries()->first()->getName());
-		$this->assertEquals('testMutation', $scaffolder->getMutations()->first()->getName());
-
-		$this->assertInstanceof(
-			Read::class,			
-			$scaffolder->type(RedirectorPage::class)->getOperations()->findByIdentifier(SchemaScaffolder::READ)
-		);
-		$this->assertInstanceof(
-			Read::class,			
-			$scaffolder->type(Page::class)->getOperations()->findByIdentifier(SchemaScaffolder::READ)
-		);
-		$this->assertInstanceof(
-			Read::class,			
-			$scaffolder->type(SiteTree::class)->getOperations()->findByIdentifier(SchemaScaffolder::READ)
-		);
-
-		$this->assertInstanceof(
-			Create::class,			
-			$scaffolder->type(RedirectorPage::class)->getOperations()->findByIdentifier(SchemaScaffolder::CREATE)
-		);
-		$this->assertInstanceof(
-			Create::class,			
-			$scaffolder->type(Page::class)->getOperations()->findByIdentifier(SchemaScaffolder::CREATE)
-		);
-		$this->assertInstanceof(
-			Create::class,			
-			$scaffolder->type(SiteTree::class)->getOperations()->findByIdentifier(SchemaScaffolder::CREATE)
-		);
-	}
-
-	public function testSchemaScaffolderCreateFromConfigThrowsIfBadTypes()
-	{
-		$this->setExpectedExceptionRegExp(
-			InvalidArgumentException::class,
-			'/"types" must be a map of class name to settings/'
-		);
-		SchemaScaffolder::createFromConfig([
-			'types' => ['fail']
-		]);
-	}
-
-	public function testSchemaScaffolderCreateFromConfigThrowsIfBadQueries()
-	{
-		$this->setExpectedExceptionRegExp(
-			InvalidArgumentException::class,
-			'/must be a map of operation name to settings/'
-		);
-		SchemaScaffolder::createFromConfig([
-			'types' => [
-				DataObjectFake::class => [
-					'fields' => '*'
-				]
-			],
-			'queries' => ['fail']
-		]);
-	}
-
-	public function testSchemaScaffolderCreateFromConfig()
-	{
-		$observer = $this->getMockBuilder(SchemaScaffolder::class)
-			->setMethods(['query','mutation','type'])
-			->getMock();
-
-		$observer->expects($this->once())
-			->method('query')
-			->will($this->returnValue(new QueryScaffolder('test','test')));
-
-		$observer->expects($this->once())
-			->method('mutation')
-			->will($this->returnValue(new MutationScaffolder('test','test')));
-
-		$observer->expects($this->once())
-			->method('type')
-			->willReturn(
-				new DataObjectScaffolder(DataObjectFake::class)
-			);
-
-		Injector::inst()->registerService($observer, SchemaScaffolder::class);
-
-		SchemaScaffolder::createFromConfig([
-			'types' => [
-				DataObjectFake::class => [
-					'fields' => ['MyField']
-				]
-			],
-			'queries' => [
-				'testQuery' => [
-					'type' => DataObjectFake::class,
-					'resolver' => FakeResolver::class
-				]
-			],
-			'mutations' => [
-				'testMutation' => [
-					'type' => DataObjectFake::class,
-					'resolver' => FakeResolver::class
-				]
-			]
-		]);
-	}
-
-	public function testOperationIdentifiers()
-	{
-		$this->assertEquals(
-			Read::class, 
-			OperationScaffolder::getOperationScaffoldFromIdentifier(SchemaScaffolder::READ)
-		);
-		$this->assertEquals(
-			Update::class, 
-			OperationScaffolder::getOperationScaffoldFromIdentifier(SchemaScaffolder::UPDATE)
-		);
-		$this->assertEquals(
-			Delete::class, 
-			OperationScaffolder::getOperationScaffoldFromIdentifier(SchemaScaffolder::DELETE)
-		);
-		$this->assertEquals(
-			Create::class, 
-			OperationScaffolder::getOperationScaffoldFromIdentifier(SchemaScaffolder::CREATE)
-		);
-
-	}
-
-	public function testOperationScaffolderArgs()
-	{
-		$scaffolder = new OperationScaffolderFake('testOperation','testType');
-		
-		$this->assertEquals('testOperation', $scaffolder->getName());
-		$scaffolder->addArgs([
-			'One' => 'String',
-			'Two' => 'Boolean'
-		]);
-		$scaffolder->addArg(
-			'One', 'String', 'One description', 'One default'
-		);
-
-		$this->assertEquals([], array_diff(
-			$scaffolder->getArgs()->column('argName'),
-			['One','Two']
-		));
-
-		$argument = $scaffolder->getArgs()->find('argName', 'One');
-		$this->assertInstanceOf(ArgumentScaffolder::class, $argument);
-		$arr = $argument->toArray();
-		$this->assertEquals('One description', $arr['description']);
-		$this->assertEquals('One default', $arr['defaultValue']);
-
-		$scaffolder->setArgDescriptions([
-			'One' => 'Foo',
-			'Two' => 'Bar'
-		]);
-
-		$scaffolder->setArgDefaults([
-			'One' => 'Feijoa',
-			'Two' => 'Kiwifruit'
-		]);
-
-		$argument = $scaffolder->getArgs()->find('argName', 'One');
-		$arr = $argument->toArray();
-		$this->assertEquals('Foo', $arr['description']);
-		$this->assertEquals('Feijoa', $arr['defaultValue']);
-
-		$argument = $scaffolder->getArgs()->find('argName', 'Two');
-		$arr = $argument->toArray();
-		$this->assertEquals('Bar', $arr['description']);
-		$this->assertEquals('Kiwifruit', $arr['defaultValue']);
-
-		$scaffolder->setArgDescription('One', 'Tui')
-			->setArgDefault('One', 'Moa');
-
-		$argument = $scaffolder->getArgs()->find('argName', 'One');
-		$arr = $argument->toArray();
-		$this->assertEquals('Tui', $arr['description']);
-		$this->assertEquals('Moa', $arr['defaultValue']);
-
-		$scaffolder->removeArg('One');
-		$this->assertEquals(['Two'], $scaffolder->getArgs()->column('argName'));
-		$scaffolder->addArg('Test', 'String');
-		$scaffolder->removeArgs(['Two','Test']);
-		$this->assertFalse($scaffolder->getArgs()->exists());
-
-		$ex = null;
-		try {
-			$scaffolder->setArgDescription('Nothing', 'Test');
-		} catch (Exception $e) {
-			$ex = $e;
-		}
-
-		$this->assertInstanceOf(InvalidArgumentException::class, $ex);
-		$this->assertRegExp('/Tried to set description/', $ex->getMessage());
-
-		$ex = null;
-		try {
-			$scaffolder->setArgDefault('Nothing', 'Test');
-		} catch (Exception $e) {
-			$ex = $e;
-		}
-
-		$this->assertInstanceOf(InvalidArgumentException::class, $ex);
-		$this->assertRegExp('/Tried to set default/', $ex->getMessage());
-	}
-
-	public function testOperationScaffolderResolver()
-	{
-		$scaffolder = new OperationScaffolderFake('testOperation','testType');
-
-		try {
-			$scaffolder->setResolver(function() {});
-			$scaffolder->setResolver(FakeResolver::class);
-			$scaffolder->setResolver(new FakeResolver());
-			$success = true;
-		} catch (Exception $e) {
-			$success = false;
-		}
-
-		$this->assertTrue($success);
-
-		$this->setExpectedExceptionRegExp(
-			InvalidArgumentException::class,
-			'/closures, instances of/'
-		);
-		$scaffolder->setResolver('fail');
-	}
-
-	public function testOperationScaffolderAppliesConfig()
-	{
-		$scaffolder = new OperationScaffolderFake('testOperation','testType');
-		
-		
-		$scaffolder->applyConfig([
-			'args' => [
-				'One' => 'String',
-				'Two' => [
-					'type' => 'String',
-					'default' => 'Foo',
-					'description' => 'Bar'
-				]
-			],
-			'resolver' => FakeResolver::class
-		]);
-
-		$this->assertEquals([], array_diff(
-			$scaffolder->getArgs()->column('argName'),
-			['One','Two']
-		));
-
-		$arg = $scaffolder->getArgs()->find('argName', 'Two');
-		$this->assertInstanceof(ArgumentScaffolder::class, $arg);
-		$arr = $arg->toArray();
-		$this->assertInstanceOf(StringType::class, $arr['type']);
-
-		$ex = null;
-		try {
-			$scaffolder->applyConfig([
-				'args' => 'fail'
-			]);
-		} catch (Exception $e) {
-			$ex = $e;
-		}
-
-		$this->assertInstanceof(Exception::class, $e);
-		$this->assertRegExp('/args must be an array/', $e->getMessage());
-
-		$ex = null;
-		try {
-			$scaffolder->applyConfig([
-				'args' => [
-					'One' => [					
-						'default' => 'Foo',
-						'description' => 'Bar'
-					]
-				]
-			]);
-		} catch (Exception $e) {
-			$ex = $e;
-		}
-
-		$this->assertInstanceof(Exception::class, $e);
-		$this->assertRegExp('/must have a type/', $e->getMessage());
-
-		$ex = null;
-		try {
-			$scaffolder->applyConfig([
-				'args' => [
-					'One' => false
-				]
-			]);
-		} catch (Exception $e) {
-			$ex = $e;
-		}
-
-		$this->assertInstanceof(Exception::class, $e);
-		$this->assertRegExp('/should be mapped to a string or an array/', $e->getMessage());
-
-	}
-
-	public function testArgumentScaffolder()
-	{
-		$scaffolder = new ArgumentScaffolder('Test', 'String');
-		$scaffolder->setRequired(false)
-			->setDescription('Description')
-			->setDefaultValue('Default');
-
-		$this->assertEquals('Description', $scaffolder->getDescription());
-		$this->assertEquals('Default', $scaffolder->getDefaultValue());
-		$this->assertFalse($scaffolder->isRequired());
-
-		$scaffolder->applyConfig([
-			'description' => 'Foo',
-			'default' => 'Bar',
-			'required' => true
-		]);
-
-		$this->assertEquals('Foo', $scaffolder->getDescription());
-		$this->assertEquals('Bar', $scaffolder->getDefaultValue());
-		$this->assertTrue($scaffolder->isRequired());
-
-		$arr = $scaffolder->toArray();
-
-		$this->assertEquals('Foo', $arr['description']);
-		$this->assertEquals('Bar', $arr['defaultValue']);
-		$this->assertInstanceOf(NonNull::class, $arr['type']);
-		$this->assertInstanceOf(StringType::class, $arr['type']->getWrappedType());
-	}
-
-	public function testMutationScaffolder()
-	{
-		$observer = $this->getMockBuilder(Manager::class)
-			->setMethods(['addMutation'])
-			->getMock();
-		$scaffolder = new MutationScaffolder('testMutation', 'test');
-		$scaffolder->addArgs(['Test' => 'String']);
-		$scaffold = $scaffolder->scaffold($manager = new Manager());
-		$manager->addType($o = new ObjectType([
-			'name' => 'test',
-			'fields' => []
-		]));
-		$o->Test = true;
-
-		$this->assertEquals('testMutation', $scaffold['name']);
-		$this->assertArrayHasKey('Test', $scaffold['args']);
-		$this->assertTrue(is_callable($scaffold['resolve']));
-		$this->assertTrue($scaffold['type']()->Test);
-
-		$observer->expects($this->once())
-			->method('addMutation')
-			->with(
-				$this->equalTo($scaffold),
-				$this->equalTo('testMutation')
-			);
-
-		$scaffolder->addToManager($observer);
-	}
-
-	public function testQueryScaffolderUnpaginated()
-	{
-		$observer = $this->getMockBuilder(Manager::class)
-			->setMethods(['addQuery'])
-			->getMock();
-		$scaffolder = new QueryScaffolder('testQuery', 'test');
-		$scaffolder->setUsePagination(false);
-		$scaffolder->addArgs(['Test' => 'String']);
-		$scaffold = $scaffolder->scaffold($manager = new Manager());
-		
-		$manager->addType($o = new ObjectType([
-			'name' => 'test',
-			'fields' => []
-		]));
-		$o->Test = true;
-
-		$this->assertEquals('testQuery', $scaffold['name']);
-		$this->assertArrayHasKey('Test', $scaffold['args']);
-		$this->assertTrue(is_callable($scaffold['resolve']));
-		$this->assertTrue($scaffold['type']()->Test);
-
-		$observer->expects($this->once())
-			->method('addQuery')
-			->with(
-				$this->equalTo($scaffold),
-				$this->equalTo('testQuery')
-			);
-
-		$scaffolder->addToManager($observer);
-	}
-
-	public function testQueryScaffolderPaginated()
-	{
-		$scaffolder = new QueryScaffolder('testQuery', 'test');
-		$scaffolder->setUsePagination(true);
-		$scaffolder->addArgs(['Test' => 'String']);
-		$scaffolder->addSortableFields(['test']);
-		$scaffold = $scaffolder->scaffold($manager = new Manager());
-		$manager->addType($o = new ObjectType([
-			'name' => 'test',
-			'fields' => []
-		]));
-		$o->Test = true;
-		$config = $scaffold['type']()->config;
-
-		$this->assertEquals('testQueryConnection', $config['name']);
-		$this->assertArrayHasKey('pageInfo', $config['fields']);
-		$this->assertArrayHasKey('edges', $config['fields']);
-	}
-
-	public function testQueryScaffolderApplyConfig()
-	{
-		$mock = $this->getMockBuilder(QueryScaffolder::class)
-			->setConstructorArgs(['testQuery', 'testType'])
-			->setMethods(['addSortableFields','setUsePagination'])
-			->getMock();
-		$mock->expects($this->once())
-			->method('addSortableFields')
-			->with(['Test1','Test2']);
-		$mock->expects($this->once())
-			->method('setUsePagination')
-			->with(false);
-
-		$mock->applyConfig([
-			'sortableFields' => ['Test1','Test2'],
-			'paginate' => false
-		]);
-	}
-
-	public function testQueryScaffolderApplyConfigThrowsOnBadSortableFields()
-	{
-		$scaffolder = new QueryScaffolder('testQuery','testType');
-		$this->setExpectedExceptionRegExp(
-			InvalidArgumentException::class,
-			'/sortableFields must be an array/'
-		);
-		$scaffolder->applyConfig([
-			'sortableFields' => 'fail'			
-		]);
-	}
-
-	public function testCreateOperationResolver()
-	{
-		$create = new Create(DataObjectFake::class);
-		$scaffold = $create->scaffold(new Manager());
-
-		$newRecord = $scaffold['resolve'](
-			null,
-			[
-				'Input' => ['MyField' => '__testing__']
-			],
-			[
-				'currentMember' => Member::create()
-			],
-			new ResolveInfo([])
-		);
-
-		$this->assertGreaterThan(0, $newRecord->ID);
-		$this->assertEquals('__testing__', $newRecord->MyField);
-	}
-
-	public function testCreateOperationInputType()
-	{
-		$create = new Create(DataObjectFake::class);
-		$scaffold = $create->scaffold(new Manager());
-
-		$this->assertArrayHasKey('Input', $scaffold['args']);
-		$this->assertInstanceof(NonNull::class, $scaffold['args']['Input']['type']);
-		
-		$config = $scaffold['args']['Input']['type']->getWrappedType()->config;
-
-		$this->assertEquals('Data_Object_FakeCreateInputType', $config['name']);
-		$fieldMap = [];
-		foreach($config['fields'] as $name => $fieldData) {
-			$fieldMap[$name] = $fieldData['type'];
-		}
-		$this->assertArrayHasKey('MyField', $fieldMap);
-		$this->assertArrayHasKey('MyInt', $fieldMap);
-		$this->assertArrayNotHasKey('ID', $fieldMap);
-		$this->assertInstanceOf(StringType::class, $fieldMap['MyField']);
-		$this->assertInstanceOf(IntType::class, $fieldMap['MyInt']);
-	}
-
-	public function testCreateOperationPermissionCheck()
-	{
-		$create = new Create(RestrictedDataObjectFake::class);
-		$scaffold = $create->scaffold(new Manager());		
-
-		$this->setExpectedExceptionRegExp(
-			Exception::class,
-			'/Cannot create/'
-		);
-
-		$scaffold['resolve'](
-			null, 
-			[], 
-			['currentMember' => Member::create()], 
-			new ResolveInfo([])
-		);
-	}
-
-	public function testUpdateOperationResolver()
-	{
-		$update = new Update(DataObjectFake::class);
-		$scaffold = $update->scaffold(new Manager());
-
-		$record = DataObjectFake::create([
-			'MyField' => 'old'
-		]);
-		$ID = $record->write();
-
-		$scaffold['resolve'](
-			$record,
-			[
-				'ID' => $ID,
-				'Input' => ['MyField' => 'new']
-			],
-			[
-				'currentMember' => Member::create()
-			],
-			new ResolveInfo([])
-		);
-		$updatedRecord = DataObjectFake::get()->byID($ID);	
-		$this->assertEquals('new', $updatedRecord->MyField);
-	}
-
-	public function testUpdateOperationInputType()
-	{
-		$update = new Update(DataObjectFake::class);
-		$scaffold = $update->scaffold(new Manager());
-
-		$this->assertArrayHasKey('Input', $scaffold['args']);
-		$this->assertInstanceof(NonNull::class, $scaffold['args']['Input']['type']);
-		
-		$config = $scaffold['args']['Input']['type']->getWrappedType()->config;
-
-		$this->assertEquals('Data_Object_FakeUpdateInputType', $config['name']);
-		$fieldMap = [];
-		foreach($config['fields'] as $name => $fieldData) {
-			$fieldMap[$name] = $fieldData['type'];
-		}
-		$this->assertArrayHasKey('MyField', $fieldMap);
-		$this->assertArrayHasKey('MyInt', $fieldMap);
-		$this->assertArrayNotHasKey('ID', $fieldMap);
-		$this->assertInstanceOf(StringType::class, $fieldMap['MyField']);
-		$this->assertInstanceOf(IntType::class, $fieldMap['MyInt']);
-	}
-
-	public function testUpdateOperationPermissionCheck()
-	{
-		$update = new Update(RestrictedDataObjectFake::class);
-		$restrictedDataobject = RestrictedDataObjectFake::create();
-		$ID = $restrictedDataobject->write();
-
-		$scaffold = $update->scaffold(new Manager());		
-
-		$this->setExpectedExceptionRegExp(
-			Exception::class,
-			'/Cannot edit/'
-		);
-
-		$scaffold['resolve'](
-			$restrictedDataobject, 
-			['ID' => $ID], 
-			['currentMember' => Member::create()], 
-			new ResolveInfo([])
-		);
-	}
-
-
-	public function testDeleteOperationResolver()
-	{
-		$delete = new Delete(DataObjectFake::class);
-		$scaffold = $delete->scaffold(new Manager());
-
-		$record = DataObjectFake::create();
-		$ID1 = $record->write();
-
-		$record = DataObjectFake::create();
-		$ID2 = $record->write();
-
-		$record = DataObjectFake::create();
-		$ID3 = $record->write();
-
-		$scaffold['resolve'](
-			$record,
-			[			
-				'IDs' => [$ID1, $ID2]
-			],
-			[
-				'currentMember' => Member::create()
-			],
-			new ResolveInfo([])
-		);
-		
-		$this->assertNull(DataObjectFake::get()->byID($ID1));
-		$this->assertNull(DataObjectFake::get()->byID($ID2));
-		$this->assertInstanceOf(DataObjectFake::class, DataObjectFake::get()->byID($ID3));
-	}
-
-	public function testDeleteOperationArgs()
-	{
-		$delete = new Delete(DataObjectFake::class);
-		$scaffold = $delete->scaffold(new Manager());
-
-		$this->assertArrayHasKey('IDs', $scaffold['args']);
-		$this->assertInstanceof(NonNull::class, $scaffold['args']['IDs']['type']);
-		
-		$listOf = $scaffold['args']['IDs']['type']->getWrappedType();
-
-		$this->assertInstanceOf(ListOfType::class, $listOf);
-
-		$idType = $listOf->getWrappedType();
-
-		$this->assertInstanceof(IDType::class, $idType);
-	}
-
-	public function testDeleteOperationPermissionCheck()
-	{
-		$delete = new Delete(RestrictedDataObjectFake::class);
-		$restrictedDataobject = RestrictedDataObjectFake::create();
-		$ID = $restrictedDataobject->write();
-
-		$scaffold = $delete->scaffold(new Manager());		
-
-		$this->setExpectedExceptionRegExp(
-			Exception::class,
-			'/Cannot delete/'
-		);
-
-		$scaffold['resolve'](
-			$restrictedDataobject, 
-			['IDs' => [$ID]], 
-			['currentMember' => Member::create()], 
-			new ResolveInfo([])
-		);
-	}
-
-	public function testReadOperationResolver()
-	{
-		$read = new Read(DataObjectFake::class);
-		$scaffold = $read->scaffold(new Manager());
-
-		DataObjectFake::get()->removeAll();
-		
-		$record = DataObjectFake::create();
-		$ID1 = $record->write();
-
-		$record = DataObjectFake::create();
-		$ID2 = $record->write();
-
-		$record = DataObjectFake::create();
-		$ID3 = $record->write();
-
-		$response = $scaffold['resolve'](
-			null,
-			[],
-			[
-				'currentMember' => Member::create()
-			],
-			new ResolveInfo([])
-		);
-
-		$this->assertArrayHasKey('edges', $response);
-		$this->assertEquals([$ID1, $ID2, $ID3], $response['edges']->column('ID'));
-	}
+    public function testDataObjectScaffolderConstructor()
+    {
+        $scaffolder = $this->getFakeScaffolder();
+        $this->assertEquals(DataObjectFake::class, $scaffolder->getDataObjectClass());
+        $this->assertInstanceOf(DataObjectFake::class, $scaffolder->getDataObjectInstance());
+
+        $this->setExpectedExceptionRegExp(
+            InvalidArgumentException::class,
+            '/non-existent classname/'
+        );
+        $scaffolder = new DataObjectScaffolder('fail');
+    }
+
+    public function testDataObjectScaffolderFields()
+    {
+        $scaffolder = $this->getFakeScaffolder();
+        
+        $scaffolder->addField('MyField');
+        $this->assertEquals(['MyField'], $scaffolder->getFields()->column('Name'));
+        
+        $scaffolder->addField('MyField', 'Some description');
+        $this->assertEquals(
+            'Some description',
+            $scaffolder->getFieldDescription('MyField')
+        );
+
+        $scaffolder->addFields([
+            'MyField',
+            'MyInt' => 'Int description'
+        ]);
+        
+        $this->assertEquals(['MyField', 'MyInt'], $scaffolder->getFields()->column('Name'));
+        $this->assertNull(
+            $scaffolder->getFieldDescription('MyField')
+        );
+        $this->assertEquals(
+            'Int description',
+            $scaffolder->getFieldDescription('MyInt')
+        );
+
+        $scaffolder->setFieldDescription('MyInt', 'New int description');
+        $this->assertEquals(
+            'New int description',
+            $scaffolder->getFieldDescription('MyInt')
+        );
+
+        $scaffolder = $this->getFakeScaffolder();
+        $scaffolder->addAllFields();
+        $this->assertEquals(
+            ['ID','ClassName','LastEdited','Created','MyField','MyInt'],
+            $scaffolder->getFields()->column('Name')
+        );
+
+        $scaffolder = $this->getFakeScaffolder();
+        $scaffolder->addAllFields(true);
+        $this->assertEquals(
+            ['ID','ClassName','LastEdited','Created','MyField','MyInt', 'Author'],
+            $scaffolder->getFields()->column('Name')
+        );
+
+        $scaffolder = $this->getFakeScaffolder();
+        $scaffolder->addAllFieldsExcept('MyInt');
+        $this->assertEquals(
+            ['ID','ClassName','LastEdited','Created','MyField'],
+            $scaffolder->getFields()->column('Name')
+        );
+
+        $scaffolder = $this->getFakeScaffolder();
+        $scaffolder->addAllFieldsExcept('MyInt', true);
+        $this->assertEquals(
+            ['ID','ClassName','LastEdited','Created','MyField','Author'],
+            $scaffolder->getFields()->column('Name')
+        );
+
+        $scaffolder->removeField('ClassName');
+        $this->assertEquals(
+            ['ID','LastEdited','Created','MyField','Author'],
+            $scaffolder->getFields()->column('Name')
+        );
+        $scaffolder->removeFields(['LastEdited','Created']);
+        $this->assertEquals(
+            ['ID','MyField','Author'],
+            $scaffolder->getFields()->column('Name')
+        );
+    }
+
+
+    public function testDataObjectScaffolderOperations()
+    {
+        $scaffolder = $this->getFakeScaffolder();
+        $op = $scaffolder->operation(SchemaScaffolder::CREATE);
+
+        $this->assertInstanceOf(CRUDInterface::class, $op);
+
+        // Ensure we get back the same reference
+        $op->Test = true;
+        $op = $scaffolder->operation(SchemaScaffolder::CREATE);
+        $this->assertEquals(true, $op->Test);
+
+        // Ensure duplicates aren't created
+        $scaffolder->operation(SchemaScaffolder::DELETE);
+        $this->assertEquals(2, $scaffolder->getOperations()->count());
+
+        $scaffolder->removeOperation(SchemaScaffolder::DELETE);
+        $this->assertEquals(1, $scaffolder->getOperations()->count());
+
+        $this->setExpectedExceptionRegExp(
+            InvalidArgumentException::class,
+            '/Invalid operation/'
+        );
+        $scaffolder = $this->getFakeScaffolder();
+        $scaffolder->operation('fail');
+    }
+
+    public function testDataObjectScaffolderNestedQueries()
+    {
+        $scaffolder = $this->getFakeScaffolder();
+        $query = $scaffolder->nestedQuery('Files');
+
+        $this->assertInstanceOf(QueryScaffolder::class, $query);
+
+        // Ensure we get back the same reference
+        $query->Test = true;
+        $query = $scaffolder->nestedQuery('Files');
+        $this->assertEquals(true, $query->Test);
+
+        // Ensure duplicates aren't created
+        $this->assertEquals(1, $scaffolder->getNestedQueries()->count());
+
+        $this->setExpectedExceptionRegExp(
+            InvalidArgumentException::class,
+            '/returns a DataList or ArrayList/'
+        );
+        $scaffolder = $this->getFakeScaffolder();
+        $scaffolder->nestedQuery('MyField');
+
+    }
+
+    public function testDataObjectScaffolderDependentClasses()
+    {
+        $scaffolder = $this->getFakeScaffolder();
+        $this->assertEquals([], $scaffolder->getDependentClasses());
+        $scaffolder->nestedQuery('Files');
+        $this->assertEquals(
+            [$scaffolder->getDataObjectInstance()->Files()->dataClass()],
+            $scaffolder->getDependentClasses()
+        );
+
+        $scaffolder->addField('Author');
+        $this->assertEquals(
+            [
+                $scaffolder->getDataObjectInstance()->Author()->class,
+                $scaffolder->getDataObjectInstance()->Files()->dataClass()
+            ],
+            $scaffolder->getDependentClasses()
+        );
+    }
+
+    public function testDataObjectScaffolderAncestralClasses()
+    {
+        $scaffolder = new DataObjectScaffolder(RedirectorPage::class);
+        $classes = $scaffolder->getAncestralClasses();
+
+        $this->assertEquals([
+            'Page','SilverStripe\CMS\Model\SiteTree'
+        ], $classes);
+
+    }
+
+    public function testDataObjectScaffolderApplyConfig()
+    {
+        $observer = $this->getMockBuilder(DataObjectScaffolder::class)
+            ->setConstructorArgs([DataObjectFake::class])
+            ->setMethods(['addFields','removeFields','operation','nestedQuery', 'setFieldDescription'])
+            ->getMock();
+
+        $observer->expects($this->once())
+            ->method('addFields')
+            ->with($this->equalTo(['ID','MyField','MyInt']));
+
+        $observer->expects($this->once())
+            ->method('removeFields')
+            ->with($this->equalTo(['ID']));
+
+        $observer->expects($this->exactly(2))
+            ->method('operation')
+            ->withConsecutive(
+                [$this->equalTo(SchemaScaffolder::CREATE)],
+                [$this->equalTo(SchemaScaffolder::READ)]
+            )
+            ->will($this->returnValue(
+                $this->getMockBuilder(Create::class)
+                    ->disableOriginalConstructor()
+                    ->getMock()
+            ));
+
+        $observer->expects($this->once())
+            ->method('nestedQuery')
+            ->with($this->equalTo('Files'))
+            ->will($this->returnValue(
+                $this->getMockBuilder(QueryScaffolder::class)
+                    ->disableOriginalConstructor()
+                    ->getMock()
+            ));
+
+        $observer->expects($this->once())
+            ->method('setFieldDescription')
+            ->with(
+                $this->equalTo('MyField'),
+                $this->equalTo('This is myfield')
+            );
+
+        $observer->applyConfig([
+            'fields' => ['ID', 'MyField','MyInt'],
+            'excludeFields' => ['ID'],
+            'operations' => ['create' => true,'read' => true],
+            'nestedQueries' => ['Files' => true],
+            'fieldDescriptions' => [
+                'MyField' => 'This is myfield'
+            ]
+        ]);
+
+    }
+
+    public function testDataObjectScaffolderApplyConfigNoFieldsException()
+    {
+        $scaffolder = $this->getFakeScaffolder();
+
+        // Must have "fields" defined
+        $this->setExpectedExceptionRegExp(
+            Exception::class,
+            '/No array of fields/'
+        );
+        $scaffolder->applyConfig([
+            'operations' => ['create' => true]
+        ]);
+    }
+
+    public function testDataObjectScaffolderApplyConfigInvalidFieldsException()
+    {
+        $scaffolder = $this->getFakeScaffolder();
+
+        // Invalid fields
+        $this->setExpectedExceptionRegExp(
+            Exception::class,
+            '/Fields must be an array/'
+        );
+        $scaffolder->applyConfig([
+            'fields' => 'fail'
+        ]);
+    }
+
+    public function testDataObjectScaffolderApplyConfigInvalidFieldsExceptException()
+    {
+        $scaffolder = $this->getFakeScaffolder();
+
+        // Invalid fieldsExcept
+        $this->setExpectedExceptionRegExp(
+            InvalidArgumentException::class,
+            '/"excludeFields" must be an enumerated list/'
+        );
+        $scaffolder->applyConfig([
+            'fields' => ['MyField'],
+            'excludeFields' => 'fail'
+        ]);
+    }
+
+    public function testDataObjectScaffolderApplyConfigInvalidOperationsException()
+    {
+        $scaffolder = $this->getFakeScaffolder();
+
+        // Invalid operations
+        $this->setExpectedExceptionRegExp(
+            Exception::class,
+            '/Operations field must be a map/'
+        );
+        $scaffolder->applyConfig([
+            'fields' => ['MyField'],
+            'operations' => ['create']
+        ]);
+    }
+
+    public function testDataObjectScaffolderApplyConfigInvalidNestedQueriesException()
+    {
+        $scaffolder = $this->getFakeScaffolder();
+
+        // Invalid nested queries
+        $this->setExpectedExceptionRegExp(
+            Exception::class,
+            '/"nestedQueries" must be a map of relation name/'
+        );
+        $scaffolder->applyConfig([
+            'fields' => ['MyField'],
+            'nestedQueries' => ['Files']
+        ]);
+    }
+
+
+
+    public function testDataObjectScaffolderWildcards()
+    {
+        $scaffolder = $this->getFakeScaffolder();
+        $scaffolder->applyConfig([
+            'fields' => SchemaScaffolder::ALL,
+            'operations' => SchemaScaffolder::ALL
+        ]);
+        $ops = $scaffolder->getOperations();
+
+        $this->assertInstanceOf(Create::class, $ops->findByIdentifier(SchemaScaffolder::CREATE));
+        $this->assertInstanceOf(Delete::class, $ops->findByIdentifier(SchemaScaffolder::DELETE));
+        $this->assertInstanceOf(Read::class, $ops->findByIdentifier(SchemaScaffolder::READ));
+        $this->assertInstanceOf(Update::class, $ops->findByIdentifier(SchemaScaffolder::UPDATE));
+
+        $this->assertEquals(
+            ['ID','ClassName','LastEdited','Created','MyField','MyInt','Author'],
+            $scaffolder->getFields()->column('Name')
+        );
+    }
+
+    public function testDataObjectScaffolderScaffold()
+    {
+        $scaffolder = $this->getFakeScaffolder();
+        $scaffolder->addFields(['MyField', 'Author'])
+                   ->nestedQuery('Files');
+
+        $objectType = $scaffolder->scaffold(new Manager());
+
+        $this->assertInstanceof(ObjectType::class, $objectType);
+        $config = $objectType->config;
+
+        $this->assertEquals($scaffolder->typeName(), $config['name']);
+        $this->assertEquals(['MyField', 'Author', 'Files'], array_keys($config['fields']));
+    }
+
+    public function testDataObjectScaffolderScaffoldFieldException()
+    {
+        $this->setExpectedExceptionRegExp(
+            InvalidArgumentException::class,
+            '/Invalid field/'
+        );
+        $scaffolder = $this->getFakeScaffolder()
+            ->addFields(['not a field'])
+            ->scaffold(new Manager());
+    }
+
+    public function testDataObjectScaffolderScaffoldNestedQueryException()
+    {
+        $this->setExpectedExceptionRegExp(
+            InvalidArgumentException::class,
+            '/returns a list/'
+        );
+        $scaffolder = $this->getFakeScaffolder()
+            ->addFields(['Files'])
+            ->scaffold(new Manager());
+    }
+
+    public function testDataObjectScaffolderAddToManager()
+    {
+        $manager = new Manager();
+        $scaffolder = $this->getFakeScaffolder()
+            ->addFields(['MyField'])
+            ->operation(SchemaScaffolder::CREATE)
+                ->end()
+            ->operation(SchemaScaffolder::READ)
+                ->end();
+
+        $scaffolder->addToManager($manager);
+
+        $schema = $manager->schema();
+        $queryConfig = $schema->getQueryType()->config;
+        $mutationConfig = $schema->getMutationType()->config;
+        $types = $schema->getTypeMap();
+
+        $this->assertArrayHasKey(
+            (new Read(DataObjectFake::class))->getName(),
+            $queryConfig['fields']
+        );
+
+        $this->assertArrayHasKey(
+            (new Create(DataObjectFake::class))->getName(),
+            $mutationConfig['fields']
+        );
+
+        $this->assertTrue($manager->hasType($scaffolder->typeName()));
+
+    }
+
+
+    public function testSchemaScaffolderTypes()
+    {
+
+        $scaffolder = new SchemaScaffolder();
+        $type = $scaffolder->type(DataObjectFake::class);
+        $type->Test = true;
+        $type2 = $scaffolder->type(DataObjectFake::class);
+
+        $query = $scaffolder->query('testQuery', DataObjectFake::class);
+        $query->Test = true;
+        $query2 = $scaffolder->query('testQuery', DataObjectFake::class);
+
+        $mutation = $scaffolder->mutation('testMutation', DataObjectFake::class);
+        $mutation->Test = true;
+        $mutation2 = $scaffolder->mutation('testMutation', DataObjectFake::class);
+
+        $this->assertEquals(1, count($scaffolder->getTypes()));
+        $this->assertTrue($type2->Test);
+
+        $this->assertEquals(1, $scaffolder->getQueries()->count());
+        $this->assertTrue($query2->Test);
+
+        $this->assertEquals(1, $scaffolder->getMutations()->count());
+        $this->assertTrue($mutation2->Test);
+
+        $scaffolder->removeQuery('testQuery');
+        $this->assertEquals(0, $scaffolder->getQueries()->count());
+
+        $scaffolder->removeMutation('testMutation');
+        $this->assertEquals(0, $scaffolder->getMutations()->count());
+
+    }
+
+    public function testSchemaScaffolderAddToManager()
+    {
+        Config::inst()->update('Page', 'db', [
+            'TestPageField' => 'Varchar'
+        ]);
+
+        $manager = new Manager();
+        $scaffolder = (new SchemaScaffolder())
+            ->type(RedirectorPage::class)
+                ->addFields(['Created','TestPageField', 'RedirectionType'])
+                ->operation(SchemaScaffolder::CREATE)
+                    ->end()
+                ->operation(SchemaScaffolder::READ)
+                    ->end()
+                ->end()
+            ->type(DataObjectFake::class)
+                ->addFields(['Author'])
+                ->nestedQuery('Files')
+                    ->end()
+                ->end()
+            ->query('testQuery', DataObjectFake::class)
+                ->end()
+            ->mutation('testMutation', DataObjectFake::class)
+                ->end();
+
+        $scaffolder->addToManager($manager);
+        $queries = $scaffolder->getQueries();
+        $mutations = $scaffolder->getMutations();
+        $types = $scaffolder->getTypes();
+
+        $classNames = array_map(function ($scaffold) {
+            return $scaffold->getDataObjectClass();
+        }, $types);
+
+        $this->assertEquals([
+            RedirectorPage::class,
+            DataObjectFake::class,
+            Page::class,
+            SiteTree::class,
+            Member::class,
+            File::class
+        ], $classNames);
+
+        $this->assertEquals(
+            ['Created', 'TestPageField', 'RedirectionType'],
+            $scaffolder->type(RedirectorPage::class)->getFields()->column('Name')
+        );
+
+        $this->assertEquals(
+            ['Created', 'TestPageField'],
+            $scaffolder->type(Page::class)->getFields()->column('Name')
+        );
+
+        $this->assertEquals(
+            ['Created'],
+            $scaffolder->type(SiteTree::class)->getFields()->column('Name')
+        );
+
+
+        $this->assertEquals('testQuery', $scaffolder->getQueries()->first()->getName());
+        $this->assertEquals('testMutation', $scaffolder->getMutations()->first()->getName());
+
+        $this->assertInstanceof(
+            Read::class,
+            $scaffolder->type(RedirectorPage::class)->getOperations()->findByIdentifier(SchemaScaffolder::READ)
+        );
+        $this->assertInstanceof(
+            Read::class,
+            $scaffolder->type(Page::class)->getOperations()->findByIdentifier(SchemaScaffolder::READ)
+        );
+        $this->assertInstanceof(
+            Read::class,
+            $scaffolder->type(SiteTree::class)->getOperations()->findByIdentifier(SchemaScaffolder::READ)
+        );
+
+        $this->assertInstanceof(
+            Create::class,
+            $scaffolder->type(RedirectorPage::class)->getOperations()->findByIdentifier(SchemaScaffolder::CREATE)
+        );
+        $this->assertInstanceof(
+            Create::class,
+            $scaffolder->type(Page::class)->getOperations()->findByIdentifier(SchemaScaffolder::CREATE)
+        );
+        $this->assertInstanceof(
+            Create::class,
+            $scaffolder->type(SiteTree::class)->getOperations()->findByIdentifier(SchemaScaffolder::CREATE)
+        );
+    }
+
+    public function testSchemaScaffolderCreateFromConfigThrowsIfBadTypes()
+    {
+        $this->setExpectedExceptionRegExp(
+            InvalidArgumentException::class,
+            '/"types" must be a map of class name to settings/'
+        );
+        SchemaScaffolder::createFromConfig([
+            'types' => ['fail']
+        ]);
+    }
+
+    public function testSchemaScaffolderCreateFromConfigThrowsIfBadQueries()
+    {
+        $this->setExpectedExceptionRegExp(
+            InvalidArgumentException::class,
+            '/must be a map of operation name to settings/'
+        );
+        SchemaScaffolder::createFromConfig([
+            'types' => [
+                DataObjectFake::class => [
+                    'fields' => '*'
+                ]
+            ],
+            'queries' => ['fail']
+        ]);
+    }
+
+    public function testSchemaScaffolderCreateFromConfig()
+    {
+        $observer = $this->getMockBuilder(SchemaScaffolder::class)
+            ->setMethods(['query','mutation','type'])
+            ->getMock();
+
+        $observer->expects($this->once())
+            ->method('query')
+            ->will($this->returnValue(new QueryScaffolder('test', 'test')));
+
+        $observer->expects($this->once())
+            ->method('mutation')
+            ->will($this->returnValue(new MutationScaffolder('test', 'test')));
+
+        $observer->expects($this->once())
+            ->method('type')
+            ->willReturn(
+                new DataObjectScaffolder(DataObjectFake::class)
+            );
+
+        Injector::inst()->registerService($observer, SchemaScaffolder::class);
+
+        SchemaScaffolder::createFromConfig([
+            'types' => [
+                DataObjectFake::class => [
+                    'fields' => ['MyField']
+                ]
+            ],
+            'queries' => [
+                'testQuery' => [
+                    'type' => DataObjectFake::class,
+                    'resolver' => FakeResolver::class
+                ]
+            ],
+            'mutations' => [
+                'testMutation' => [
+                    'type' => DataObjectFake::class,
+                    'resolver' => FakeResolver::class
+                ]
+            ]
+        ]);
+    }
+
+    public function testOperationIdentifiers()
+    {
+        $this->assertEquals(
+            Read::class,
+            OperationScaffolder::getOperationScaffoldFromIdentifier(SchemaScaffolder::READ)
+        );
+        $this->assertEquals(
+            Update::class,
+            OperationScaffolder::getOperationScaffoldFromIdentifier(SchemaScaffolder::UPDATE)
+        );
+        $this->assertEquals(
+            Delete::class,
+            OperationScaffolder::getOperationScaffoldFromIdentifier(SchemaScaffolder::DELETE)
+        );
+        $this->assertEquals(
+            Create::class,
+            OperationScaffolder::getOperationScaffoldFromIdentifier(SchemaScaffolder::CREATE)
+        );
+
+    }
+
+    public function testOperationScaffolderArgs()
+    {
+        $scaffolder = new OperationScaffolderFake('testOperation', 'testType');
+        
+        $this->assertEquals('testOperation', $scaffolder->getName());
+        $scaffolder->addArgs([
+            'One' => 'String',
+            'Two' => 'Boolean'
+        ]);
+        $scaffolder->addArg(
+            'One',
+            'String',
+            'One description',
+            'One default'
+        );
+
+        $this->assertEquals([], array_diff(
+            $scaffolder->getArgs()->column('argName'),
+            ['One','Two']
+        ));
+
+        $argument = $scaffolder->getArgs()->find('argName', 'One');
+        $this->assertInstanceOf(ArgumentScaffolder::class, $argument);
+        $arr = $argument->toArray();
+        $this->assertEquals('One description', $arr['description']);
+        $this->assertEquals('One default', $arr['defaultValue']);
+
+        $scaffolder->setArgDescriptions([
+            'One' => 'Foo',
+            'Two' => 'Bar'
+        ]);
+
+        $scaffolder->setArgDefaults([
+            'One' => 'Feijoa',
+            'Two' => 'Kiwifruit'
+        ]);
+
+        $argument = $scaffolder->getArgs()->find('argName', 'One');
+        $arr = $argument->toArray();
+        $this->assertEquals('Foo', $arr['description']);
+        $this->assertEquals('Feijoa', $arr['defaultValue']);
+
+        $argument = $scaffolder->getArgs()->find('argName', 'Two');
+        $arr = $argument->toArray();
+        $this->assertEquals('Bar', $arr['description']);
+        $this->assertEquals('Kiwifruit', $arr['defaultValue']);
+
+        $scaffolder->setArgDescription('One', 'Tui')
+            ->setArgDefault('One', 'Moa');
+
+        $argument = $scaffolder->getArgs()->find('argName', 'One');
+        $arr = $argument->toArray();
+        $this->assertEquals('Tui', $arr['description']);
+        $this->assertEquals('Moa', $arr['defaultValue']);
+
+        $scaffolder->removeArg('One');
+        $this->assertEquals(['Two'], $scaffolder->getArgs()->column('argName'));
+        $scaffolder->addArg('Test', 'String');
+        $scaffolder->removeArgs(['Two','Test']);
+        $this->assertFalse($scaffolder->getArgs()->exists());
+
+        $ex = null;
+        try {
+            $scaffolder->setArgDescription('Nothing', 'Test');
+        } catch (Exception $e) {
+            $ex = $e;
+        }
+
+        $this->assertInstanceOf(InvalidArgumentException::class, $ex);
+        $this->assertRegExp('/Tried to set description/', $ex->getMessage());
+
+        $ex = null;
+        try {
+            $scaffolder->setArgDefault('Nothing', 'Test');
+        } catch (Exception $e) {
+            $ex = $e;
+        }
+
+        $this->assertInstanceOf(InvalidArgumentException::class, $ex);
+        $this->assertRegExp('/Tried to set default/', $ex->getMessage());
+    }
+
+    public function testOperationScaffolderResolver()
+    {
+        $scaffolder = new OperationScaffolderFake('testOperation', 'testType');
+
+        try {
+            $scaffolder->setResolver(function () {
+            });
+            $scaffolder->setResolver(FakeResolver::class);
+            $scaffolder->setResolver(new FakeResolver());
+            $success = true;
+        } catch (Exception $e) {
+            $success = false;
+        }
+
+        $this->assertTrue($success);
+
+        $this->setExpectedExceptionRegExp(
+            InvalidArgumentException::class,
+            '/closures, instances of/'
+        );
+        $scaffolder->setResolver('fail');
+    }
+
+    public function testOperationScaffolderAppliesConfig()
+    {
+        $scaffolder = new OperationScaffolderFake('testOperation', 'testType');
+        
+        
+        $scaffolder->applyConfig([
+            'args' => [
+                'One' => 'String',
+                'Two' => [
+                    'type' => 'String',
+                    'default' => 'Foo',
+                    'description' => 'Bar'
+                ]
+            ],
+            'resolver' => FakeResolver::class
+        ]);
+
+        $this->assertEquals([], array_diff(
+            $scaffolder->getArgs()->column('argName'),
+            ['One','Two']
+        ));
+
+        $arg = $scaffolder->getArgs()->find('argName', 'Two');
+        $this->assertInstanceof(ArgumentScaffolder::class, $arg);
+        $arr = $arg->toArray();
+        $this->assertInstanceOf(StringType::class, $arr['type']);
+
+        $ex = null;
+        try {
+            $scaffolder->applyConfig([
+                'args' => 'fail'
+            ]);
+        } catch (Exception $e) {
+            $ex = $e;
+        }
+
+        $this->assertInstanceof(Exception::class, $e);
+        $this->assertRegExp('/args must be an array/', $e->getMessage());
+
+        $ex = null;
+        try {
+            $scaffolder->applyConfig([
+                'args' => [
+                    'One' => [
+                        'default' => 'Foo',
+                        'description' => 'Bar'
+                    ]
+                ]
+            ]);
+        } catch (Exception $e) {
+            $ex = $e;
+        }
+
+        $this->assertInstanceof(Exception::class, $e);
+        $this->assertRegExp('/must have a type/', $e->getMessage());
+
+        $ex = null;
+        try {
+            $scaffolder->applyConfig([
+                'args' => [
+                    'One' => false
+                ]
+            ]);
+        } catch (Exception $e) {
+            $ex = $e;
+        }
+
+        $this->assertInstanceof(Exception::class, $e);
+        $this->assertRegExp('/should be mapped to a string or an array/', $e->getMessage());
+
+    }
+
+    public function testArgumentScaffolder()
+    {
+        $scaffolder = new ArgumentScaffolder('Test', 'String');
+        $scaffolder->setRequired(false)
+            ->setDescription('Description')
+            ->setDefaultValue('Default');
+
+        $this->assertEquals('Description', $scaffolder->getDescription());
+        $this->assertEquals('Default', $scaffolder->getDefaultValue());
+        $this->assertFalse($scaffolder->isRequired());
+
+        $scaffolder->applyConfig([
+            'description' => 'Foo',
+            'default' => 'Bar',
+            'required' => true
+        ]);
+
+        $this->assertEquals('Foo', $scaffolder->getDescription());
+        $this->assertEquals('Bar', $scaffolder->getDefaultValue());
+        $this->assertTrue($scaffolder->isRequired());
+
+        $arr = $scaffolder->toArray();
+
+        $this->assertEquals('Foo', $arr['description']);
+        $this->assertEquals('Bar', $arr['defaultValue']);
+        $this->assertInstanceOf(NonNull::class, $arr['type']);
+        $this->assertInstanceOf(StringType::class, $arr['type']->getWrappedType());
+    }
+
+    public function testMutationScaffolder()
+    {
+        $observer = $this->getMockBuilder(Manager::class)
+            ->setMethods(['addMutation'])
+            ->getMock();
+        $scaffolder = new MutationScaffolder('testMutation', 'test');
+        $scaffolder->addArgs(['Test' => 'String']);
+        $scaffold = $scaffolder->scaffold($manager = new Manager());
+        $manager->addType($o = new ObjectType([
+            'name' => 'test',
+            'fields' => []
+        ]));
+        $o->Test = true;
+
+        $this->assertEquals('testMutation', $scaffold['name']);
+        $this->assertArrayHasKey('Test', $scaffold['args']);
+        $this->assertTrue(is_callable($scaffold['resolve']));
+        $this->assertTrue($scaffold['type']()->Test);
+
+        $observer->expects($this->once())
+            ->method('addMutation')
+            ->with(
+                $this->equalTo($scaffold),
+                $this->equalTo('testMutation')
+            );
+
+        $scaffolder->addToManager($observer);
+    }
+
+    public function testQueryScaffolderUnpaginated()
+    {
+        $observer = $this->getMockBuilder(Manager::class)
+            ->setMethods(['addQuery'])
+            ->getMock();
+        $scaffolder = new QueryScaffolder('testQuery', 'test');
+        $scaffolder->setUsePagination(false);
+        $scaffolder->addArgs(['Test' => 'String']);
+        $scaffold = $scaffolder->scaffold($manager = new Manager());
+        
+        $manager->addType($o = new ObjectType([
+            'name' => 'test',
+            'fields' => []
+        ]));
+        $o->Test = true;
+
+        $this->assertEquals('testQuery', $scaffold['name']);
+        $this->assertArrayHasKey('Test', $scaffold['args']);
+        $this->assertTrue(is_callable($scaffold['resolve']));
+        $this->assertTrue($scaffold['type']()->Test);
+
+        $observer->expects($this->once())
+            ->method('addQuery')
+            ->with(
+                $this->equalTo($scaffold),
+                $this->equalTo('testQuery')
+            );
+
+        $scaffolder->addToManager($observer);
+    }
+
+    public function testQueryScaffolderPaginated()
+    {
+        $scaffolder = new QueryScaffolder('testQuery', 'test');
+        $scaffolder->setUsePagination(true);
+        $scaffolder->addArgs(['Test' => 'String']);
+        $scaffolder->addSortableFields(['test']);
+        $scaffold = $scaffolder->scaffold($manager = new Manager());
+        $manager->addType($o = new ObjectType([
+            'name' => 'test',
+            'fields' => []
+        ]));
+        $o->Test = true;
+        $config = $scaffold['type']()->config;
+
+        $this->assertEquals('testQueryConnection', $config['name']);
+        $this->assertArrayHasKey('pageInfo', $config['fields']);
+        $this->assertArrayHasKey('edges', $config['fields']);
+    }
+
+    public function testQueryScaffolderApplyConfig()
+    {
+        $mock = $this->getMockBuilder(QueryScaffolder::class)
+            ->setConstructorArgs(['testQuery', 'testType'])
+            ->setMethods(['addSortableFields','setUsePagination'])
+            ->getMock();
+        $mock->expects($this->once())
+            ->method('addSortableFields')
+            ->with(['Test1','Test2']);
+        $mock->expects($this->once())
+            ->method('setUsePagination')
+            ->with(false);
+
+        $mock->applyConfig([
+            'sortableFields' => ['Test1','Test2'],
+            'paginate' => false
+        ]);
+    }
+
+    public function testQueryScaffolderApplyConfigThrowsOnBadSortableFields()
+    {
+        $scaffolder = new QueryScaffolder('testQuery', 'testType');
+        $this->setExpectedExceptionRegExp(
+            InvalidArgumentException::class,
+            '/sortableFields must be an array/'
+        );
+        $scaffolder->applyConfig([
+            'sortableFields' => 'fail'
+        ]);
+    }
+
+    public function testCreateOperationResolver()
+    {
+        $create = new Create(DataObjectFake::class);
+        $scaffold = $create->scaffold(new Manager());
+
+        $newRecord = $scaffold['resolve'](
+            null,
+            [
+                'Input' => ['MyField' => '__testing__']
+            ],
+            [
+                'currentMember' => Member::create()
+            ],
+            new ResolveInfo([])
+        );
+
+        $this->assertGreaterThan(0, $newRecord->ID);
+        $this->assertEquals('__testing__', $newRecord->MyField);
+    }
+
+    public function testCreateOperationInputType()
+    {
+        $create = new Create(DataObjectFake::class);
+        $scaffold = $create->scaffold(new Manager());
+
+        $this->assertArrayHasKey('Input', $scaffold['args']);
+        $this->assertInstanceof(NonNull::class, $scaffold['args']['Input']['type']);
+        
+        $config = $scaffold['args']['Input']['type']->getWrappedType()->config;
+
+        $this->assertEquals('Data_Object_FakeCreateInputType', $config['name']);
+        $fieldMap = [];
+        foreach ($config['fields'] as $name => $fieldData) {
+            $fieldMap[$name] = $fieldData['type'];
+        }
+        $this->assertArrayHasKey('MyField', $fieldMap);
+        $this->assertArrayHasKey('MyInt', $fieldMap);
+        $this->assertArrayNotHasKey('ID', $fieldMap);
+        $this->assertInstanceOf(StringType::class, $fieldMap['MyField']);
+        $this->assertInstanceOf(IntType::class, $fieldMap['MyInt']);
+    }
+
+    public function testCreateOperationPermissionCheck()
+    {
+        $create = new Create(RestrictedDataObjectFake::class);
+        $scaffold = $create->scaffold(new Manager());
+
+        $this->setExpectedExceptionRegExp(
+            Exception::class,
+            '/Cannot create/'
+        );
+
+        $scaffold['resolve'](
+            null,
+            [],
+            ['currentMember' => Member::create()],
+            new ResolveInfo([])
+        );
+    }
+
+    public function testUpdateOperationResolver()
+    {
+        $update = new Update(DataObjectFake::class);
+        $scaffold = $update->scaffold(new Manager());
+
+        $record = DataObjectFake::create([
+            'MyField' => 'old'
+        ]);
+        $ID = $record->write();
+
+        $scaffold['resolve'](
+            $record,
+            [
+                'ID' => $ID,
+                'Input' => ['MyField' => 'new']
+            ],
+            [
+                'currentMember' => Member::create()
+            ],
+            new ResolveInfo([])
+        );
+        $updatedRecord = DataObjectFake::get()->byID($ID);
+        $this->assertEquals('new', $updatedRecord->MyField);
+    }
+
+    public function testUpdateOperationInputType()
+    {
+        $update = new Update(DataObjectFake::class);
+        $scaffold = $update->scaffold(new Manager());
+
+        $this->assertArrayHasKey('Input', $scaffold['args']);
+        $this->assertInstanceof(NonNull::class, $scaffold['args']['Input']['type']);
+        
+        $config = $scaffold['args']['Input']['type']->getWrappedType()->config;
+
+        $this->assertEquals('Data_Object_FakeUpdateInputType', $config['name']);
+        $fieldMap = [];
+        foreach ($config['fields'] as $name => $fieldData) {
+            $fieldMap[$name] = $fieldData['type'];
+        }
+        $this->assertArrayHasKey('MyField', $fieldMap);
+        $this->assertArrayHasKey('MyInt', $fieldMap);
+        $this->assertArrayNotHasKey('ID', $fieldMap);
+        $this->assertInstanceOf(StringType::class, $fieldMap['MyField']);
+        $this->assertInstanceOf(IntType::class, $fieldMap['MyInt']);
+    }
+
+    public function testUpdateOperationPermissionCheck()
+    {
+        $update = new Update(RestrictedDataObjectFake::class);
+        $restrictedDataobject = RestrictedDataObjectFake::create();
+        $ID = $restrictedDataobject->write();
+
+        $scaffold = $update->scaffold(new Manager());
+
+        $this->setExpectedExceptionRegExp(
+            Exception::class,
+            '/Cannot edit/'
+        );
+
+        $scaffold['resolve'](
+            $restrictedDataobject,
+            ['ID' => $ID],
+            ['currentMember' => Member::create()],
+            new ResolveInfo([])
+        );
+    }
+
+
+    public function testDeleteOperationResolver()
+    {
+        $delete = new Delete(DataObjectFake::class);
+        $scaffold = $delete->scaffold(new Manager());
+
+        $record = DataObjectFake::create();
+        $ID1 = $record->write();
+
+        $record = DataObjectFake::create();
+        $ID2 = $record->write();
+
+        $record = DataObjectFake::create();
+        $ID3 = $record->write();
+
+        $scaffold['resolve'](
+            $record,
+            [
+                'IDs' => [$ID1, $ID2]
+            ],
+            [
+                'currentMember' => Member::create()
+            ],
+            new ResolveInfo([])
+        );
+        
+        $this->assertNull(DataObjectFake::get()->byID($ID1));
+        $this->assertNull(DataObjectFake::get()->byID($ID2));
+        $this->assertInstanceOf(DataObjectFake::class, DataObjectFake::get()->byID($ID3));
+    }
+
+    public function testDeleteOperationArgs()
+    {
+        $delete = new Delete(DataObjectFake::class);
+        $scaffold = $delete->scaffold(new Manager());
+
+        $this->assertArrayHasKey('IDs', $scaffold['args']);
+        $this->assertInstanceof(NonNull::class, $scaffold['args']['IDs']['type']);
+        
+        $listOf = $scaffold['args']['IDs']['type']->getWrappedType();
+
+        $this->assertInstanceOf(ListOfType::class, $listOf);
+
+        $idType = $listOf->getWrappedType();
+
+        $this->assertInstanceof(IDType::class, $idType);
+    }
+
+    public function testDeleteOperationPermissionCheck()
+    {
+        $delete = new Delete(RestrictedDataObjectFake::class);
+        $restrictedDataobject = RestrictedDataObjectFake::create();
+        $ID = $restrictedDataobject->write();
+
+        $scaffold = $delete->scaffold(new Manager());
+
+        $this->setExpectedExceptionRegExp(
+            Exception::class,
+            '/Cannot delete/'
+        );
+
+        $scaffold['resolve'](
+            $restrictedDataobject,
+            ['IDs' => [$ID]],
+            ['currentMember' => Member::create()],
+            new ResolveInfo([])
+        );
+    }
+
+    public function testReadOperationResolver()
+    {
+        $read = new Read(DataObjectFake::class);
+        $scaffold = $read->scaffold(new Manager());
+
+        DataObjectFake::get()->removeAll();
+        
+        $record = DataObjectFake::create();
+        $ID1 = $record->write();
+
+        $record = DataObjectFake::create();
+        $ID2 = $record->write();
+
+        $record = DataObjectFake::create();
+        $ID3 = $record->write();
+
+        $response = $scaffold['resolve'](
+            null,
+            [],
+            [
+                'currentMember' => Member::create()
+            ],
+            new ResolveInfo([])
+        );
+
+        $this->assertArrayHasKey('edges', $response);
+        $this->assertEquals([$ID1, $ID2, $ID3], $response['edges']->column('ID'));
+    }
 
 
     public function testTypeParser()
@@ -1210,7 +1214,7 @@ public function testTypeParser()
         $this->assertTrue($parser->isRequired());
         $this->assertEquals('Int', $parser->getArgTypeName());
         $this->assertEquals('23', $parser->getDefaultValue());
-		$this->assertTrue(is_int($parser->getDefaultValue()));
+        $this->assertTrue(is_int($parser->getDefaultValue()));
 
         $parser = new TypeParser('Boolean');
         $this->assertFalse($parser->isRequired());
@@ -1221,22 +1225,22 @@ public function testTypeParser()
         $this->assertFalse($parser->isRequired());
         $this->assertEquals('Boolean', $parser->getArgTypeName());
         $this->assertEquals('1', $parser->getDefaultValue());
-		$this->assertTrue(is_bool($parser->getDefaultValue()));
+        $this->assertTrue(is_bool($parser->getDefaultValue()));
 
-        $parser = new TypeParser('String!(Test)');        
+        $parser = new TypeParser('String!(Test)');
         $this->assertInstanceOf(StringType::class, $parser->getType());
         $this->assertEquals('Test', $parser->getDefaultValue());
 
         $this->setExpectedExceptionRegExp(
-        	InvalidArgumentException::class,
-        	'/Invalid argument/'
+            InvalidArgumentException::class,
+            '/Invalid argument/'
         );
         
         $parser = new TypeParser('  ... Nothing');
 
         $this->setExpectedExceptionRegExp(
-        	InvalidArgumentException::class,
-        	'/Invalid type/'
+            InvalidArgumentException::class,
+            '/Invalid type/'
         );
 
         $parser = (new TypeParser('Nothing'))->toArray();
@@ -1262,16 +1266,14 @@ public function testOperationList()
         $this->assertEquals(1, $list->count());
 
         $this->setExpectedExceptionRegExp(
-        	InvalidArgumentException::class,
-        	'/only accepts instances of/'
+            InvalidArgumentException::class,
+            '/only accepts instances of/'
         );
         $list->push(new OperationList());
     }
 
-	protected function getFakeScaffolder()
-	{
-		return new DataObjectScaffolder(DataObjectFake::class);
-	}
-
-
+    protected function getFakeScaffolder()
+    {
+        return new DataObjectScaffolder(DataObjectFake::class);
+    }
 }
diff --git a/tests/TypeCreatorTest.php b/tests/TypeCreatorTest.php
index 33387a759..f044c27b3 100644
--- a/tests/TypeCreatorTest.php
+++ b/tests/TypeCreatorTest.php
@@ -59,7 +59,9 @@ public function testGetFieldsUsesResolveConfig()
         $mock->method('fields')->willReturn([
             'fieldA' => [
                 'type' => Type::string(),
-                'resolve' => function() {return 'config';},
+                'resolve' => function () {
+                    return 'config';
+                },
             ],
             'fieldB' => [
                 'type' => Type::string(),
@@ -126,7 +128,7 @@ protected function getTypeCreatorMock($extraMethods = [])
             ->setMethods(array_unique(array_merge(['fields', 'attributes'], $extraMethods)))
             ->getMock();
 
-        if(!in_array('fields', $extraMethods)) {
+        if (!in_array('fields', $extraMethods)) {
             $mock->method('fields')->willReturn([
                 'ID' => [
                     'type' => Type::nonNull(Type::id()),
@@ -134,7 +136,7 @@ protected function getTypeCreatorMock($extraMethods = [])
             ]);
         }
 
-        if(!in_array('attributes', $extraMethods)) {
+        if (!in_array('attributes', $extraMethods)) {
             $mock->method('attributes')
                 ->willReturn(['name' => 'myType']);
         }

From d018593a194fcc13d3e6238f68429f671327886a Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 31 Jan 2017 21:07:10 +1300
Subject: [PATCH 51/66] Clean up rebasing issues

---
 src/Manager.php                  | 97 ++++++++++++++++++--------------
 src/Pagination/SortInputType.php | 86 ----------------------------
 2 files changed, 56 insertions(+), 127 deletions(-)
 delete mode 100644 src/Pagination/SortInputType.php

diff --git a/src/Manager.php b/src/Manager.php
index 167bf4eb8..b419829b8 100644
--- a/src/Manager.php
+++ b/src/Manager.php
@@ -3,6 +3,8 @@
 namespace SilverStripe\GraphQL;
 
 use Doctrine\Instantiator\Exception\InvalidArgumentException;
+use GraphQL\Executor\ExecutionResult;
+use GraphQL\Language\SourceLocation;
 use GraphQL\Schema;
 use GraphQL\GraphQL;
 use SilverStripe\Core\Injector\Injector;
@@ -10,10 +12,16 @@
 use GraphQL\Type\Definition\ObjectType;
 use GraphQL\Error;
 use GraphQL\Type\Definition\Type;
+use SilverStripe\ORM\ValidationException;
 use SilverStripe\Security\Member;
 use SilverStripe\GraphQL\Scaffolding\Interfaces\ScaffoldingProvider;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
-
+/**
+ * Manager is the master container for a graphql endpoint, and contains
+ * all queries, mutations, and types.
+ *
+ * Instantiate with {@see Manager::createFromConfig()} with a config array.
+ */
 class Manager
 {
     use Injectable;
@@ -45,20 +53,18 @@ class Manager
 
     /**
      * @param array $config An array with optional 'types' and 'queries' keys
-     *
      * @return Manager
      */
     public static function createFromConfig($config)
     {
         /** @var Manager $manager */
-        $manager = Injector::inst()->create(self::class);
+        $manager = Injector::inst()->create(Manager::class);
 
         if (isset($config['scaffolding'])) {
             $scaffolder = SchemaScaffolder::createFromConfig($config['scaffolding']);
         } else {
             $scaffolder = new SchemaScaffolder();
         }
-
         if (isset($config['scaffolding_providers'])) {
             foreach ($config['scaffolding_providers'] as $provider) {
                 if (!class_exists($provider)) {
@@ -69,7 +75,6 @@ public static function createFromConfig($config)
                 }
                 
                 $provider = Injector::inst()->create($provider);
-
                 if (!$provider instanceof ScaffoldingProvider) {
                     throw new InvalidArgumentException(sprintf(
                         'All scaffolding providers must implement the %s interface',
@@ -79,7 +84,6 @@ public static function createFromConfig($config)
                 $scaffolder = $provider->provideGraphQLScaffolding($scaffolder);
             }
         }
-
         $scaffolder->addToManager($manager);
 
         // Types (incl. Interfaces and InputTypes)
@@ -88,7 +92,7 @@ public static function createFromConfig($config)
                 $typeCreator = Injector::inst()->create($typeCreatorClass, $manager);
                 if (!($typeCreator instanceof TypeCreator)) {
                     throw new InvalidArgumentException(sprintf(
-                        'The type named "%s" needs to be a class extending '.TypeCreator::class,
+                        'The type named "%s" needs to be a class extending ' . TypeCreator::class,
                         $name
                     ));
                 }
@@ -104,7 +108,7 @@ public static function createFromConfig($config)
                 $queryCreator = Injector::inst()->create($queryCreatorClass, $manager);
                 if (!($queryCreator instanceof QueryCreator)) {
                     throw new InvalidArgumentException(sprintf(
-                        'The type named "%s" needs to be a class extending '.QueryCreator::class,
+                        'The type named "%s" needs to be a class extending ' . QueryCreator::class,
                         $name
                     ));
                 }
@@ -120,7 +124,7 @@ public static function createFromConfig($config)
                 $mutationCreator = Injector::inst()->create($mutationCreatorClass, $manager);
                 if (!($mutationCreator instanceof MutationCreator)) {
                     throw new InvalidArgumentException(sprintf(
-                        'The mutation named "%s" needs to be a class extending '.MutationCreator::class,
+                        'The mutation named "%s" needs to be a class extending ' . MutationCreator::class,
                         $name
                     ));
                 }
@@ -134,6 +138,8 @@ public static function createFromConfig($config)
     }
 
     /**
+     * Build the main Schema instance that represents the final schema for this endpoint
+     *
      * @return Schema
      */
     public function schema()
@@ -157,15 +163,15 @@ public function schema()
     }
 
     /**
-     * @param string $query
-     * @param array  $params
-     * @param null   $schema
+     * Execute an arbitrary operation (mutation / query) on this schema
      *
+     * @param string $query Raw query
+     * @param array $params List of arguments given for this operation
      * @return array
      */
-    public function query($query, $params = [], $schema = null)
+    public function query($query, $params = [])
     {
-        $executionResult = $this->queryAndReturnResult($query, $params, $schema);
+        $executionResult = $this->queryAndReturnResult($query, $params);
 
         if (!empty($executionResult->errors)) {
             return [
@@ -181,14 +187,12 @@ public function query($query, $params = [], $schema = null)
 
     /**
      * @param string $query
-     * @param array  $params
-     * @param null   $schema
-     *
-     * @return array
+     * @param array $params
+     * @return ExecutionResult
      */
-    public function queryAndReturnResult($query, $params = [], $schema = null)
+    public function queryAndReturnResult($query, $params = [])
     {
-        $schema = $this->schema($schema);
+        $schema = $this->schema();
         $context = $this->getContext();
         $result = GraphQL::executeAndReturnResult($schema, $query, null, $context, $params);
 
@@ -196,21 +200,25 @@ public function queryAndReturnResult($query, $params = [], $schema = null)
     }
 
     /**
-     * @param Type   $type
-     * @param string $name An optional identifier for this type (defaults to 'name' attribute in type definition).
-     *                     Needs to be unique in schema
+     * Register a new type
+     *
+     * @param Type $type
+     * @param string $name An optional identifier for this type (defaults to 'name'
+     * attribute in type definition). Needs to be unique in schema.
      */
     public function addType(Type $type, $name = '')
     {
         if (!$name) {
-            $name = (string) $type;
+            $name = (string)$type;
         }
+
         $this->types[$name] = $type;
     }
 
     /**
-     * @param string $name
+     * Return a type definition by name
      *
+     * @param string $name
      * @return Type
      */
     public function getType($name)
@@ -233,8 +241,10 @@ public function hasType($name)
     }
 
     /**
-     * @param array  $query
-     * @param string $name  Identifier for this query (unique in schema)
+     * Register a new Query
+     *
+     * @param array $query
+     * @param string $name Identifier for this query (unique in schema)
      */
     public function addQuery($query, $name)
     {
@@ -242,8 +252,9 @@ public function addQuery($query, $name)
     }
 
     /**
-     * @param string $name
+     * Get a query by name
      *
+     * @param string $name
      * @return array
      */
     public function getQuery($name)
@@ -252,8 +263,10 @@ public function getQuery($name)
     }
 
     /**
-     * @param array  $mutation
-     * @param string $name     Identifier for this mutation (unique in schema)
+     * Register a new mutation
+     *
+     * @param array $mutation
+     * @param string $name Identifier for this mutation (unique in schema)
      */
     public function addMutation($mutation, $name)
     {
@@ -261,8 +274,9 @@ public function addMutation($mutation, $name)
     }
 
     /**
-     * @param string $name
+     * Get a mutation by name
      *
+     * @param string $name
      * @return array
      */
     public function getMutation($name)
@@ -273,26 +287,25 @@ public function getMutation($name)
     /**
      * More verbose error display defaults.
      *
-     * @param Error $e
-     *
+     * @param Error $exception
      * @return array
      */
-    public static function formatError(Error $e)
+    public static function formatError(Error $exception)
     {
         $error = [
-            'message' => $e->getMessage(),
+            'message' => $exception->getMessage(),
         ];
 
-        $locations = $e->getLocations();
+        $locations = $exception->getLocations();
         if (!empty($locations)) {
-            $error['locations'] = array_map(function ($loc) {
+            $error['locations'] = array_map(function (SourceLocation $loc) {
                 return $loc->toArray();
             }, $locations);
         }
 
-        $previous = $e->getPrevious();
-        if ($previous && $previous instanceof ValidationError) {
-            $error['validation'] = $previous->getValidatorMessages();
+        $previous = $exception->getPrevious();
+        if ($previous && $previous instanceof ValidationException) {
+            $error['validation'] = $previous->getResult()->getMessages();
         }
 
         return $error;
@@ -321,6 +334,8 @@ public function getMember()
     }
 
     /**
+     * Get global context to pass to $context for all queries
+     *
      * @return array
      */
     protected function getContext()
@@ -329,4 +344,4 @@ protected function getContext()
             'currentUser' => $this->getMember()
         ];
     }
-}
+}
\ No newline at end of file
diff --git a/src/Pagination/SortInputType.php b/src/Pagination/SortInputType.php
deleted file mode 100644
index c30c9d594..000000000
--- a/src/Pagination/SortInputType.php
+++ /dev/null
@@ -1,86 +0,0 @@
-<?php
-
-namespace SilverStripe\GraphQL\Pagination;
-
-use GraphQL\Type\Definition\Type;
-use GraphQL\Type\Definition\InputObjectType;
-use SilverStripe\Core\Injector\Injector;
-use SilverStripe\Core\Injector\Injectable;
-use GraphQL\Type\Definition\EnumType;
-
-class SortInputType
-{
-    use Injectable;
-
-    /**
-     * @var InputObjectType
-     */
-    private $type;
-
-    /**
-     * @var string
-     */
-    private $inputName;
-
-    /**
-     * @var array Keyed by field argument name, values as DataObject column names.
-     *            Does not support in-memory sorting for composite values (getters)
-     */
-    protected $sortableFields = [];
-
-    public function __construct($name)
-    {
-        $this->inputName = $name;
-    }
-
-    /**
-     * @param array $sortableFields
-     *
-     * @return $this
-     */
-    public function setSortableFields($sortableFields)
-    {
-        $this->sortableFields = $sortableFields;
-
-        return $this;
-    }
-
-    /**
-     * @return Type
-     */
-    public function toType()
-    {
-        $values = [];
-
-        foreach ($this->sortableFields as $fieldAlias => $fieldName) {
-            $values[$fieldAlias] = [
-                'value' => $fieldAlias,
-            ];
-        }
-
-        $sortableField = new EnumType([
-            'name' => ucfirst($this->inputName).'SortFieldType',
-            'description' => 'Field name to sort by.',
-            'values' => $values,
-        ]);
-
-        if (!$this->type) {
-            $this->type = new InputObjectType([
-                'name' => ucfirst($this->inputName).'SortInputType',
-                'description' => 'Define the sorting',
-                'fields' => [
-                    'field' => [
-                        'type' => Type::nonNull($sortableField),
-                        'description' => 'Sort field name.',
-                    ],
-                    'direction' => [
-                        'type' => Injector::inst()->get(SortDirectionType::class)->toType(),
-                        'description' => 'Sort direction (ASC / DESC)',
-                    ],
-                ],
-            ]);
-        }
-
-        return $this->type;
-    }
-}

From 1066eb7bdab3158b6e5e04ba2f51a28f8da3c877 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 31 Jan 2017 21:19:12 +1300
Subject: [PATCH 52/66] docblock revisions

---
 src/Pagination/PaginatedQueryCreator.php     | 1 +
 src/Scaffolding/Interfaces/CRUDInterface.php | 6 ++++++
 2 files changed, 7 insertions(+)

diff --git a/src/Pagination/PaginatedQueryCreator.php b/src/Pagination/PaginatedQueryCreator.php
index 41547b868..2ccbca4e8 100644
--- a/src/Pagination/PaginatedQueryCreator.php
+++ b/src/Pagination/PaginatedQueryCreator.php
@@ -21,6 +21,7 @@ abstract class PaginatedQueryCreator extends QueryCreator implements OperationRe
 
     /**
      * @param Manager $manager
+     * @param  Connection $connection
      */
     public function __construct(Manager $manager, Connection $connection = null)
     {
diff --git a/src/Scaffolding/Interfaces/CRUDInterface.php b/src/Scaffolding/Interfaces/CRUDInterface.php
index b95d39a28..b5d96d45f 100644
--- a/src/Scaffolding/Interfaces/CRUDInterface.php
+++ b/src/Scaffolding/Interfaces/CRUDInterface.php
@@ -2,7 +2,13 @@
 
 namespace SilverStripe\GraphQL\Scaffolding\Interfaces;
 
+/**
+ * Defines the methods required for a class to provide a CRUD scaffold
+ */
 interface CRUDInterface
 {
+    /**
+     * @return string
+     */
     public function getIdentifier();
 }

From 7672e24d70c5b483965e4d1b74a3fc08066b5aa1 Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 31 Jan 2017 21:19:28 +1300
Subject: [PATCH 53/66] Rename Configurable to ConfigurationApplier

---
 src/Scaffolding/Interfaces/Configurable.php        |  8 --------
 .../Interfaces/ConfigurationApplier.php            | 14 ++++++++++++++
 src/Scaffolding/Scaffolders/ArgumentScaffolder.php |  4 ++--
 .../Scaffolders/DataObjectScaffolder.php           |  4 ++--
 .../Scaffolders/OperationScaffolder.php            |  4 ++--
 5 files changed, 20 insertions(+), 14 deletions(-)
 delete mode 100644 src/Scaffolding/Interfaces/Configurable.php
 create mode 100644 src/Scaffolding/Interfaces/ConfigurationApplier.php

diff --git a/src/Scaffolding/Interfaces/Configurable.php b/src/Scaffolding/Interfaces/Configurable.php
deleted file mode 100644
index fe979d9a1..000000000
--- a/src/Scaffolding/Interfaces/Configurable.php
+++ /dev/null
@@ -1,8 +0,0 @@
-<?php
-
-namespace SilverStripe\GraphQL\Scaffolding\Interfaces;
-
-interface Configurable
-{
-    public function applyConfig(array $config);
-}
diff --git a/src/Scaffolding/Interfaces/ConfigurationApplier.php b/src/Scaffolding/Interfaces/ConfigurationApplier.php
new file mode 100644
index 000000000..29299e720
--- /dev/null
+++ b/src/Scaffolding/Interfaces/ConfigurationApplier.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace SilverStripe\GraphQL\Scaffolding\Interfaces;
+
+/**
+ * Defines the methods required for a class to accept a configuration as an array
+ */
+interface ConfigurationApplier
+{
+    /**
+     * @param  array  $config
+     */
+    public function applyConfig(array $config);
+}
diff --git a/src/Scaffolding/Scaffolders/ArgumentScaffolder.php b/src/Scaffolding/Scaffolders/ArgumentScaffolder.php
index f6472dfcb..158836d40 100644
--- a/src/Scaffolding/Scaffolders/ArgumentScaffolder.php
+++ b/src/Scaffolding/Scaffolders/ArgumentScaffolder.php
@@ -4,11 +4,11 @@
 
 use GraphQL\Type\Definition\Type;
 use Doctrine\Instantiator\Exception\InvalidArgumentException;
-use SilverStripe\GraphQL\Scaffolding\Interfaces\Configurable;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ConfigurationApplier;
 use SilverStripe\GraphQL\Scaffolding\Util\TypeParser;
 use Exception;
 
-class ArgumentScaffolder implements Configurable
+class ArgumentScaffolder implements ConfigurationApplier
 {
 
     /**
diff --git a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
index c6a86b0e3..d01d9126c 100644
--- a/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
+++ b/src/Scaffolding/Scaffolders/DataObjectScaffolder.php
@@ -21,12 +21,12 @@
 use SilverStripe\GraphQL\Scaffolding\Interfaces\ManagerMutatorInterface;
 use SilverStripe\GraphQL\Scaffolding\Interfaces\ScaffolderInterface;
 use SilverStripe\ORM\ArrayLib;
-use SilverStripe\GraphQL\Scaffolding\Interfaces\Configurable;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ConfigurationApplier;
 
 /**
  * Scaffolds a DataObjectTypeCreator.
  */
-class DataObjectScaffolder implements ManagerMutatorInterface, ScaffolderInterface, Configurable
+class DataObjectScaffolder implements ManagerMutatorInterface, ScaffolderInterface, ConfigurationApplier
 {
     use DataObjectTypeTrait;
     use Chainable;
diff --git a/src/Scaffolding/Scaffolders/OperationScaffolder.php b/src/Scaffolding/Scaffolders/OperationScaffolder.php
index ef5f9deb5..e1c131cea 100644
--- a/src/Scaffolding/Scaffolders/OperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/OperationScaffolder.php
@@ -11,7 +11,7 @@
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\CRUD\Create;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\CRUD\Update;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\CRUD\Delete;
-use SilverStripe\GraphQL\Scaffolding\Interfaces\Configurable;
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ConfigurationApplier;
 use SilverStripe\ORM\ArrayList;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\ArgumentScaffolder;
 use Exception;
@@ -20,7 +20,7 @@
  * Provides functionality common to both operation scaffolders. Cannot
  * be a subclass due to their distinct inheritance chains.
  */
-abstract class OperationScaffolder implements Configurable
+abstract class OperationScaffolder implements ConfigurationApplier
 {
     use Chainable;
 

From 1977943a35064f5694bcd08672d395899c0c95bf Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 31 Jan 2017 21:23:53 +1300
Subject: [PATCH 54/66] More docblock cleanup

---
 src/Scaffolding/Interfaces/ResolverInterface.php    | 4 ++--
 src/Scaffolding/Interfaces/ScaffoldingProvider.php  | 2 +-
 src/Scaffolding/Scaffolders/CRUD/Delete.php         | 2 +-
 src/Scaffolding/Scaffolders/CRUD/Update.php         | 2 +-
 src/Scaffolding/Scaffolders/OperationScaffolder.php | 5 +++--
 src/Scaffolding/Scaffolders/SchemaScaffolder.php    | 2 +-
 6 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/src/Scaffolding/Interfaces/ResolverInterface.php b/src/Scaffolding/Interfaces/ResolverInterface.php
index ac7ecdd65..9e4d87314 100644
--- a/src/Scaffolding/Interfaces/ResolverInterface.php
+++ b/src/Scaffolding/Interfaces/ResolverInterface.php
@@ -10,8 +10,8 @@ interface ResolverInterface
     /**
      * @param DataObjectInterface $object
      * @param array $args
-     * @param $context
-     * @param $info
+     * @param array $context
+     * @param ResolverInfo $info
      * @return mixed
      */
     public function resolve($object, $args, $context, $info);
diff --git a/src/Scaffolding/Interfaces/ScaffoldingProvider.php b/src/Scaffolding/Interfaces/ScaffoldingProvider.php
index 80d141b72..b10101e31 100644
--- a/src/Scaffolding/Interfaces/ScaffoldingProvider.php
+++ b/src/Scaffolding/Interfaces/ScaffoldingProvider.php
@@ -10,7 +10,7 @@
 interface ScaffoldingProvider
 {
     /**
-     * @return mixed
+     * @param SchemaScaffolder $scaffolder
      */
     public function provideGraphQLScaffolding(SchemaScaffolder $scaffolder);
 }
diff --git a/src/Scaffolding/Scaffolders/CRUD/Delete.php b/src/Scaffolding/Scaffolders/CRUD/Delete.php
index 4eb09cfdd..47c4d4beb 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Delete.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Delete.php
@@ -50,7 +50,7 @@ public function __construct($dataObjectClass)
     }
 
     /**
-     * @return string`
+     * @return string
      */
     public function getIdentifier()
     {
diff --git a/src/Scaffolding/Scaffolders/CRUD/Update.php b/src/Scaffolding/Scaffolders/CRUD/Update.php
index fa65193f2..6617e14eb 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Update.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Update.php
@@ -62,7 +62,7 @@ public function __construct($dataObjectClass)
     }
 
     /**
-     * @return string`
+     * @return string
      */
     public function getIdentifier()
     {
diff --git a/src/Scaffolding/Scaffolders/OperationScaffolder.php b/src/Scaffolding/Scaffolders/OperationScaffolder.php
index e1c131cea..ee69a9b14 100644
--- a/src/Scaffolding/Scaffolders/OperationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/OperationScaffolder.php
@@ -46,6 +46,7 @@ abstract class OperationScaffolder implements ConfigurationApplier
 
     /**
      * @param $name
+     * @return  string|null
      */
     public static function getOperationScaffoldFromIdentifier($name)
     {
@@ -66,8 +67,8 @@ public static function getOperationScaffoldFromIdentifier($name)
     /**
      * OperationScaffolder constructor.
      *
-     * @param null $operationName
-     * @param null $resolver      Resolver|\Closure
+     * @param string $operationName
+     * @param Resolver|\Closure $resolver
      */
     public function __construct($operationName, $typeName, $resolver = null)
     {
diff --git a/src/Scaffolding/Scaffolders/SchemaScaffolder.php b/src/Scaffolding/Scaffolders/SchemaScaffolder.php
index 102e0dce5..1e51ff108 100644
--- a/src/Scaffolding/Scaffolders/SchemaScaffolder.php
+++ b/src/Scaffolding/Scaffolders/SchemaScaffolder.php
@@ -136,7 +136,7 @@ public function type($class)
      * @param string $class
      * @param null   $resolver
      *
-     * @return bool|QueryScaffolder
+     * @return QueryScaffolder
      */
     public function query($name, $class, $resolver = null)
     {

From d6eb7335f71d4efe5864f89e4cf597831b01b64f Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 31 Jan 2017 21:29:57 +1300
Subject: [PATCH 55/66] Update example code to use DateTime

---
 examples/code/Post.php | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/code/Post.php b/examples/code/Post.php
index 52af36b9d..94792e543 100644
--- a/examples/code/Post.php
+++ b/examples/code/Post.php
@@ -14,7 +14,7 @@ class Post extends DataObject implements ScaffoldingProvider {
 	private static $db = [
 		'Title' => 'Varchar',
 		'Content' => 'HTMLText',
-		'Date' => 'SilverStripe\ORM\FieldType\DBDateTime'
+		'Date' => 'DateTime'
 	];
 
 	private static $has_one = [

From 8296a232754905ffe02b9ba75c125b9514b515fd Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 31 Jan 2017 22:28:43 +1300
Subject: [PATCH 56/66] Add new fake redirector page so tests pass without CMS

---
 tests/Fake/FakeRedirectorPage.php | 18 ++++++++++++++++++
 tests/ScaffoldingTest.php         |  2 +-
 2 files changed, 19 insertions(+), 1 deletion(-)
 create mode 100644 tests/Fake/FakeRedirectorPage.php

diff --git a/tests/Fake/FakeRedirectorPage.php b/tests/Fake/FakeRedirectorPage.php
new file mode 100644
index 000000000..ab26108d0
--- /dev/null
+++ b/tests/Fake/FakeRedirectorPage.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace SilverStripe\GraphQL\Tests\Fake;
+
+use Page;
+
+/**
+ * Because otherwise we have to include silverstripe-cms as a dependency just
+ * to get the test to work.
+ */
+class FakeRedirectorPage extends Page {
+
+	private static $db = [
+		"RedirectionType" => "Enum('Internal,External','Internal')",
+		"ExternalURL" => "Varchar(2083)"
+	];
+
+}
\ No newline at end of file
diff --git a/tests/ScaffoldingTest.php b/tests/ScaffoldingTest.php
index 74fa77934..be0163b71 100644
--- a/tests/ScaffoldingTest.php
+++ b/tests/ScaffoldingTest.php
@@ -8,6 +8,7 @@
 use SilverStripe\GraphQL\Tests\Fake\RestrictedDataObjectFake;
 use SilverStripe\GraphQL\Tests\Fake\OperationScaffolderFake;
 use SilverStripe\GraphQL\Tests\Fake\FakeResolver;
+use SilverStripe\GraphQL\Tests\Fake\FakeRedirectorPage as RedirectorPage;
 use Doctrine\Instantiator\Exception\InvalidArgumentException;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\OperationScaffolder;
@@ -31,7 +32,6 @@
 use GraphQL\Type\Definition\IDType;
 use GraphQL\Type\Definition\Type;
 use GraphQL\Type\Definition\ResolveInfo;
-use SilverStripe\CMS\Model\RedirectorPage;
 use SilverStripe\CMS\Model\SiteTree;
 use SilverStripe\Security\Member;
 use SilverStripe\Assets\File;

From 1456d5b4843922f3b36d00d0bb4a95f6d749133e Mon Sep 17 00:00:00 2001
From: Uncle Cheese <unclecheese@leftandmain.com>
Date: Tue, 31 Jan 2017 23:04:08 +1300
Subject: [PATCH 57/66] Build shim classes for Page, SiteTree

---
 tests/Fake/FakePage.php           |  8 +++++++
 tests/Fake/FakeRedirectorPage.php |  6 ++---
 tests/Fake/FakeSiteTree.php       | 13 +++++++++++
 tests/ScaffoldingTest.php         | 39 ++++++++++++++++---------------
 4 files changed, 43 insertions(+), 23 deletions(-)
 create mode 100644 tests/Fake/FakePage.php
 create mode 100644 tests/Fake/FakeSiteTree.php

diff --git a/tests/Fake/FakePage.php b/tests/Fake/FakePage.php
new file mode 100644
index 000000000..a635152d6
--- /dev/null
+++ b/tests/Fake/FakePage.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace SilverStripe\GraphQL\Tests\Fake;
+
+class FakePage extends FakeSiteTree
+{
+	
+}
\ No newline at end of file
diff --git a/tests/Fake/FakeRedirectorPage.php b/tests/Fake/FakeRedirectorPage.php
index ab26108d0..bd6edf5f7 100644
--- a/tests/Fake/FakeRedirectorPage.php
+++ b/tests/Fake/FakeRedirectorPage.php
@@ -2,17 +2,15 @@
 
 namespace SilverStripe\GraphQL\Tests\Fake;
 
-use Page;
-
 /**
  * Because otherwise we have to include silverstripe-cms as a dependency just
  * to get the test to work.
  */
-class FakeRedirectorPage extends Page {
+class FakeRedirectorPage extends FakePage {
 
 	private static $db = [
 		"RedirectionType" => "Enum('Internal,External','Internal')",
 		"ExternalURL" => "Varchar(2083)"
 	];
 
-}
\ No newline at end of file
+}
diff --git a/tests/Fake/FakeSiteTree.php b/tests/Fake/FakeSiteTree.php
new file mode 100644
index 000000000..b8026efe4
--- /dev/null
+++ b/tests/Fake/FakeSiteTree.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace SilverStripe\GraphQL\Tests\Fake;
+
+use SilverStripe\ORM\DataObject;
+
+class FakeSiteTree extends DataObject 
+{
+	private static $db = [
+		'Title' => 'Varchar',
+		'Content' => 'HTMLText'
+	];
+}
diff --git a/tests/ScaffoldingTest.php b/tests/ScaffoldingTest.php
index be0163b71..297192327 100644
--- a/tests/ScaffoldingTest.php
+++ b/tests/ScaffoldingTest.php
@@ -8,7 +8,9 @@
 use SilverStripe\GraphQL\Tests\Fake\RestrictedDataObjectFake;
 use SilverStripe\GraphQL\Tests\Fake\OperationScaffolderFake;
 use SilverStripe\GraphQL\Tests\Fake\FakeResolver;
-use SilverStripe\GraphQL\Tests\Fake\FakeRedirectorPage as RedirectorPage;
+use SilverStripe\GraphQL\Tests\Fake\FakeSiteTree;
+use SilverStripe\GraphQL\Tests\Fake\FakePage;
+use SilverStripe\GraphQL\Tests\Fake\FakeRedirectorPage;
 use Doctrine\Instantiator\Exception\InvalidArgumentException;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\OperationScaffolder;
@@ -32,13 +34,11 @@
 use GraphQL\Type\Definition\IDType;
 use GraphQL\Type\Definition\Type;
 use GraphQL\Type\Definition\ResolveInfo;
-use SilverStripe\CMS\Model\SiteTree;
 use SilverStripe\Security\Member;
 use SilverStripe\Assets\File;
 use SilverStripe\Core\Config\Config;
 use SilverStripe\Core\Injector\Injector;
 use Exception;
-use Page;
 
 class ScaffoldingTest extends SapphireTest
 {
@@ -208,11 +208,12 @@ public function testDataObjectScaffolderDependentClasses()
 
     public function testDataObjectScaffolderAncestralClasses()
     {
-        $scaffolder = new DataObjectScaffolder(RedirectorPage::class);
+        $scaffolder = new DataObjectScaffolder(FakeRedirectorPage::class);
         $classes = $scaffolder->getAncestralClasses();
 
         $this->assertEquals([
-            'Page','SilverStripe\CMS\Model\SiteTree'
+            FakePage::class,
+            FakeSiteTree::class
         ], $classes);
 
     }
@@ -471,13 +472,13 @@ public function testSchemaScaffolderTypes()
 
     public function testSchemaScaffolderAddToManager()
     {
-        Config::inst()->update('Page', 'db', [
+        Config::inst()->update(FakePage::class, 'db', [
             'TestPageField' => 'Varchar'
         ]);
 
         $manager = new Manager();
         $scaffolder = (new SchemaScaffolder())
-            ->type(RedirectorPage::class)
+            ->type(FakeRedirectorPage::class)
                 ->addFields(['Created','TestPageField', 'RedirectionType'])
                 ->operation(SchemaScaffolder::CREATE)
                     ->end()
@@ -504,27 +505,27 @@ public function testSchemaScaffolderAddToManager()
         }, $types);
 
         $this->assertEquals([
-            RedirectorPage::class,
+            FakeRedirectorPage::class,
             DataObjectFake::class,
-            Page::class,
-            SiteTree::class,
+            FakePage::class,
+            FakeSiteTree::class,
             Member::class,
             File::class
         ], $classNames);
 
         $this->assertEquals(
             ['Created', 'TestPageField', 'RedirectionType'],
-            $scaffolder->type(RedirectorPage::class)->getFields()->column('Name')
+            $scaffolder->type(FakeRedirectorPage::class)->getFields()->column('Name')
         );
 
         $this->assertEquals(
             ['Created', 'TestPageField'],
-            $scaffolder->type(Page::class)->getFields()->column('Name')
+            $scaffolder->type(FakePage::class)->getFields()->column('Name')
         );
 
         $this->assertEquals(
             ['Created'],
-            $scaffolder->type(SiteTree::class)->getFields()->column('Name')
+            $scaffolder->type(FakeSiteTree::class)->getFields()->column('Name')
         );
 
 
@@ -533,28 +534,28 @@ public function testSchemaScaffolderAddToManager()
 
         $this->assertInstanceof(
             Read::class,
-            $scaffolder->type(RedirectorPage::class)->getOperations()->findByIdentifier(SchemaScaffolder::READ)
+            $scaffolder->type(FakeRedirectorPage::class)->getOperations()->findByIdentifier(SchemaScaffolder::READ)
         );
         $this->assertInstanceof(
             Read::class,
-            $scaffolder->type(Page::class)->getOperations()->findByIdentifier(SchemaScaffolder::READ)
+            $scaffolder->type(FakePage::class)->getOperations()->findByIdentifier(SchemaScaffolder::READ)
         );
         $this->assertInstanceof(
             Read::class,
-            $scaffolder->type(SiteTree::class)->getOperations()->findByIdentifier(SchemaScaffolder::READ)
+            $scaffolder->type(FakeSiteTree::class)->getOperations()->findByIdentifier(SchemaScaffolder::READ)
         );
 
         $this->assertInstanceof(
             Create::class,
-            $scaffolder->type(RedirectorPage::class)->getOperations()->findByIdentifier(SchemaScaffolder::CREATE)
+            $scaffolder->type(FakeRedirectorPage::class)->getOperations()->findByIdentifier(SchemaScaffolder::CREATE)
         );
         $this->assertInstanceof(
             Create::class,
-            $scaffolder->type(Page::class)->getOperations()->findByIdentifier(SchemaScaffolder::CREATE)
+            $scaffolder->type(FakePage::class)->getOperations()->findByIdentifier(SchemaScaffolder::CREATE)
         );
         $this->assertInstanceof(
             Create::class,
-            $scaffolder->type(SiteTree::class)->getOperations()->findByIdentifier(SchemaScaffolder::CREATE)
+            $scaffolder->type(FakeSiteTree::class)->getOperations()->findByIdentifier(SchemaScaffolder::CREATE)
         );
     }
 

From 17dc73e1a484054867b7be2c596ce5de1ef689ca Mon Sep 17 00:00:00 2001
From: Ingo Schommer <ingo@silverstripe.com>
Date: Thu, 2 Feb 2017 12:28:15 +1300
Subject: [PATCH 58/66] API Separate connection() to get/create

Required to make scaffolding work cleanly.
See https://github.com/silverstripe/silverstripe-graphql/pull/20#discussion_r98581495
---
 README.md                                     |  2 +-
 .../code/PaginatedReadMembersQueryCreator.php |  2 +-
 src/Pagination/PaginatedQueryCreator.php      | 31 +++++++++----------
 .../Scaffolders/PaginationScaffolder.php      | 15 +++++++--
 tests/Fake/PaginatedQueryFake.php             |  2 +-
 5 files changed, 31 insertions(+), 21 deletions(-)

diff --git a/README.md b/README.md
index 3277c05ce..fa87ffc65 100644
--- a/README.md
+++ b/README.md
@@ -223,7 +223,7 @@ use SilverStripe\GraphQL\Pagination\PaginatedQueryCreator;
 
 class PaginatedReadMembersQueryCreator extends PaginatedQueryCreator
 {
-    public function connection()
+    public function createConnection()
     {
         return Connection::create('paginatedReadMembers')
             ->setConnectionType(function () {
diff --git a/examples/code/PaginatedReadMembersQueryCreator.php b/examples/code/PaginatedReadMembersQueryCreator.php
index 12a301847..c69099852 100644
--- a/examples/code/PaginatedReadMembersQueryCreator.php
+++ b/examples/code/PaginatedReadMembersQueryCreator.php
@@ -8,7 +8,7 @@
 
 class PaginatedReadMembersQueryCreator extends PaginatedQueryCreator
 {
-    public function connection()
+    public function createConnection()
     {
         return Connection::create('paginatedReadMembers')
             ->setConnectionType(function () {
diff --git a/src/Pagination/PaginatedQueryCreator.php b/src/Pagination/PaginatedQueryCreator.php
index 2ccbca4e8..052c74726 100644
--- a/src/Pagination/PaginatedQueryCreator.php
+++ b/src/Pagination/PaginatedQueryCreator.php
@@ -14,47 +14,46 @@
  */
 abstract class PaginatedQueryCreator extends QueryCreator implements OperationResolver
 {
-    /**
-     * @var Connection
-     */
-    protected $connection;
 
     /**
-     * @param Manager $manager
-     * @param  Connection $connection
+     * @var Connection Local instance created through `createConnection()`.
      */
-    public function __construct(Manager $manager, Connection $connection = null)
-    {
-        parent::__construct($manager);
-
-        $this->connection = $connection ?: $this->connection();
-    }
+    protected $connection;
 
     /**
      * Get connection for this query
      *
      * @return Connection
      */
-    abstract public function connection();
+    abstract public function createConnection();
+
+    public function getConnection()
+    {
+        if (!$this->connection) {
+            $this->connection = $this->createConnection();
+        }
+
+        return $this->connection;
+    }
 
     /**
      * @return array
      */
     public function args()
     {
-        return $this->connection->args();
+        return $this->getConnection()->args();
     }
 
     public function type()
     {
         return function () {
-            return $this->connection->toType();
+            return $this->getConnection()->toType();
         };
     }
 
     public function resolve($value, array $args, $context, ResolveInfo $info)
     {
-        return $this->connection->resolve(
+        return $this->getConnection()->resolve(
             $value,
             $args,
             $context,
diff --git a/src/Scaffolding/Scaffolders/PaginationScaffolder.php b/src/Scaffolding/Scaffolders/PaginationScaffolder.php
index bf08c65f6..c387b3134 100644
--- a/src/Scaffolding/Scaffolders/PaginationScaffolder.php
+++ b/src/Scaffolding/Scaffolders/PaginationScaffolder.php
@@ -9,13 +9,24 @@
 class PaginationScaffolder extends PaginatedQueryCreator
 {
 
+    /**
+     * @param Manager $manager
+     * @param  Connection $connection
+     */
     public function __construct(Manager $manager, Connection $connection)
     {
-        $this->manager = $manager;
+        parent::__construct($manager);
+
         $this->connection = $connection;
     }
 
-    public function connection()
+    /**
+     * Connection is passed in through the constructor argument,
+     * to allow the instance to be created by the external scaffolding logic.
+     *
+     * @return Connection
+     */
+    public function createConnection()
     {
         return $this->connection;
     }
diff --git a/tests/Fake/PaginatedQueryFake.php b/tests/Fake/PaginatedQueryFake.php
index 253c4546f..2c4065757 100644
--- a/tests/Fake/PaginatedQueryFake.php
+++ b/tests/Fake/PaginatedQueryFake.php
@@ -10,7 +10,7 @@
 
 class PaginatedQueryFake extends PaginatedQueryCreator
 {
-    public function connection()
+    public function createConnection()
     {
         return Connection::create('testPagination')
             ->setArgs([

From c08bda7ef192b9f14e34f5a2306282051756bf57 Mon Sep 17 00:00:00 2001
From: Ingo Schommer <ingo@silverstripe.com>
Date: Thu, 2 Feb 2017 21:52:29 +1300
Subject: [PATCH 59/66] Use DB transaction for multi delete

---
 src/Scaffolding/Scaffolders/CRUD/Delete.php | 27 ++++++++++++---------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/src/Scaffolding/Scaffolders/CRUD/Delete.php b/src/Scaffolding/Scaffolders/CRUD/Delete.php
index 47c4d4beb..88f2fdac0 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Delete.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Delete.php
@@ -9,6 +9,7 @@
 use SilverStripe\GraphQL\Scaffolding\Interfaces\CRUDInterface;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
 use Exception;
+use SilverStripe\ORM\DB;
 
 /**
  * A generic delete operation.
@@ -32,20 +33,22 @@ public function __construct($dataObjectClass)
         );
 
         $this->setResolver(function ($object, array $args, $context, $info) {
-            $results = DataList::create($this->dataObjectClass)
-                ->byIDs($args['IDs']);
+            DB::get_conn()->withTransaction(function () use ($args, $context) {
+                $results = DataList::create($this->dataObjectClass)
+                    ->byIDs($args['IDs']);
 
-            foreach ($results as $obj) {
-                if ($obj->canDelete($context['currentMember'])) {
-                    $obj->delete();
-                } else {
-                    throw new Exception(sprintf(
-                        'Cannot delete %s with ID %s',
-                        $this->dataObjectClass,
-                        $obj->ID
-                    ));
+                foreach ($results as $obj) {
+                    if ($obj->canDelete($context['currentMember'])) {
+                        $obj->delete();
+                    } else {
+                        throw new Exception(sprintf(
+                            'Cannot delete %s with ID %s',
+                            $this->dataObjectClass,
+                            $obj->ID
+                        ));
+                    }
                 }
-            }
+            });
         });
     }
 

From 06ff0b25481ed7ee7f9749e4b15b57ba15284f16 Mon Sep 17 00:00:00 2001
From: Ingo Schommer <ingo@silverstripe.com>
Date: Thu, 2 Feb 2017 21:53:11 +1300
Subject: [PATCH 60/66] Fix examples

---
 README.md                                     | 3 +++
 examples/_config/config.yml                   | 6 +++---
 examples/code/CreateMemberMutationCreator.php | 2 +-
 examples/code/Post.php                        | 5 ++---
 4 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index fa87ffc65..2edc4df11 100644
--- a/README.md
+++ b/README.md
@@ -608,6 +608,9 @@ SilverStripe\GraphQL:
 ```php
 namespace MyProject;
 
+use SilverStripe\GraphQL\Scaffolding\Interfaces\ScaffoldingProvider;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
+
 class Post extends DataObject implements ScaffoldingProvider {
 	//...
     public function provideGraphQLScaffolding(SchemaScaffolder $scaffolder)
diff --git a/examples/_config/config.yml b/examples/_config/config.yml
index 46e6c3c35..fbe38f998 100644
--- a/examples/_config/config.yml
+++ b/examples/_config/config.yml
@@ -10,10 +10,10 @@ SilverStripe\GraphQL:
       createMember: 'MyProject\GraphQL\CreateMemberMutationCreator'
   # Enforce HTTP basic authentication for GraphQL requests
   authenticators:
-    - class: SilverStripe\GraphQL\Auth\BasicAuthAuthenticator
-      priority: 10
+    class: SilverStripe\GraphQL\Auth\BasicAuthAuthenticator
+    priority: 10
     scaffolding_providers:
-     - My\Project\Post
+      - My\Project\Post
     scaffolding:
       types:
         My\Project\Post:
diff --git a/examples/code/CreateMemberMutationCreator.php b/examples/code/CreateMemberMutationCreator.php
index 89ade1540..e89ce88f7 100644
--- a/examples/code/CreateMemberMutationCreator.php
+++ b/examples/code/CreateMemberMutationCreator.php
@@ -1,5 +1,5 @@
 <?php
-namespace MyProject;
+namespace MyProject\GraphQL;
 
 use GraphQL\Type\Definition\ResolveInfo;
 use GraphQL\Type\Definition\Type;
diff --git a/examples/code/Post.php b/examples/code/Post.php
index 94792e543..2c11af87b 100644
--- a/examples/code/Post.php
+++ b/examples/code/Post.php
@@ -4,8 +4,7 @@
 
 use SilverStripe\ORM\DataObject;
 use SilverStripe\GraphQL\Scaffolding\Interfaces\ScaffoldingProvider;
-use SilverStripe\GraphQL\Scaffolding\Scaffolders\GraphQLScaffolder;
-use SilverStripe\Core\Injector\Injector;
+use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
 use SilverStripe\Security\Member;
 use SilverStripe\Assets\File;
 
@@ -29,7 +28,7 @@ class Post extends DataObject implements ScaffoldingProvider {
 		'Comments' => Comment::class
 	];
 
-	public function provideGraphQLScaffolding(GraphQLScaffolder $scaffolder)
+	public function provideGraphQLScaffolding(SchemaScaffolder $scaffolder)
 	{
         $scaffolder
         	->type(Post::class)

From 198127c3b60cb3b42141010b45e3bf4af4e5d956 Mon Sep 17 00:00:00 2001
From: Ingo Schommer <ingo@silverstripe.com>
Date: Thu, 2 Feb 2017 21:53:49 +1300
Subject: [PATCH 61/66] Fix example $db declaration

---
 examples/code/Post.php | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/code/Post.php b/examples/code/Post.php
index 2c11af87b..c3d0f2242 100644
--- a/examples/code/Post.php
+++ b/examples/code/Post.php
@@ -13,7 +13,7 @@ class Post extends DataObject implements ScaffoldingProvider {
 	private static $db = [
 		'Title' => 'Varchar',
 		'Content' => 'HTMLText',
-		'Date' => 'DateTime'
+		'Date' => 'Datetime'
 	];
 
 	private static $has_one = [

From 641213bb197d609abac05080be6b81ed98e261a8 Mon Sep 17 00:00:00 2001
From: Ingo Schommer <ingo@silverstripe.com>
Date: Thu, 2 Feb 2017 21:53:55 +1300
Subject: [PATCH 62/66] Fix example whitespace

---
 examples/code/Post.php | 209 ++++++++++++++++++++++-------------------
 1 file changed, 110 insertions(+), 99 deletions(-)

diff --git a/examples/code/Post.php b/examples/code/Post.php
index c3d0f2242..42084c200 100644
--- a/examples/code/Post.php
+++ b/examples/code/Post.php
@@ -8,7 +8,8 @@
 use SilverStripe\Security\Member;
 use SilverStripe\Assets\File;
 
-class Post extends DataObject implements ScaffoldingProvider {
+class Post extends DataObject implements ScaffoldingProvider
+{
 
 	private static $db = [
 		'Title' => 'Varchar',
@@ -30,101 +31,111 @@ class Post extends DataObject implements ScaffoldingProvider {
 
 	public function provideGraphQLScaffolding(SchemaScaffolder $scaffolder)
 	{
-        $scaffolder
-        	->type(Post::class)
-            	->addFields(['ID','Title','Content', 'Author', 'Date'])
-            	// basic many_many nested query, no options
-            	->nestedQuery('Files')
-	            	->end()
-	            // more complex nested query
-	            ->nestedQuery('Comments')
-	            	->addArgs([
-	            		'Today' => 'Boolean'
-	            	])
-	            	->addSortableFields(['Author'])
-	            	->setResolver(function($obj, $args, $context) {
-	            		$comments = $obj->Comments();
-	            		if(isset($args['Today']) && $args['Today']) {
-	            			$comments = $comments->where('DATE(Created) = DATE(NOW())');
-	            		}
-
-	            		return $comments;
-	            	})
-	            	->end()
-	            // basic crud operation, no options
-            	->operation(GraphQLScaffolder::CREATE)
-            		->end()
-
-            	// complex crud operation, with custom args
-            	->operation(GraphQLScaffolder::READ)
-            		->addArgs([
-            			'StartingWith' => 'String'
-            		])
-            		->setResolver(function($obj, $args) {
-            			$list = Post::get();
-            			if(isset($args['StartingWith'])) {
-            				$list = $list->filter('Title:StartsWith', $args['StartingWith']);
-            			}
-
-            			return $list;
-            		})         	
-            		->end()
-            	->end()
-
-            // these types were all created implicitly above. Add some fields to them.
-            ->type(Member::class)
-            	->addFields(['Name','FirstName', 'Surname', 'Email'])
-            	->end()
-            ->type(File::class)
-            	->addAllFieldsExcept(['Content'])
-            	->addFields(['File'])
-            	->end()
-            ->type(Comment::class)
-            	->addFields(['Comment','Author'])
-            	->end()
-
-            // Arbitrary mutation
-            ->mutation('updatePostTitle', Post::class)
-	            ->addArgs([
-	                'ID' => 'ID!',
-	                'NewTitle' => 'String!'
-	            ])
-	            ->setResolver(function($obj, $args) {
-	                $post = Post::get()->byID($args['ID']);
-	                if($post->canEdit()) {
-	                    $post->Title = $args['NewTitle'];
-	                    $post->write();
-	                }
-
-	                return $post;
-	            })
-	            ->end()
-
-	        // Arbitrary query
-	        ->query('latestPost', Post::class)
-	        	->setUsePagination(false)
-	        	->setResolver(function($obj, $args) {
-	        		return Post::get()->sort('Date', 'DESC')->first();
-	        	})
-	        	->end()
-	        ->type('SilverStripe\CMS\Model\RedirectorPage')
-	        	->addFields(['ExternalURL','Content'])
-	        	->operation(GraphQLScaffolder::READ)
-	        		->end()
-	        	->operation(GraphQLScaffolder::CREATE)
-	        		->end()
-	        	->end()
-	        ->type('Page')
-	        	->addFields(['BackwardsTitle'])
-	        	->end();
-
-
-
-        return $scaffolder;		
-	}  
-
-	public function canView($member = null, $context = []) { return true; }
-	public function canEdit($member = null, $context = []) { return true; }
-	public function canCreate($member = null, $context = []) { return true; }
-	public function canDelete($member = null, $context = []) { return true; }
-}
\ No newline at end of file
+		$scaffolder
+			->type(Post::class)
+			->addFields(['ID', 'Title', 'Content', 'Author', 'Date'])
+			// basic many_many nested query, no options
+			->nestedQuery('Files')
+			->end()
+			// more complex nested query
+			->nestedQuery('Comments')
+			->addArgs([
+				'Today' => 'Boolean'
+			])
+			->addSortableFields(['Author'])
+			->setResolver(function ($obj, $args, $context) {
+				$comments = $obj->Comments();
+				if (isset($args['Today']) && $args['Today']) {
+					$comments = $comments->where('DATE(Created) = DATE(NOW())');
+				}
+
+				return $comments;
+			})
+			->end()
+			// basic crud operation, no options
+			->operation(GraphQLScaffolder::CREATE)
+			->end()
+			// complex crud operation, with custom args
+			->operation(GraphQLScaffolder::READ)
+			->addArgs([
+				'StartingWith' => 'String'
+			])
+			->setResolver(function ($obj, $args) {
+				$list = Post::get();
+				if (isset($args['StartingWith'])) {
+					$list = $list->filter('Title:StartsWith', $args['StartingWith']);
+				}
+
+				return $list;
+			})
+			->end()
+			->end()
+			// these types were all created implicitly above. Add some fields to them.
+			->type(Member::class)
+			->addFields(['Name', 'FirstName', 'Surname', 'Email'])
+			->end()
+			->type(File::class)
+			->addAllFieldsExcept(['Content'])
+			->addFields(['File'])
+			->end()
+			->type(Comment::class)
+			->addFields(['Comment', 'Author'])
+			->end()
+			// Arbitrary mutation
+			->mutation('updatePostTitle', Post::class)
+			->addArgs([
+				'ID' => 'ID!',
+				'NewTitle' => 'String!'
+			])
+			->setResolver(function ($obj, $args) {
+				$post = Post::get()->byID($args['ID']);
+				if ($post->canEdit()) {
+					$post->Title = $args['NewTitle'];
+					$post->write();
+				}
+
+				return $post;
+			})
+			->end()
+			// Arbitrary query
+			->query('latestPost', Post::class)
+			->setUsePagination(false)
+			->setResolver(function ($obj, $args) {
+				return Post::get()->sort('Date', 'DESC')->first();
+			})
+			->end()
+			->type('SilverStripe\CMS\Model\RedirectorPage')
+			->addFields(['ExternalURL', 'Content'])
+			->operation(GraphQLScaffolder::READ)
+			->end()
+			->operation(GraphQLScaffolder::CREATE)
+			->end()
+			->end()
+			->type('Page')
+			->addFields(['BackwardsTitle'])
+			->end();
+
+
+		return $scaffolder;
+	}
+
+	public function canView($member = null, $context = [])
+	{
+		return true;
+	}
+
+	public function canEdit($member = null, $context = [])
+	{
+		return true;
+	}
+
+	public function canCreate($member = null, $context = [])
+	{
+		return true;
+	}
+
+	public function canDelete($member = null, $context = [])
+	{
+		return true;
+	}
+}

From 7047fbafd991865d71118c18108ea28fca95dff1 Mon Sep 17 00:00:00 2001
From: Ingo Schommer <ingo@silverstripe.com>
Date: Thu, 2 Feb 2017 12:28:15 +1300
Subject: [PATCH 63/66] Use DO->update() for create
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Constructor args on DataObject don’t call setters
---
 src/Scaffolding/Scaffolders/CRUD/Create.php | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/Scaffolding/Scaffolders/CRUD/Create.php b/src/Scaffolding/Scaffolders/CRUD/Create.php
index 1bcd96043..23712a39c 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Create.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Create.php
@@ -37,10 +37,8 @@ public function __construct($dataObjectClass)
         // Todo: this is totally half baked
         $this->setResolver(function ($object, array $args, $context, $info) {
             if (singleton($this->dataObjectClass)->canCreate($context['currentMember'])) {
-                $newObject = Injector::inst()->createWithArgs(
-                    $this->dataObjectClass,
-                    $args
-                );
+                $newObject = Injector::inst()->create($this->dataObjectClass);
+                $newObject->update($args['Input']);
                 $newObject->write();
 
                 return $newObject;

From 3e981b713a65aa5602821b8424091d88e2312c03 Mon Sep 17 00:00:00 2001
From: Ingo Schommer <ingo@silverstripe.com>
Date: Thu, 2 Feb 2017 22:15:34 +1300
Subject: [PATCH 64/66] Use DataObjectSchema

---
 src/Scaffolding/Scaffolders/CRUD/Create.php | 8 +++-----
 src/Scaffolding/Scaffolders/CRUD/Update.php | 9 ++++-----
 2 files changed, 7 insertions(+), 10 deletions(-)

diff --git a/src/Scaffolding/Scaffolders/CRUD/Create.php b/src/Scaffolding/Scaffolders/CRUD/Create.php
index 23712a39c..f357d1217 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Create.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Create.php
@@ -12,6 +12,7 @@
 use SilverStripe\GraphQL\Scaffolding\Interfaces\CRUDInterface;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
 use Exception;
+use SilverStripe\ORM\DataObjectSchema;
 
 /**
  * A generic "create" operation for a DataObject.
@@ -77,11 +78,8 @@ protected function generateInputType()
         $instance = $this->getDataObjectInstance();
 
         // Setup default input args.. Placeholder!
-        $db = (array) Config::inst()->get(
-            $this->dataObjectClass,
-            'db',
-            Config::INHERITED
-        );
+        $schema = Injector::inst()->get(DataObjectSchema::class);
+        $db = $schema->fieldSpecs($this->dataObjectClass);
 
         unset($db['ID']);
 
diff --git a/src/Scaffolding/Scaffolders/CRUD/Update.php b/src/Scaffolding/Scaffolders/CRUD/Update.php
index 6617e14eb..5f6108061 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Update.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Update.php
@@ -2,6 +2,7 @@
 
 namespace SilverStripe\GraphQL\Scaffolding\Scaffolders\CRUD;
 
+use SilverStripe\Core\Injector\Injector;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\MutationScaffolder;
 use SilverStripe\GraphQL\Scaffolding\Traits\DataObjectTypeTrait;
 use GraphQL\Type\Definition\InputObjectType;
@@ -13,6 +14,7 @@
 use SilverStripe\GraphQL\Scaffolding\Interfaces\CRUDInterface;
 use SilverStripe\GraphQL\Scaffolding\Scaffolders\SchemaScaffolder;
 use Exception;
+use SilverStripe\ORM\DataObjectSchema;
 
 /**
  * Scaffolds a generic update operation for DataObjects.
@@ -97,11 +99,8 @@ protected function generateInputType()
         $instance = $this->getDataObjectInstance();
 
         // Setup default input args.. Placeholder!
-        $db = (array) Config::inst()->get(
-            $this->dataObjectClass,
-            'db',
-            Config::INHERITED
-        );
+        $schema = Injector::inst()->get(DataObjectSchema::class);
+        $db = $schema->fieldSpecs($this->dataObjectClass);
 
         unset($db['ID']);
 

From 7d41007c3806ab3781f32b68d45404501a58e771 Mon Sep 17 00:00:00 2001
From: Ingo Schommer <ingo@silverstripe.com>
Date: Thu, 2 Feb 2017 22:43:40 +1300
Subject: [PATCH 65/66] More example class reference fixes

---
 examples/code/Post.php | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/examples/code/Post.php b/examples/code/Post.php
index 42084c200..948e15d11 100644
--- a/examples/code/Post.php
+++ b/examples/code/Post.php
@@ -53,10 +53,10 @@ public function provideGraphQLScaffolding(SchemaScaffolder $scaffolder)
 			})
 			->end()
 			// basic crud operation, no options
-			->operation(GraphQLScaffolder::CREATE)
+			->operation(SchemaScaffolder::CREATE)
 			->end()
 			// complex crud operation, with custom args
-			->operation(GraphQLScaffolder::READ)
+			->operation(SchemaScaffolder::READ)
 			->addArgs([
 				'StartingWith' => 'String'
 			])
@@ -106,9 +106,9 @@ public function provideGraphQLScaffolding(SchemaScaffolder $scaffolder)
 			->end()
 			->type('SilverStripe\CMS\Model\RedirectorPage')
 			->addFields(['ExternalURL', 'Content'])
-			->operation(GraphQLScaffolder::READ)
+			->operation(SchemaScaffolder::READ)
 			->end()
-			->operation(GraphQLScaffolder::CREATE)
+			->operation(SchemaScaffolder::CREATE)
 			->end()
 			->end()
 			->type('Page')

From fd5d41f8c86c47d3f4f71fc248a2f645f6872a08 Mon Sep 17 00:00:00 2001
From: Ingo Schommer <ingo@silverstripe.com>
Date: Thu, 2 Feb 2017 22:47:27 +1300
Subject: [PATCH 66/66] Correct use of currentUser context

---
 src/Scaffolding/Scaffolders/CRUD/Create.php |  2 +-
 src/Scaffolding/Scaffolders/CRUD/Delete.php |  2 +-
 src/Scaffolding/Scaffolders/CRUD/Read.php   |  4 ++--
 src/Scaffolding/Scaffolders/CRUD/Update.php |  2 +-
 tests/ScaffoldingTest.php                   | 14 +++++++-------
 5 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/Scaffolding/Scaffolders/CRUD/Create.php b/src/Scaffolding/Scaffolders/CRUD/Create.php
index f357d1217..4ae92a638 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Create.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Create.php
@@ -37,7 +37,7 @@ public function __construct($dataObjectClass)
 
         // Todo: this is totally half baked
         $this->setResolver(function ($object, array $args, $context, $info) {
-            if (singleton($this->dataObjectClass)->canCreate($context['currentMember'])) {
+            if (singleton($this->dataObjectClass)->canCreate($context['currentUser'])) {
                 $newObject = Injector::inst()->create($this->dataObjectClass);
                 $newObject->update($args['Input']);
                 $newObject->write();
diff --git a/src/Scaffolding/Scaffolders/CRUD/Delete.php b/src/Scaffolding/Scaffolders/CRUD/Delete.php
index 88f2fdac0..2a6990adc 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Delete.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Delete.php
@@ -38,7 +38,7 @@ public function __construct($dataObjectClass)
                     ->byIDs($args['IDs']);
 
                 foreach ($results as $obj) {
-                    if ($obj->canDelete($context['currentMember'])) {
+                    if ($obj->canDelete($context['currentUser'])) {
                         $obj->delete();
                     } else {
                         throw new Exception(sprintf(
diff --git a/src/Scaffolding/Scaffolders/CRUD/Read.php b/src/Scaffolding/Scaffolders/CRUD/Read.php
index d1c6ae25b..dfc469d04 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Read.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Read.php
@@ -33,13 +33,13 @@ public function __construct($dataObjectClass)
         parent::__construct($operationName, $this->typeName());
 
         $this->setResolver(function ($object, array $args, $context, $info) {
-            if (!singleton($this->dataObjectClass)->canView($context['currentMember'])) {
+            if (!singleton($this->dataObjectClass)->canView($context['currentUser'])) {
                 throw new Exception(sprintf(
                     'Cannot create %s',
                     $this->dataObjectClass
                 ));
             }
-            
+
             $list = DataList::create($this->dataObjectClass);
 
             return $list;
diff --git a/src/Scaffolding/Scaffolders/CRUD/Update.php b/src/Scaffolding/Scaffolders/CRUD/Update.php
index 5f6108061..507c70053 100644
--- a/src/Scaffolding/Scaffolders/CRUD/Update.php
+++ b/src/Scaffolding/Scaffolders/CRUD/Update.php
@@ -49,7 +49,7 @@ public function __construct($dataObjectClass)
                 ));
             }
 
-            if ($obj->canEdit($context['currentMember'])) {
+            if ($obj->canEdit($context['currentUser'])) {
                 $obj->update($args['Input']);
                 $obj->write();
 
diff --git a/tests/ScaffoldingTest.php b/tests/ScaffoldingTest.php
index 297192327..c31142880 100644
--- a/tests/ScaffoldingTest.php
+++ b/tests/ScaffoldingTest.php
@@ -977,7 +977,7 @@ public function testCreateOperationResolver()
                 'Input' => ['MyField' => '__testing__']
             ],
             [
-                'currentMember' => Member::create()
+                'currentUser' => Member::create()
             ],
             new ResolveInfo([])
         );
@@ -1021,7 +1021,7 @@ public function testCreateOperationPermissionCheck()
         $scaffold['resolve'](
             null,
             [],
-            ['currentMember' => Member::create()],
+            ['currentUser' => Member::create()],
             new ResolveInfo([])
         );
     }
@@ -1043,7 +1043,7 @@ public function testUpdateOperationResolver()
                 'Input' => ['MyField' => 'new']
             ],
             [
-                'currentMember' => Member::create()
+                'currentUser' => Member::create()
             ],
             new ResolveInfo([])
         );
@@ -1089,7 +1089,7 @@ public function testUpdateOperationPermissionCheck()
         $scaffold['resolve'](
             $restrictedDataobject,
             ['ID' => $ID],
-            ['currentMember' => Member::create()],
+            ['currentUser' => Member::create()],
             new ResolveInfo([])
         );
     }
@@ -1115,7 +1115,7 @@ public function testDeleteOperationResolver()
                 'IDs' => [$ID1, $ID2]
             ],
             [
-                'currentMember' => Member::create()
+                'currentUser' => Member::create()
             ],
             new ResolveInfo([])
         );
@@ -1158,7 +1158,7 @@ public function testDeleteOperationPermissionCheck()
         $scaffold['resolve'](
             $restrictedDataobject,
             ['IDs' => [$ID]],
-            ['currentMember' => Member::create()],
+            ['currentUser' => Member::create()],
             new ResolveInfo([])
         );
     }
@@ -1183,7 +1183,7 @@ public function testReadOperationResolver()
             null,
             [],
             [
-                'currentMember' => Member::create()
+                'currentUser' => Member::create()
             ],
             new ResolveInfo([])
         );