# Source: src/js/bundle.js

    (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
    /*!

     ----------------------------------------------------------------------------
     | ewd-client: Browser (websocket & HTTP) Client for ewd-xpress applications |
     |                                                                           |
     | Copyright (c) 2016 M/Gateway Developments Ltd,                            |
     | Reigate, Surrey UK.                                                       |
     | All rights reserved.                                                      |
     |                                                                           |
     | http://www.mgateway.com                                                   |
     | Email: rtweed@mgateway.com                                                |
     |                                                                           |
     |                                                                           |
     | 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.                                           |
     ----------------------------------------------------------------------------

     */

    'use strict';

    module.exports = require('./lib/ewd');

    },{"./lib/ewd":2}],2:[function(require,module,exports){
    /*

     ----------------------------------------------------------------------------
     | ewd-client: Browser (websocket & HTTP) Client for ewd-xpress applications |
     |                                                                           |
     | Copyright (c) 2016 M/Gateway Developments Ltd,                            |
     | Reigate, Surrey UK.                                                       |
     | All rights reserved.                                                      |
     |                                                                           |
     | http://www.mgateway.com                                                   |
     | Email: rtweed@mgateway.com                                                |
     |                                                                           |
     |                                                                           |
     | 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.                                           |
     ----------------------------------------------------------------------------

    */

    module.exports = {
      EWD: require('./proto/ewd-client')
    };

    },{"./proto/ewd-client":3}],3:[function(require,module,exports){
    /*!

     ----------------------------------------------------------------------------
     | ewd-client: Browser (websocket & HTTP) Client for ewd-xpress applications |
     |                                                                           |
     | Copyright (c) 2016 M/Gateway Developments Ltd,                            |
     | Reigate, Surrey UK.                                                       |
     | All rights reserved.                                                      |
     |                                                                           |
     | http://www.mgateway.com                                                   |
     | Email: rtweed@mgateway.com                                                |
     |                                                                           |
     |                                                                           |
     | 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.                                           |
     ----------------------------------------------------------------------------

     17 December 2016

     */

    var EWD;

    (function() {
      var events = {};

      var emitter = {
        on: function(type, callback, deleteWhenFinished) {
          if (!events[type]) events[type] = [];
          events[type].push({
            callback: callback,
            deleteWhenFinished: deleteWhenFinished
          });
        },
        off: function(type, callback) {
          var event = events[type];
          if (typeof callback === 'function') {
            if (event) {
              for (var i = 0; i < event.length; i++) {
                if (event[i].callback === callback) {
                  event.splice(i,1);
                }
              }
            }
          }
          else {
            event = [];
          }
        },
        emit: function(type, data) {
          var ev = events[type];
          if (!ev || ev.length < 1) return;
          data = data || {};
          for (var i = 0; i < ev.length; i++) {
            var e = ev[i];
            e.callback(data);
            if (e.deleteWhenFinished && data.finished) ev.splice(i,1);
          }
        }
      };

      var start = function(application, $, io, customAjaxFn, url) {

        //console.log('starting ewd-client: ' + JSON.stringify(application));

        var url;
        var cookieName = 'ewdSession';
        var appName = application;
        if (typeof application === 'object') {
          $ = application.$;
          io = application.io;
          customAjaxFn = application.ajax;
          url = application.url;
          appName = application.application;
          cookieName = application.cookieName;
        }

        function getCookie(name) {
          var value = "; " + document.cookie;
          var parts = value.split("; " + name + "=");
          if (parts.length == 2) return parts.pop().split(";").shift();
        }

        (function(application, io, customAjaxFn, url) {

          //console.log('application = ' + application);
          //console.log('customAjaxFn = ' + typeof customAjaxFn);

          var token;

          EWD.application = application;

          function registerEvent(messageObj, callback) {
            var cb = callback;
            var type = messageObj.type;
            if (type === 'ewd-fragment') {
              type = type + ':' + messageObj.params.file;
              var targetId = messageObj.params.targetId;
              var fragmentName = messageObj.params.file;
              cb = function(responseObj) {
                if (typeof $ !== 'undefined') $('#' + targetId).html(responseObj.message.content);
                callback(fragmentName);
              }
              delete messageObj.params.targetId;
            }
            EWD.on(type, cb, true);
          }

          function handleResponse(messageObj) {
            // messages received back from Node.js

            //if (EWD.log && messageObj.type !== 'ewd-register') console.log('raw received: ' + JSON.stringify(messageObj));
            if (messageObj.message && messageObj.message.error && messageObj.message.disconnect) {
              if (typeof socket !== 'undefined') {
                socket.disconnect();
                console.log('Socket disconnected');
              }
              EWD.send = function() {};
              EWD.emit = function() {};
              console.log(messageObj.message.error);
              return;
            }
            if (messageObj.type === 'ewd-register') {
              token = messageObj.message.token;

              EWD.setCookie = function(name) {
                name = name || 'ewd-token';
                document.cookie = name + "=" + token;
              };

              console.log(application + ' registered');
              EWD.emit('ewd-registered');
              return;
            }
            if (messageObj.type === 'ewd-reregister') {
              console.log('Re-registered');
              EWD.emit('ewd-reregistered');
              return;
            }
            if (EWD.log) console.log('received: ' + JSON.stringify(messageObj));

            if (messageObj.type === 'ewd-fragment') {
               if (messageObj.message.error) {
                 EWD.emit('error', messageObj);
                 return;
               }
               EWD.emit('ewd-fragment:' + messageObj.message.fragmentName, messageObj);
               return;
            }

            if (messageObj.message && messageObj.message.error) {
              var ok = EWD.emit('error', messageObj);
              if (ok) return;
            }

            EWD.emit(messageObj.type, messageObj);
          };

          function ajax(messageObj, callback) {
              if (callback) {
                registerEvent(messageObj, callback);
              }
              if (token) {
                messageObj.token = token;
              }
              if (token || messageObj.type === 'ewd-register') {
                messageObj.token = token;
                console.log('Ajax send: ' + JSON.stringify(messageObj));
                (function(type) {

                  function success(data) {
                    console.log('Ajax response for type ' + type + ': ' + JSON.stringify(data));
                    if (data.ewd_response !== false) {
                      handleResponse({
                        type: type,
                        message: data,
                        finished: true
                      });
                    }
                  }

                  function fail(error) {
                    console.log('Error occurred: ' + error);
                    var messageObj = {
                      message: {error: error}
                    };
                    EWD.emit('error', messageObj);
                  }

                  var params = {
                    url: '/ajax',
                    type: 'post',
                    contentType: 'application/json',
                    data: messageObj,
                    dataType: 'json',
                    timeout: 10000
                  };

                  if (customAjaxFn) {
                    customAjaxFn(params, success, fail);
                  }
                  else if (typeof $ !== 'undefined') {
                    $.ajax({
                      url: params.url,
                      type: params.type,
                      contentType: params.contentType,
                      data: JSON.stringify(params.data),
                      dataType: params.dataType,
                      timeout: params.timeout
                    })
                    .done(function(data) {
                      success(data);
                    })
                    .error(function(err) {
                      var error = err.responseJSON.error;
                      fail(error);
                    });
                  }
                  else {
                    console.log('Error: No Ajax handler function is available');
                  }
                }(messageObj.type));
                delete messageObj.token;
                if (EWD.log) console.log('sent: ' + JSON.stringify(messageObj));
              }
          };

          EWD.send = function(messageObj, callback) {
            if (messageObj.ajax) {
              ajax(messageObj, callback);
              return;
            }
            if (callback) {
              registerEvent(messageObj, callback);
            }
            if (token) {
              messageObj.token = token;
              socket.emit('ewdjs', messageObj);
              delete messageObj.token;
              if (EWD.log) console.log('sent: ' + JSON.stringify(messageObj));
            }
          };

          EWD.getFragment = function(params, callback) {
            EWD.send({
              type: 'ewd-fragment',
              service: params.service || false,
              params: {
                file: params.name,
                targetId: params.targetId
              }
            }, callback);
          };

          if (io) {
            var socket;
            if (url) {
              socket = io(url, {
                transports: ['websocket'] // needed for react-native
              });
            }
            else {
              socket = io.connect();
            }
            socket.on('connect', function() {

              EWD.disconnectSocket = function() {
                socket.disconnect();
                console.log('EWD disconnected socket');
              };

              //console.log('token: ' + token + '; ' + cookieName + ' cookie: ' + getCookie(cookieName));

              if (!token && cookieName && getCookie(cookieName)) token = getCookie(cookieName);

              if (token) {
                // re-connection occured - re-register to attach to original Session
                var message = {
                  type: 'ewd-reregister',
                  token: token
                };
              }
              else {
                var message = {
                  type: 'ewd-register',
                  application: application
                };
              }
              socket.emit('ewdjs', message);
            });

            socket.on('ewdjs', handleResponse);

            socket.on('disconnect', function() {
              console.log('*** server has disconnected socket, probably because it shut down');
              EWD.emit('socketDisconnected');
            });

          }
          else {
            EWD.send = ajax;
            EWD.send({
              type: 'ewd-register',
              application: application
            });
          }

        })(appName, io, customAjaxFn, url);

        EWD.start = function() {};
        io = null;
        customAjaxFn = null;
      }

      var ewd = function() {
        this.application = 'undefined';
        this.log = false;
      };

      var proto = ewd.prototype;
      proto.on = emitter.on;
      proto.off = emitter.off;
      proto.emit = emitter.emit;
      proto.start = start;

      EWD = new ewd();
    })();

    if (typeof module !== 'undefined') module.exports = EWD;
    },{}],4:[function(require,module,exports){
    /*!

     ----------------------------------------------------------------------------
     | ewd-xpress-react: React Client Modules for ewd-xpress                    |
     |                                                                          |
     | Copyright (c) 2016 M/Gateway Developments Ltd,                           |
     | Reigate, Surrey UK.                                                      |
     | All rights reserved.                                                     |
     |                                                                          |
     | http://www.mgateway.com                                                  |
     | Email: rtweed@mgateway.com                                               |
     |                                                                          |
     |                                                                          |
     | 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.                                          |
     ----------------------------------------------------------------------------

     */

    'use strict';

    module.exports = require('./lib/ewd-react');

    },{"./lib/ewd-react":6}],5:[function(require,module,exports){
    /*

     ----------------------------------------------------------------------------
     | ewd-xpress-react: React Client Modules for ewd-xpress                    |
     |                                                                          |
     | Copyright (c) 2016 M/Gateway Developments Ltd,                           |
     | Reigate, Surrey UK.                                                      |
     | All rights reserved.                                                     |
     |                                                                          |
     | http://www.mgateway.com                                                  |
     | Email: rtweed@mgateway.com                                               |
     |                                                                          |
     |                                                                          |
     | 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.                                          |
     ----------------------------------------------------------------------------

      14 December 2016

    */

    module.exports = function (envObj, component, $, io) {

      // Here we do all the EWD-specific stuff

      envObj.on('ewd-registered', function() {
        component.setState({
          status: 'go'
        });
      });

      envObj.on('ewd-reregistered', function() {
        if (component.state.status === 'wait') {
          component.setState({
            status: 'go'
          });
        }
      });

      envObj.on('socketDisconnected', function() {
        if (component.state.status === 'wait') {
          component.setState({
            status: 'disconnected'
          });
        }
      });

      component.start = function(application) {
        envObj.start(application, $, io);
      };

      envObj.componentPaths = {};

      envObj.updateComponentPath = function(component) {
        // builds a React component hierarchy for the application
        var componentPath = component.props.componentPath;
        var path = componentPath.slice(0);
        path.push(component.constructor.displayName);
        var pathStr = JSON.stringify(path);
        if (!envObj[pathStr]) {
          console.log('Component path: ' + pathStr);
          envObj.send({
            type: 'updateComponentPath',
            params: {
              path: path
            },
            service: 'ewd-react-tools'
          });
          envObj[pathStr] = true;
        }
        return path;
      };

      return envObj;

    };

    },{}],6:[function(require,module,exports){
    /*

     ----------------------------------------------------------------------------
     | ewd-xpress-react: React Client Modules for ewd-xpress                    |
     |                                                                          |
     | Copyright (c) 2016 M/Gateway Developments Ltd,                           |
     | Reigate, Surrey UK.                                                      |
     | All rights reserved.                                                     |
     |                                                                          |
     | http://www.mgateway.com                                                  |
     | Email: rtweed@mgateway.com                                               |
     |                                                                          |
     |                                                                          |
     | 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.                                          |
     ----------------------------------------------------------------------------

      27 April 2016

    */

    var loader = require('./loader');
    var controller = require('./controller');

    module.exports = {
      loader: loader,
      controller: controller
    };
    },{"./controller":5,"./loader":7}],7:[function(require,module,exports){
    /*

     ----------------------------------------------------------------------------
     | ewd-xpress-react: React Client Modules for ewd-xpress                    |
     |                                                                          |
     | Copyright (c) 2016 M/Gateway Developments Ltd,                           |
     | Reigate, Surrey UK.                                                      |
     | All rights reserved.                                                     |
     |                                                                          |
     | http://www.mgateway.com                                                  |
     | Email: rtweed@mgateway.com                                               |
     |                                                                          |
     |                                                                          |
     | 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.                                          |
     ----------------------------------------------------------------------------

      14 December 2016

    */

    "use strict"

    var React = require('react');
    var ReactDOM = require('react-dom');
    var ewdClient = require('ewd-client');
    var ewdController = require('./controller');

    module.exports = function(params) {

      var io;
      if (!params.no_sockets) io = require('socket.io-client');
      var $;
      if (!params.ajax) $ = require('jquery');

      var EWD = ewdClient.EWD;
      //console.log('cwd = ' + process.cwd());
      EWD.application = {
        name: params.applicationName || 'unknown',
        mode: params.mode || 'development',
        log: params.log || true
      };

      EWD.log = params.log || false;

      //console.log('EWD = ' + JSON.stringify(EWD));
      var MainPage = params.MainPage;

      var Top = React.createClass({displayName: "Top",

        getInitialState: function() {
          return {
            status: 'wait',
          }
        },

        componentWillMount: function() {

          // set up EWD.js-specific context

          this.controller = ewdController(EWD, this, $, io);
        },

        componentDidMount: function() {
          if (params.log) console.log('starting EWD');
          var startParams = {
            application: EWD.application.name,
            cookieName: params.cookieName,
            url: params.url,
            io: io,
            $: $
          };
          this.start(startParams);
        },

      render: function render() {

        var componentPath = ['app'];

        var renderComponent;
        if (this.state.status === 'wait') {
          renderComponent = React.createElement(
            'div',
            null,
            'Please wait...'
          );
        } else {
          renderComponent = React.createElement(MainPage, {
            controller: this.controller,
            componentPath: componentPath,
            status: this.state.status
          });
        }

        return renderComponent;
      }
    });

    ReactDOM.render(React.createElement(Top, null), document.getElementById('content'));
    };
    },{"./controller":5,"ewd-client":1,"jquery":8,"react":618,"react-dom":262,"socket.io-client":619}],8:[function(require,module,exports){
    /*!
     * jQuery JavaScript Library v3.1.1
     * https://jquery.com/
     *
     * Includes Sizzle.js
     * https://sizzlejs.com/
     *
     * Copyright jQuery Foundation and other contributors
     * Released under the MIT license
     * https://jquery.org/license
     *
     * Date: 2016-09-22T22:30Z
     */
    ( function( global, factory ) {

    	"use strict";

    	if ( typeof module === "object" && typeof module.exports === "object" ) {

    		// For CommonJS and CommonJS-like environments where a proper `window`
    		// is present, execute the factory and get jQuery.
    		// For environments that do not have a `window` with a `document`
    		// (such as Node.js), expose a factory as module.exports.
    		// This accentuates the need for the creation of a real `window`.
    		// e.g. var jQuery = require("jquery")(window);
    		// See ticket #14549 for more info.
    		module.exports = global.document ?
    			factory( global, true ) :
    			function( w ) {
    				if ( !w.document ) {
    					throw new Error( "jQuery requires a window with a document" );
    				}
    				return factory( w );
    			};
    	} else {
    		factory( global );
    	}

    // Pass this if window is not defined yet
    } )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {

    // Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
    // throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
    // arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
    // enough that all such attempts are guarded in a try block.
    "use strict";

    var arr = [];

    var document = window.document;

    var getProto = Object.getPrototypeOf;

    var slice = arr.slice;

    var concat = arr.concat;

    var push = arr.push;

    var indexOf = arr.indexOf;

    var class2type = {};

    var toString = class2type.toString;

    var hasOwn = class2type.hasOwnProperty;

    var fnToString = hasOwn.toString;

    var ObjectFunctionString = fnToString.call( Object );

    var support = {};

    	function DOMEval( code, doc ) {
    		doc = doc || document;

    		var script = doc.createElement( "script" );

    		script.text = code;
    		doc.head.appendChild( script ).parentNode.removeChild( script );
    	}
    /* global Symbol */
    // Defining this global in .eslintrc.json would create a danger of using the global
    // unguarded in another place, it seems safer to define global only for this module

    var
    	version = "3.1.1",

    	// Define a local copy of jQuery
    	jQuery = function( selector, context ) {

    		// The jQuery object is actually just the init constructor 'enhanced'
    		// Need init if jQuery is called (just allow error to be thrown if not included)
    		return new jQuery.fn.init( selector, context );
    	},

    	// Support: Android <=4.0 only
    	// Make sure we trim BOM and NBSP
    	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,

    	// Matches dashed string for camelizing
    	rmsPrefix = /^-ms-/,
    	rdashAlpha = /-([a-z])/g,

    	// Used by jQuery.camelCase as callback to replace()
    	fcamelCase = function( all, letter ) {
    		return letter.toUpperCase();
    	};

    jQuery.fn = jQuery.prototype = {

    	// The current version of jQuery being used
    	jquery: version,

    	constructor: jQuery,

    	// The default length of a jQuery object is 0
    	length: 0,

    	toArray: function() {
    		return slice.call( this );
    	},

    	// Get the Nth element in the matched element set OR
    	// Get the whole matched element set as a clean array
    	get: function( num ) {

    		// Return all the elements in a clean array
    		if ( num == null ) {
    			return slice.call( this );
    		}

    		// Return just the one element from the set
    		return num < 0 ? this[ num + this.length ] : this[ num ];
    	},

    	// Take an array of elements and push it onto the stack
    	// (returning the new matched element set)
    	pushStack: function( elems ) {

    		// Build a new jQuery matched element set
    		var ret = jQuery.merge( this.constructor(), elems );

    		// Add the old object onto the stack (as a reference)
    		ret.prevObject = this;

    		// Return the newly-formed element set
    		return ret;
    	},

    	// Execute a callback for every element in the matched set.
    	each: function( callback ) {
    		return jQuery.each( this, callback );
    	},

    	map: function( callback ) {
    		return this.pushStack( jQuery.map( this, function( elem, i ) {
    			return callback.call( elem, i, elem );
    		} ) );
    	},

    	slice: function() {
    		return this.pushStack( slice.apply( this, arguments ) );
    	},

    	first: function() {
    		return this.eq( 0 );
    	},

    	last: function() {
    		return this.eq( -1 );
    	},

    	eq: function( i ) {
    		var len = this.length,
    			j = +i + ( i < 0 ? len : 0 );
    		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
    	},

    	end: function() {
    		return this.prevObject || this.constructor();
    	},

    	// For internal use only.
    	// Behaves like an Array's method, not like a jQuery method.
    	push: push,
    	sort: arr.sort,
    	splice: arr.splice
    };

    jQuery.extend = jQuery.fn.extend = function() {
    	var options, name, src, copy, copyIsArray, clone,
    		target = arguments[ 0 ] || {},
    		i = 1,
    		length = arguments.length,
    		deep = false;

    	// Handle a deep copy situation
    	if ( typeof target === "boolean" ) {
    		deep = target;

    		// Skip the boolean and the target
    		target = arguments[ i ] || {};
    		i++;
    	}

    	// Handle case when target is a string or something (possible in deep copy)
    	if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
    		target = {};
    	}

    	// Extend jQuery itself if only one argument is passed
    	if ( i === length ) {
    		target = this;
    		i--;
    	}

    	for ( ; i < length; i++ ) {

    		// Only deal with non-null/undefined values
    		if ( ( options = arguments[ i ] ) != null ) {

    			// Extend the base object
    			for ( name in options ) {
    				src = target[ name ];
    				copy = options[ name ];

    				// Prevent never-ending loop
    				if ( target === copy ) {
    					continue;
    				}

    				// Recurse if we're merging plain objects or arrays
    				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
    					( copyIsArray = jQuery.isArray( copy ) ) ) ) {

    					if ( copyIsArray ) {
    						copyIsArray = false;
    						clone = src && jQuery.isArray( src ) ? src : [];

    					} else {
    						clone = src && jQuery.isPlainObject( src ) ? src : {};
    					}

    					// Never move original objects, clone them
    					target[ name ] = jQuery.extend( deep, clone, copy );

    				// Don't bring in undefined values
    				} else if ( copy !== undefined ) {
    					target[ name ] = copy;
    				}
    			}
    		}
    	}

    	// Return the modified object
    	return target;
    };

    jQuery.extend( {

    	// Unique for each copy of jQuery on the page
    	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),

    	// Assume jQuery is ready without the ready module
    	isReady: true,

    	error: function( msg ) {
    		throw new Error( msg );
    	},

    	noop: function() {},

    	isFunction: function( obj ) {
    		return jQuery.type( obj ) === "function";
    	},

    	isArray: Array.isArray,

    	isWindow: function( obj ) {
    		return obj != null && obj === obj.window;
    	},

    	isNumeric: function( obj ) {

    		// As of jQuery 3.0, isNumeric is limited to
    		// strings and numbers (primitives or objects)
    		// that can be coerced to finite numbers (gh-2662)
    		var type = jQuery.type( obj );
    		return ( type === "number" || type === "string" ) &&

    			// parseFloat NaNs numeric-cast false positives ("")
    			// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
    			// subtraction forces infinities to NaN
    			!isNaN( obj - parseFloat( obj ) );
    	},

    	isPlainObject: function( obj ) {
    		var proto, Ctor;

    		// Detect obvious negatives
    		// Use toString instead of jQuery.type to catch host objects
    		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
    			return false;
    		}

    		proto = getProto( obj );

    		// Objects with no prototype (e.g., `Object.create( null )`) are plain
    		if ( !proto ) {
    			return true;
    		}

    		// Objects with prototype are plain iff they were constructed by a global Object function
    		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
    		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
    	},

    	isEmptyObject: function( obj ) {

    		/* eslint-disable no-unused-vars */
    		// See https://github.com/eslint/eslint/issues/6125
    		var name;

    		for ( name in obj ) {
    			return false;
    		}
    		return true;
    	},

    	type: function( obj ) {
    		if ( obj == null ) {
    			return obj + "";
    		}

    		// Support: Android <=2.3 only (functionish RegExp)
    		return typeof obj === "object" || typeof obj === "function" ?
    			class2type[ toString.call( obj ) ] || "object" :
    			typeof obj;
    	},

    	// Evaluates a script in a global context
    	globalEval: function( code ) {
    		DOMEval( code );
    	},

    	// Convert dashed to camelCase; used by the css and data modules
    	// Support: IE <=9 - 11, Edge 12 - 13
    	// Microsoft forgot to hump their vendor prefix (#9572)
    	camelCase: function( string ) {
    		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
    	},

    	nodeName: function( elem, name ) {
    		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
    	},

    	each: function( obj, callback ) {
    		var length, i = 0;

    		if ( isArrayLike( obj ) ) {
    			length = obj.length;
    			for ( ; i < length; i++ ) {
    				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
    					break;
    				}
    			}
    		} else {
    			for ( i in obj ) {
    				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
    					break;
    				}
    			}
    		}

    		return obj;
    	},

    	// Support: Android <=4.0 only
    	trim: function( text ) {
    		return text == null ?
    			"" :
    			( text + "" ).replace( rtrim, "" );
    	},

    	// results is for internal usage only
    	makeArray: function( arr, results ) {
    		var ret = results || [];

    		if ( arr != null ) {
    			if ( isArrayLike( Object( arr ) ) ) {
    				jQuery.merge( ret,
    					typeof arr === "string" ?
    					[ arr ] : arr
    				);
    			} else {
    				push.call( ret, arr );
    			}
    		}

    		return ret;
    	},

    	inArray: function( elem, arr, i ) {
    		return arr == null ? -1 : indexOf.call( arr, elem, i );
    	},

    	// Support: Android <=4.0 only, PhantomJS 1 only
    	// push.apply(_, arraylike) throws on ancient WebKit
    	merge: function( first, second ) {
    		var len = +second.length,
    			j = 0,
    			i = first.length;

    		for ( ; j < len; j++ ) {
    			first[ i++ ] = second[ j ];
    		}

    		first.length = i;

    		return first;
    	},

    	grep: function( elems, callback, invert ) {
    		var callbackInverse,
    			matches = [],
    			i = 0,
    			length = elems.length,
    			callbackExpect = !invert;

    		// Go through the array, only saving the items
    		// that pass the validator function
    		for ( ; i < length; i++ ) {
    			callbackInverse = !callback( elems[ i ], i );
    			if ( callbackInverse !== callbackExpect ) {
    				matches.push( elems[ i ] );
    			}
    		}

    		return matches;
    	},

    	// arg is for internal usage only
    	map: function( elems, callback, arg ) {
    		var length, value,
    			i = 0,
    			ret = [];

    		// Go through the array, translating each of the items to their new values
    		if ( isArrayLike( elems ) ) {
    			length = elems.length;
    			for ( ; i < length; i++ ) {
    				value = callback( elems[ i ], i, arg );

    				if ( value != null ) {
    					ret.push( value );
    				}
    			}

    		// Go through every key on the object,
    		} else {
    			for ( i in elems ) {
    				value = callback( elems[ i ], i, arg );

    				if ( value != null ) {
    					ret.push( value );
    				}
    			}
    		}

    		// Flatten any nested arrays
    		return concat.apply( [], ret );
    	},

    	// A global GUID counter for objects
    	guid: 1,

    	// Bind a function to a context, optionally partially applying any
    	// arguments.
    	proxy: function( fn, context ) {
    		var tmp, args, proxy;

    		if ( typeof context === "string" ) {
    			tmp = fn[ context ];
    			context = fn;
    			fn = tmp;
    		}

    		// Quick check to determine if target is callable, in the spec
    		// this throws a TypeError, but we will just return undefined.
    		if ( !jQuery.isFunction( fn ) ) {
    			return undefined;
    		}

    		// Simulated bind
    		args = slice.call( arguments, 2 );
    		proxy = function() {
    			return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
    		};

    		// Set the guid of unique handler to the same of original handler, so it can be removed
    		proxy.guid = fn.guid = fn.guid || jQuery.guid++;

    		return proxy;
    	},

    	now: Date.now,

    	// jQuery.support is not used in Core but other projects attach their
    	// properties to it so it needs to exist.
    	support: support
    } );

    if ( typeof Symbol === "function" ) {
    	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
    }

    // Populate the class2type map
    jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
    function( i, name ) {
    	class2type[ "[object " + name + "]" ] = name.toLowerCase();
    } );

    function isArrayLike( obj ) {

    	// Support: real iOS 8.2 only (not reproducible in simulator)
    	// `in` check used to prevent JIT error (gh-2145)
    	// hasOwn isn't used here due to false negatives
    	// regarding Nodelist length in IE
    	var length = !!obj && "length" in obj && obj.length,
    		type = jQuery.type( obj );

    	if ( type === "function" || jQuery.isWindow( obj ) ) {
    		return false;
    	}

    	return type === "array" || length === 0 ||
    		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
    }
    var Sizzle =
    /*!
     * Sizzle CSS Selector Engine v2.3.3
     * https://sizzlejs.com/
     *
     * Copyright jQuery Foundation and other contributors
     * Released under the MIT license
     * http://jquery.org/license
     *
     * Date: 2016-08-08
     */
    (function( window ) {

    var i,
    	support,
    	Expr,
    	getText,
    	isXML,
    	tokenize,
    	compile,
    	select,
    	outermostContext,
    	sortInput,
    	hasDuplicate,

    	// Local document vars
    	setDocument,
    	document,
    	docElem,
    	documentIsHTML,
    	rbuggyQSA,
    	rbuggyMatches,
    	matches,
    	contains,

    	// Instance-specific data
    	expando = "sizzle" + 1 * new Date(),
    	preferredDoc = window.document,
    	dirruns = 0,
    	done = 0,
    	classCache = createCache(),
    	tokenCache = createCache(),
    	compilerCache = createCache(),
    	sortOrder = function( a, b ) {
    		if ( a === b ) {
    			hasDuplicate = true;
    		}
    		return 0;
    	},

    	// Instance methods
    	hasOwn = ({}).hasOwnProperty,
    	arr = [],
    	pop = arr.pop,
    	push_native = arr.push,
    	push = arr.push,
    	slice = arr.slice,
    	// Use a stripped-down indexOf as it's faster than native
    	// https://jsperf.com/thor-indexof-vs-for/5
    	indexOf = function( list, elem ) {
    		var i = 0,
    			len = list.length;
    		for ( ; i < len; i++ ) {
    			if ( list[i] === elem ) {
    				return i;
    			}
    		}
    		return -1;
    	},

    	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",

    	// Regular expressions

    	// http://www.w3.org/TR/css3-selectors/#whitespace
    	whitespace = "[\\x20\\t\\r\\n\\f]",

    	// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
    	identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",

    	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
    	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
    		// Operator (capture 2)
    		"*([*^$|!~]?=)" + whitespace +
    		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
    		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
    		"*\\]",

    	pseudos = ":(" + identifier + ")(?:\\((" +
    		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
    		// 1. quoted (capture 3; capture 4 or capture 5)
    		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
    		// 2. simple (capture 6)
    		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
    		// 3. anything else (capture 2)
    		".*" +
    		")\\)|)",

    	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
    	rwhitespace = new RegExp( whitespace + "+", "g" ),
    	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),

    	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
    	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),

    	rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),

    	rpseudo = new RegExp( pseudos ),
    	ridentifier = new RegExp( "^" + identifier + "$" ),

    	matchExpr = {
    		"ID": new RegExp( "^#(" + identifier + ")" ),
    		"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
    		"TAG": new RegExp( "^(" + identifier + "|[*])" ),
    		"ATTR": new RegExp( "^" + attributes ),
    		"PSEUDO": new RegExp( "^" + pseudos ),
    		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
    			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
    			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
    		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
    		// For use in libraries implementing .is()
    		// We use this for POS matching in `select`
    		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
    			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
    	},

    	rinputs = /^(?:input|select|textarea|button)$/i,
    	rheader = /^h\d$/i,

    	rnative = /^[^{]+\{\s*\[native \w/,

    	// Easily-parseable/retrievable ID or TAG or CLASS selectors
    	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,

    	rsibling = /[+~]/,

    	// CSS escapes
    	// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
    	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
    	funescape = function( _, escaped, escapedWhitespace ) {
    		var high = "0x" + escaped - 0x10000;
    		// NaN means non-codepoint
    		// Support: Firefox<24
    		// Workaround erroneous numeric interpretation of +"0x"
    		return high !== high || escapedWhitespace ?
    			escaped :
    			high < 0 ?
    				// BMP codepoint
    				String.fromCharCode( high + 0x10000 ) :
    				// Supplemental Plane codepoint (surrogate pair)
    				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
    	},

    	// CSS string/identifier serialization
    	// https://drafts.csswg.org/cssom/#common-serializing-idioms
    	rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
    	fcssescape = function( ch, asCodePoint ) {
    		if ( asCodePoint ) {

    			// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
    			if ( ch === "\0" ) {
    				return "\uFFFD";
    			}

    			// Control characters and (dependent upon position) numbers get escaped as code points
    			return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
    		}

    		// Other potentially-special ASCII characters get backslash-escaped
    		return "\\" + ch;
    	},

    	// Used for iframes
    	// See setDocument()
    	// Removing the function wrapper causes a "Permission Denied"
    	// error in IE
    	unloadHandler = function() {
    		setDocument();
    	},

    	disabledAncestor = addCombinator(
    		function( elem ) {
    			return elem.disabled === true && ("form" in elem || "label" in elem);
    		},
    		{ dir: "parentNode", next: "legend" }
    	);

    // Optimize for push.apply( _, NodeList )
    try {
    	push.apply(
    		(arr = slice.call( preferredDoc.childNodes )),
    		preferredDoc.childNodes
    	);
    	// Support: Android<4.0
    	// Detect silently failing push.apply
    	arr[ preferredDoc.childNodes.length ].nodeType;
    } catch ( e ) {
    	push = { apply: arr.length ?

    		// Leverage slice if possible
    		function( target, els ) {
    			push_native.apply( target, slice.call(els) );
    		} :

    		// Support: IE<9
    		// Otherwise append directly
    		function( target, els ) {
    			var j = target.length,
    				i = 0;
    			// Can't trust NodeList.length
    			while ( (target[j++] = els[i++]) ) {}
    			target.length = j - 1;
    		}
    	};
    }

    function Sizzle( selector, context, results, seed ) {
    	var m, i, elem, nid, match, groups, newSelector,
    		newContext = context && context.ownerDocument,

    		// nodeType defaults to 9, since context defaults to document
    		nodeType = context ? context.nodeType : 9;

    	results = results || [];

    	// Return early from calls with invalid selector or context
    	if ( typeof selector !== "string" || !selector ||
    		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {

    		return results;
    	}

    	// Try to shortcut find operations (as opposed to filters) in HTML documents
    	if ( !seed ) {

    		if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
    			setDocument( context );
    		}
    		context = context || document;

    		if ( documentIsHTML ) {

    			// If the selector is sufficiently simple, try using a "get*By*" DOM method
    			// (excepting DocumentFragment context, where the methods don't exist)
    			if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {

    				// ID selector
    				if ( (m = match[1]) ) {

    					// Document context
    					if ( nodeType === 9 ) {
    						if ( (elem = context.getElementById( m )) ) {

    							// Support: IE, Opera, Webkit
    							// TODO: identify versions
    							// getElementById can match elements by name instead of ID
    							if ( elem.id === m ) {
    								results.push( elem );
    								return results;
    							}
    						} else {
    							return results;
    						}

    					// Element context
    					} else {

    						// Support: IE, Opera, Webkit
    						// TODO: identify versions
    						// getElementById can match elements by name instead of ID
    						if ( newContext && (elem = newContext.getElementById( m )) &&
    							contains( context, elem ) &&
    							elem.id === m ) {

    							results.push( elem );
    							return results;
    						}
    					}

    				// Type selector
    				} else if ( match[2] ) {
    					push.apply( results, context.getElementsByTagName( selector ) );
    					return results;

    				// Class selector
    				} else if ( (m = match[3]) && support.getElementsByClassName &&
    					context.getElementsByClassName ) {

    					push.apply( results, context.getElementsByClassName( m ) );
    					return results;
    				}
    			}

    			// Take advantage of querySelectorAll
    			if ( support.qsa &&
    				!compilerCache[ selector + " " ] &&
    				(!rbuggyQSA || !rbuggyQSA.test( selector )) ) {

    				if ( nodeType !== 1 ) {
    					newContext = context;
    					newSelector = selector;

    				// qSA looks outside Element context, which is not what we want
    				// Thanks to Andrew Dupont for this workaround technique
    				// Support: IE <=8
    				// Exclude object elements
    				} else if ( context.nodeName.toLowerCase() !== "object" ) {

    					// Capture the context ID, setting it first if necessary
    					if ( (nid = context.getAttribute( "id" )) ) {
    						nid = nid.replace( rcssescape, fcssescape );
    					} else {
    						context.setAttribute( "id", (nid = expando) );
    					}

    					// Prefix every selector in the list
    					groups = tokenize( selector );
    					i = groups.length;
    					while ( i-- ) {
    						groups[i] = "#" + nid + " " + toSelector( groups[i] );
    					}
    					newSelector = groups.join( "," );

    					// Expand context for sibling selectors
    					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
    						context;
    				}

    				if ( newSelector ) {
    					try {
    						push.apply( results,
    							newContext.querySelectorAll( newSelector )
    						);
    						return results;
    					} catch ( qsaError ) {
    					} finally {
    						if ( nid === expando ) {
    							context.removeAttribute( "id" );
    						}
    					}
    				}
    			}
    		}
    	}

    	// All others
    	return select( selector.replace( rtrim, "$1" ), context, results, seed );
    }

    /**
     * Create key-value caches of limited size
     * @returns {function(string, object)} Returns the Object data after storing it on itself with
     *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
     *	deleting the oldest entry
     */
    function createCache() {
    	var keys = [];

    	function cache( key, value ) {
    		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
    		if ( keys.push( key + " " ) > Expr.cacheLength ) {
    			// Only keep the most recent entries
    			delete cache[ keys.shift() ];
    		}
    		return (cache[ key + " " ] = value);
    	}
    	return cache;
    }

    /**
     * Mark a function for special use by Sizzle
     * @param {Function} fn The function to mark
     */
    function markFunction( fn ) {
    	fn[ expando ] = true;
    	return fn;
    }

    /**
     * Support testing using an element
     * @param {Function} fn Passed the created element and returns a boolean result
     */
    function assert( fn ) {
    	var el = document.createElement("fieldset");

    	try {
    		return !!fn( el );
    	} catch (e) {
    		return false;
    	} finally {
    		// Remove from its parent by default
    		if ( el.parentNode ) {
    			el.parentNode.removeChild( el );
    		}
    		// release memory in IE
    		el = null;
    	}
    }

    /**
     * Adds the same handler for all of the specified attrs
     * @param {String} attrs Pipe-separated list of attributes
     * @param {Function} handler The method that will be applied
     */
    function addHandle( attrs, handler ) {
    	var arr = attrs.split("|"),
    		i = arr.length;

    	while ( i-- ) {
    		Expr.attrHandle[ arr[i] ] = handler;
    	}
    }

    /**
     * Checks document order of two siblings
     * @param {Element} a
     * @param {Element} b
     * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
     */
    function siblingCheck( a, b ) {
    	var cur = b && a,
    		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
    			a.sourceIndex - b.sourceIndex;

    	// Use IE sourceIndex if available on both nodes
    	if ( diff ) {
    		return diff;
    	}

    	// Check if b follows a
    	if ( cur ) {
    		while ( (cur = cur.nextSibling) ) {
    			if ( cur === b ) {
    				return -1;
    			}
    		}
    	}

    	return a ? 1 : -1;
    }

    /**
     * Returns a function to use in pseudos for input types
     * @param {String} type
     */
    function createInputPseudo( type ) {
    	return function( elem ) {
    		var name = elem.nodeName.toLowerCase();
    		return name === "input" && elem.type === type;
    	};
    }

    /**
     * Returns a function to use in pseudos for buttons
     * @param {String} type
     */
    function createButtonPseudo( type ) {
    	return function( elem ) {
    		var name = elem.nodeName.toLowerCase();
    		return (name === "input" || name === "button") && elem.type === type;
    	};
    }

    /**
     * Returns a function to use in pseudos for :enabled/:disabled
     * @param {Boolean} disabled true for :disabled; false for :enabled
     */
    function createDisabledPseudo( disabled ) {

    	// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
    	return function( elem ) {

    		// Only certain elements can match :enabled or :disabled
    		// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
    		// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
    		if ( "form" in elem ) {

    			// Check for inherited disabledness on relevant non-disabled elements:
    			// * listed form-associated elements in a disabled fieldset
    			//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
    			//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
    			// * option elements in a disabled optgroup
    			//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
    			// All such elements have a "form" property.
    			if ( elem.parentNode && elem.disabled === false ) {

    				// Option elements defer to a parent optgroup if present
    				if ( "label" in elem ) {
    					if ( "label" in elem.parentNode ) {
    						return elem.parentNode.disabled === disabled;
    					} else {
    						return elem.disabled === disabled;
    					}
    				}

    				// Support: IE 6 - 11
    				// Use the isDisabled shortcut property to check for disabled fieldset ancestors
    				return elem.isDisabled === disabled ||

    					// Where there is no isDisabled, check manually
    					/* jshint -W018 */
    					elem.isDisabled !== !disabled &&
    						disabledAncestor( elem ) === disabled;
    			}

    			return elem.disabled === disabled;

    		// Try to winnow out elements that can't be disabled before trusting the disabled property.
    		// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
    		// even exist on them, let alone have a boolean value.
    		} else if ( "label" in elem ) {
    			return elem.disabled === disabled;
    		}

    		// Remaining elements are neither :enabled nor :disabled
    		return false;
    	};
    }

    /**
     * Returns a function to use in pseudos for positionals
     * @param {Function} fn
     */
    function createPositionalPseudo( fn ) {
    	return markFunction(function( argument ) {
    		argument = +argument;
    		return markFunction(function( seed, matches ) {
    			var j,
    				matchIndexes = fn( [], seed.length, argument ),
    				i = matchIndexes.length;

    			// Match elements found at the specified indexes
    			while ( i-- ) {
    				if ( seed[ (j = matchIndexes[i]) ] ) {
    					seed[j] = !(matches[j] = seed[j]);
    				}
    			}
    		});
    	});
    }

    /**
     * Checks a node for validity as a Sizzle context
     * @param {Element|Object=} context
     * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
     */
    function testContext( context ) {
    	return context && typeof context.getElementsByTagName !== "undefined" && context;
    }

    // Expose support vars for convenience
    support = Sizzle.support = {};

    /**
     * Detects XML nodes
     * @param {Element|Object} elem An element or a document
     * @returns {Boolean} True iff elem is a non-HTML XML node
     */
    isXML = Sizzle.isXML = function( elem ) {
    	// documentElement is verified for cases where it doesn't yet exist
    	// (such as loading iframes in IE - #4833)
    	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
    	return documentElement ? documentElement.nodeName !== "HTML" : false;
    };

    /**
     * Sets document-related variables once based on the current document
     * @param {Element|Object} [doc] An element or document object to use to set the document
     * @returns {Object} Returns the current document
     */
    setDocument = Sizzle.setDocument = function( node ) {
    	var hasCompare, subWindow,
    		doc = node ? node.ownerDocument || node : preferredDoc;

    	// Return early if doc is invalid or already selected
    	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
    		return document;
    	}

    	// Update global variables
    	document = doc;
    	docElem = document.documentElement;
    	documentIsHTML = !isXML( document );

    	// Support: IE 9-11, Edge
    	// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
    	if ( preferredDoc !== document &&
    		(subWindow = document.defaultView) && subWindow.top !== subWindow ) {

    		// Support: IE 11, Edge
    		if ( subWindow.addEventListener ) {
    			subWindow.addEventListener( "unload", unloadHandler, false );

    		// Support: IE 9 - 10 only
    		} else if ( subWindow.attachEvent ) {
    			subWindow.attachEvent( "onunload", unloadHandler );
    		}
    	}

    	/* Attributes
    	---------------------------------------------------------------------- */

    	// Support: IE<8
    	// Verify that getAttribute really returns attributes and not properties
    	// (excepting IE8 booleans)
    	support.attributes = assert(function( el ) {
    		el.className = "i";
    		return !el.getAttribute("className");
    	});

    	/* getElement(s)By*
    	---------------------------------------------------------------------- */

    	// Check if getElementsByTagName("*") returns only elements
    	support.getElementsByTagName = assert(function( el ) {
    		el.appendChild( document.createComment("") );
    		return !el.getElementsByTagName("*").length;
    	});

    	// Support: IE<9
    	support.getElementsByClassName = rnative.test( document.getElementsByClassName );

    	// Support: IE<10
    	// Check if getElementById returns elements by name
    	// The broken getElementById methods don't pick up programmatically-set names,
    	// so use a roundabout getElementsByName test
    	support.getById = assert(function( el ) {
    		docElem.appendChild( el ).id = expando;
    		return !document.getElementsByName || !document.getElementsByName( expando ).length;
    	});

    	// ID filter and find
    	if ( support.getById ) {
    		Expr.filter["ID"] = function( id ) {
    			var attrId = id.replace( runescape, funescape );
    			return function( elem ) {
    				return elem.getAttribute("id") === attrId;
    			};
    		};
    		Expr.find["ID"] = function( id, context ) {
    			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
    				var elem = context.getElementById( id );
    				return elem ? [ elem ] : [];
    			}
    		};
    	} else {
    		Expr.filter["ID"] =  function( id ) {
    			var attrId = id.replace( runescape, funescape );
    			return function( elem ) {
    				var node = typeof elem.getAttributeNode !== "undefined" &&
    					elem.getAttributeNode("id");
    				return node && node.value === attrId;
    			};
    		};

    		// Support: IE 6 - 7 only
    		// getElementById is not reliable as a find shortcut
    		Expr.find["ID"] = function( id, context ) {
    			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
    				var node, i, elems,
    					elem = context.getElementById( id );

    				if ( elem ) {

    					// Verify the id attribute
    					node = elem.getAttributeNode("id");
    					if ( node && node.value === id ) {
    						return [ elem ];
    					}

    					// Fall back on getElementsByName
    					elems = context.getElementsByName( id );
    					i = 0;
    					while ( (elem = elems[i++]) ) {
    						node = elem.getAttributeNode("id");
    						if ( node && node.value === id ) {
    							return [ elem ];
    						}
    					}
    				}

    				return [];
    			}
    		};
    	}

    	// Tag
    	Expr.find["TAG"] = support.getElementsByTagName ?
    		function( tag, context ) {
    			if ( typeof context.getElementsByTagName !== "undefined" ) {
    				return context.getElementsByTagName( tag );

    			// DocumentFragment nodes don't have gEBTN
    			} else if ( support.qsa ) {
    				return context.querySelectorAll( tag );
    			}
    		} :

    		function( tag, context ) {
    			var elem,
    				tmp = [],
    				i = 0,
    				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
    				results = context.getElementsByTagName( tag );

    			// Filter out possible comments
    			if ( tag === "*" ) {
    				while ( (elem = results[i++]) ) {
    					if ( elem.nodeType === 1 ) {
    						tmp.push( elem );
    					}
    				}

    				return tmp;
    			}
    			return results;
    		};

    	// Class
    	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
    		if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
    			return context.getElementsByClassName( className );
    		}
    	};

    	/* QSA/matchesSelector
    	---------------------------------------------------------------------- */

    	// QSA and matchesSelector support

    	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
    	rbuggyMatches = [];

    	// qSa(:focus) reports false when true (Chrome 21)
    	// We allow this because of a bug in IE8/9 that throws an error
    	// whenever `document.activeElement` is accessed on an iframe
    	// So, we allow :focus to pass through QSA all the time to avoid the IE error
    	// See https://bugs.jquery.com/ticket/13378
    	rbuggyQSA = [];

    	if ( (support.qsa = rnative.test( document.querySelectorAll )) ) {
    		// Build QSA regex
    		// Regex strategy adopted from Diego Perini
    		assert(function( el ) {
    			// Select is set to empty string on purpose
    			// This is to test IE's treatment of not explicitly
    			// setting a boolean content attribute,
    			// since its presence should be enough
    			// https://bugs.jquery.com/ticket/12359
    			docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
    				"<select id='" + expando + "-\r\\' msallowcapture=''>" +
    				"<option selected=''></option></select>";

    			// Support: IE8, Opera 11-12.16
    			// Nothing should be selected when empty strings follow ^= or $= or *=
    			// The test attribute must be unknown in Opera but "safe" for WinRT
    			// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
    			if ( el.querySelectorAll("[msallowcapture^='']").length ) {
    				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
    			}

    			// Support: IE8
    			// Boolean attributes and "value" are not treated correctly
    			if ( !el.querySelectorAll("[selected]").length ) {
    				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
    			}

    			// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
    			if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
    				rbuggyQSA.push("~=");
    			}

    			// Webkit/Opera - :checked should return selected option elements
    			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
    			// IE8 throws error here and will not see later tests
    			if ( !el.querySelectorAll(":checked").length ) {
    				rbuggyQSA.push(":checked");
    			}

    			// Support: Safari 8+, iOS 8+
    			// https://bugs.webkit.org/show_bug.cgi?id=136851
    			// In-page `selector#id sibling-combinator selector` fails
    			if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
    				rbuggyQSA.push(".#.+[+~]");
    			}
    		});

    		assert(function( el ) {
    			el.innerHTML = "<a href='' disabled='disabled'></a>" +
    				"<select disabled='disabled'><option/></select>";

    			// Support: Windows 8 Native Apps
    			// The type and name attributes are restricted during .innerHTML assignment
    			var input = document.createElement("input");
    			input.setAttribute( "type", "hidden" );
    			el.appendChild( input ).setAttribute( "name", "D" );

    			// Support: IE8
    			// Enforce case-sensitivity of name attribute
    			if ( el.querySelectorAll("[name=d]").length ) {
    				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
    			}

    			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
    			// IE8 throws error here and will not see later tests
    			if ( el.querySelectorAll(":enabled").length !== 2 ) {
    				rbuggyQSA.push( ":enabled", ":disabled" );
    			}

    			// Support: IE9-11+
    			// IE's :disabled selector does not pick up the children of disabled fieldsets
    			docElem.appendChild( el ).disabled = true;
    			if ( el.querySelectorAll(":disabled").length !== 2 ) {
    				rbuggyQSA.push( ":enabled", ":disabled" );
    			}

    			// Opera 10-11 does not throw on post-comma invalid pseudos
    			el.querySelectorAll("*,:x");
    			rbuggyQSA.push(",.*:");
    		});
    	}

    	if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
    		docElem.webkitMatchesSelector ||
    		docElem.mozMatchesSelector ||
    		docElem.oMatchesSelector ||
    		docElem.msMatchesSelector) )) ) {

    		assert(function( el ) {
    			// Check to see if it's possible to do matchesSelector
    			// on a disconnected node (IE 9)
    			support.disconnectedMatch = matches.call( el, "*" );

    			// This should fail with an exception
    			// Gecko does not error, returns false instead
    			matches.call( el, "[s!='']:x" );
    			rbuggyMatches.push( "!=", pseudos );
    		});
    	}

    	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
    	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );

    	/* Contains
    	---------------------------------------------------------------------- */
    	hasCompare = rnative.test( docElem.compareDocumentPosition );

    	// Element contains another
    	// Purposefully self-exclusive
    	// As in, an element does not contain itself
    	contains = hasCompare || rnative.test( docElem.contains ) ?
    		function( a, b ) {
    			var adown = a.nodeType === 9 ? a.documentElement : a,
    				bup = b && b.parentNode;
    			return a === bup || !!( bup && bup.nodeType === 1 && (
    				adown.contains ?
    					adown.contains( bup ) :
    					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
    			));
    		} :
    		function( a, b ) {
    			if ( b ) {
    				while ( (b = b.parentNode) ) {
    					if ( b === a ) {
    						return true;
    					}
    				}
    			}
    			return false;
    		};

    	/* Sorting
    	---------------------------------------------------------------------- */

    	// Document order sorting
    	sortOrder = hasCompare ?
    	function( a, b ) {

    		// Flag for duplicate removal
    		if ( a === b ) {
    			hasDuplicate = true;
    			return 0;
    		}

    		// Sort on method existence if only one input has compareDocumentPosition
    		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
    		if ( compare ) {
    			return compare;
    		}

    		// Calculate position if both inputs belong to the same document
    		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
    			a.compareDocumentPosition( b ) :

    			// Otherwise we know they are disconnected
    			1;

    		// Disconnected nodes
    		if ( compare & 1 ||
    			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {

    			// Choose the first element that is related to our preferred document
    			if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
    				return -1;
    			}
    			if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
    				return 1;
    			}

    			// Maintain original order
    			return sortInput ?
    				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
    				0;
    		}

    		return compare & 4 ? -1 : 1;
    	} :
    	function( a, b ) {
    		// Exit early if the nodes are identical
    		if ( a === b ) {
    			hasDuplicate = true;
    			return 0;
    		}

    		var cur,
    			i = 0,
    			aup = a.parentNode,
    			bup = b.parentNode,
    			ap = [ a ],
    			bp = [ b ];

    		// Parentless nodes are either documents or disconnected
    		if ( !aup || !bup ) {
    			return a === document ? -1 :
    				b === document ? 1 :
    				aup ? -1 :
    				bup ? 1 :
    				sortInput ?
    				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
    				0;

    		// If the nodes are siblings, we can do a quick check
    		} else if ( aup === bup ) {
    			return siblingCheck( a, b );
    		}

    		// Otherwise we need full lists of their ancestors for comparison
    		cur = a;
    		while ( (cur = cur.parentNode) ) {
    			ap.unshift( cur );
    		}
    		cur = b;
    		while ( (cur = cur.parentNode) ) {
    			bp.unshift( cur );
    		}

    		// Walk down the tree looking for a discrepancy
    		while ( ap[i] === bp[i] ) {
    			i++;
    		}

    		return i ?
    			// Do a sibling check if the nodes have a common ancestor
    			siblingCheck( ap[i], bp[i] ) :

    			// Otherwise nodes in our document sort first
    			ap[i] === preferredDoc ? -1 :
    			bp[i] === preferredDoc ? 1 :
    			0;
    	};

    	return document;
    };

    Sizzle.matches = function( expr, elements ) {
    	return Sizzle( expr, null, null, elements );
    };

    Sizzle.matchesSelector = function( elem, expr ) {
    	// Set document vars if needed
    	if ( ( elem.ownerDocument || elem ) !== document ) {
    		setDocument( elem );
    	}

    	// Make sure that attribute selectors are quoted
    	expr = expr.replace( rattributeQuotes, "='$1']" );

    	if ( support.matchesSelector && documentIsHTML &&
    		!compilerCache[ expr + " " ] &&
    		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
    		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {

    		try {
    			var ret = matches.call( elem, expr );

    			// IE 9's matchesSelector returns false on disconnected nodes
    			if ( ret || support.disconnectedMatch ||
    					// As well, disconnected nodes are said to be in a document
    					// fragment in IE 9
    					elem.document && elem.document.nodeType !== 11 ) {
    				return ret;
    			}
    		} catch (e) {}
    	}

    	return Sizzle( expr, document, null, [ elem ] ).length > 0;
    };

    Sizzle.contains = function( context, elem ) {
    	// Set document vars if needed
    	if ( ( context.ownerDocument || context ) !== document ) {
    		setDocument( context );
    	}
    	return contains( context, elem );
    };

    Sizzle.attr = function( elem, name ) {
    	// Set document vars if needed
    	if ( ( elem.ownerDocument || elem ) !== document ) {
    		setDocument( elem );
    	}

    	var fn = Expr.attrHandle[ name.toLowerCase() ],
    		// Don't get fooled by Object.prototype properties (jQuery #13807)
    		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
    			fn( elem, name, !documentIsHTML ) :
    			undefined;

    	return val !== undefined ?
    		val :
    		support.attributes || !documentIsHTML ?
    			elem.getAttribute( name ) :
    			(val = elem.getAttributeNode(name)) && val.specified ?
    				val.value :
    				null;
    };

    Sizzle.escape = function( sel ) {
    	return (sel + "").replace( rcssescape, fcssescape );
    };

    Sizzle.error = function( msg ) {
    	throw new Error( "Syntax error, unrecognized expression: " + msg );
    };

    /**
     * Document sorting and removing duplicates
     * @param {ArrayLike} results
     */
    Sizzle.uniqueSort = function( results ) {
    	var elem,
    		duplicates = [],
    		j = 0,
    		i = 0;

    	// Unless we *know* we can detect duplicates, assume their presence
    	hasDuplicate = !support.detectDuplicates;
    	sortInput = !support.sortStable && results.slice( 0 );
    	results.sort( sortOrder );

    	if ( hasDuplicate ) {
    		while ( (elem = results[i++]) ) {
    			if ( elem === results[ i ] ) {
    				j = duplicates.push( i );
    			}
    		}
    		while ( j-- ) {
    			results.splice( duplicates[ j ], 1 );
    		}
    	}

    	// Clear input after sorting to release objects
    	// See https://github.com/jquery/sizzle/pull/225
    	sortInput = null;

    	return results;
    };

    /**
     * Utility function for retrieving the text value of an array of DOM nodes
     * @param {Array|Element} elem
     */
    getText = Sizzle.getText = function( elem ) {
    	var node,
    		ret = "",
    		i = 0,
    		nodeType = elem.nodeType;

    	if ( !nodeType ) {
    		// If no nodeType, this is expected to be an array
    		while ( (node = elem[i++]) ) {
    			// Do not traverse comment nodes
    			ret += getText( node );
    		}
    	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
    		// Use textContent for elements
    		// innerText usage removed for consistency of new lines (jQuery #11153)
    		if ( typeof elem.textContent === "string" ) {
    			return elem.textContent;
    		} else {
    			// Traverse its children
    			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
    				ret += getText( elem );
    			}
    		}
    	} else if ( nodeType === 3 || nodeType === 4 ) {
    		return elem.nodeValue;
    	}
    	// Do not include comment or processing instruction nodes

    	return ret;
    };

    Expr = Sizzle.selectors = {

    	// Can be adjusted by the user
    	cacheLength: 50,

    	createPseudo: markFunction,

    	match: matchExpr,

    	attrHandle: {},

    	find: {},

    	relative: {
    		">": { dir: "parentNode", first: true },
    		" ": { dir: "parentNode" },
    		"+": { dir: "previousSibling", first: true },
    		"~": { dir: "previousSibling" }
    	},

    	preFilter: {
    		"ATTR": function( match ) {
    			match[1] = match[1].replace( runescape, funescape );

    			// Move the given value to match[3] whether quoted or unquoted
    			match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );

    			if ( match[2] === "~=" ) {
    				match[3] = " " + match[3] + " ";
    			}

    			return match.slice( 0, 4 );
    		},

    		"CHILD": function( match ) {
    			/* matches from matchExpr["CHILD"]
    				1 type (only|nth|...)
    				2 what (child|of-type)
    				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
    				4 xn-component of xn+y argument ([+-]?\d*n|)
    				5 sign of xn-component
    				6 x of xn-component
    				7 sign of y-component
    				8 y of y-component
    			*/
    			match[1] = match[1].toLowerCase();

    			if ( match[1].slice( 0, 3 ) === "nth" ) {
    				// nth-* requires argument
    				if ( !match[3] ) {
    					Sizzle.error( match[0] );
    				}

    				// numeric x and y parameters for Expr.filter.CHILD
    				// remember that false/true cast respectively to 0/1
    				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
    				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );

    			// other types prohibit arguments
    			} else if ( match[3] ) {
    				Sizzle.error( match[0] );
    			}

    			return match;
    		},

    		"PSEUDO": function( match ) {
    			var excess,
    				unquoted = !match[6] && match[2];

    			if ( matchExpr["CHILD"].test( match[0] ) ) {
    				return null;
    			}

    			// Accept quoted arguments as-is
    			if ( match[3] ) {
    				match[2] = match[4] || match[5] || "";

    			// Strip excess characters from unquoted arguments
    			} else if ( unquoted && rpseudo.test( unquoted ) &&
    				// Get excess from tokenize (recursively)
    				(excess = tokenize( unquoted, true )) &&
    				// advance to the next closing parenthesis
    				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {

    				// excess is a negative index
    				match[0] = match[0].slice( 0, excess );
    				match[2] = unquoted.slice( 0, excess );
    			}

    			// Return only captures needed by the pseudo filter method (type and argument)
    			return match.slice( 0, 3 );
    		}
    	},

    	filter: {

    		"TAG": function( nodeNameSelector ) {
    			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
    			return nodeNameSelector === "*" ?
    				function() { return true; } :
    				function( elem ) {
    					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
    				};
    		},

    		"CLASS": function( className ) {
    			var pattern = classCache[ className + " " ];

    			return pattern ||
    				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
    				classCache( className, function( elem ) {
    					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
    				});
    		},

    		"ATTR": function( name, operator, check ) {
    			return function( elem ) {
    				var result = Sizzle.attr( elem, name );

    				if ( result == null ) {
    					return operator === "!=";
    				}
    				if ( !operator ) {
    					return true;
    				}

    				result += "";

    				return operator === "=" ? result === check :
    					operator === "!=" ? result !== check :
    					operator === "^=" ? check && result.indexOf( check ) === 0 :
    					operator === "*=" ? check && result.indexOf( check ) > -1 :
    					operator === "$=" ? check && result.slice( -check.length ) === check :
    					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
    					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
    					false;
    			};
    		},

    		"CHILD": function( type, what, argument, first, last ) {
    			var simple = type.slice( 0, 3 ) !== "nth",
    				forward = type.slice( -4 ) !== "last",
    				ofType = what === "of-type";

    			return first === 1 && last === 0 ?

    				// Shortcut for :nth-*(n)
    				function( elem ) {
    					return !!elem.parentNode;
    				} :

    				function( elem, context, xml ) {
    					var cache, uniqueCache, outerCache, node, nodeIndex, start,
    						dir = simple !== forward ? "nextSibling" : "previousSibling",
    						parent = elem.parentNode,
    						name = ofType && elem.nodeName.toLowerCase(),
    						useCache = !xml && !ofType,
    						diff = false;

    					if ( parent ) {

    						// :(first|last|only)-(child|of-type)
    						if ( simple ) {
    							while ( dir ) {
    								node = elem;
    								while ( (node = node[ dir ]) ) {
    									if ( ofType ?
    										node.nodeName.toLowerCase() === name :
    										node.nodeType === 1 ) {

    										return false;
    									}
    								}
    								// Reverse direction for :only-* (if we haven't yet done so)
    								start = dir = type === "only" && !start && "nextSibling";
    							}
    							return true;
    						}

    						start = [ forward ? parent.firstChild : parent.lastChild ];

    						// non-xml :nth-child(...) stores cache data on `parent`
    						if ( forward && useCache ) {

    							// Seek `elem` from a previously-cached index

    							// ...in a gzip-friendly way
    							node = parent;
    							outerCache = node[ expando ] || (node[ expando ] = {});

    							// Support: IE <9 only
    							// Defend against cloned attroperties (jQuery gh-1709)
    							uniqueCache = outerCache[ node.uniqueID ] ||
    								(outerCache[ node.uniqueID ] = {});

    							cache = uniqueCache[ type ] || [];
    							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
    							diff = nodeIndex && cache[ 2 ];
    							node = nodeIndex && parent.childNodes[ nodeIndex ];

    							while ( (node = ++nodeIndex && node && node[ dir ] ||

    								// Fallback to seeking `elem` from the start
    								(diff = nodeIndex = 0) || start.pop()) ) {

    								// When found, cache indexes on `parent` and break
    								if ( node.nodeType === 1 && ++diff && node === elem ) {
    									uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
    									break;
    								}
    							}

    						} else {
    							// Use previously-cached element index if available
    							if ( useCache ) {
    								// ...in a gzip-friendly way
    								node = elem;
    								outerCache = node[ expando ] || (node[ expando ] = {});

    								// Support: IE <9 only
    								// Defend against cloned attroperties (jQuery gh-1709)
    								uniqueCache = outerCache[ node.uniqueID ] ||
    									(outerCache[ node.uniqueID ] = {});

    								cache = uniqueCache[ type ] || [];
    								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
    								diff = nodeIndex;
    							}

    							// xml :nth-child(...)
    							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
    							if ( diff === false ) {
    								// Use the same loop as above to seek `elem` from the start
    								while ( (node = ++nodeIndex && node && node[ dir ] ||
    									(diff = nodeIndex = 0) || start.pop()) ) {

    									if ( ( ofType ?
    										node.nodeName.toLowerCase() === name :
    										node.nodeType === 1 ) &&
    										++diff ) {

    										// Cache the index of each encountered element
    										if ( useCache ) {
    											outerCache = node[ expando ] || (node[ expando ] = {});

    											// Support: IE <9 only
    											// Defend against cloned attroperties (jQuery gh-1709)
    											uniqueCache = outerCache[ node.uniqueID ] ||
    												(outerCache[ node.uniqueID ] = {});

    											uniqueCache[ type ] = [ dirruns, diff ];
    										}

    										if ( node === elem ) {
    											break;
    										}
    									}
    								}
    							}
    						}

    						// Incorporate the offset, then check against cycle size
    						diff -= last;
    						return diff === first || ( diff % first === 0 && diff / first >= 0 );
    					}
    				};
    		},

    		"PSEUDO": function( pseudo, argument ) {
    			// pseudo-class names are case-insensitive
    			// http://www.w3.org/TR/selectors/#pseudo-classes
    			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
    			// Remember that setFilters inherits from pseudos
    			var args,
    				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
    					Sizzle.error( "unsupported pseudo: " + pseudo );

    			// The user may use createPseudo to indicate that
    			// arguments are needed to create the filter function
    			// just as Sizzle does
    			if ( fn[ expando ] ) {
    				return fn( argument );
    			}

    			// But maintain support for old signatures
    			if ( fn.length > 1 ) {
    				args = [ pseudo, pseudo, "", argument ];
    				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
    					markFunction(function( seed, matches ) {
    						var idx,
    							matched = fn( seed, argument ),
    							i = matched.length;
    						while ( i-- ) {
    							idx = indexOf( seed, matched[i] );
    							seed[ idx ] = !( matches[ idx ] = matched[i] );
    						}
    					}) :
    					function( elem ) {
    						return fn( elem, 0, args );
    					};
    			}

    			return fn;
    		}
    	},

    	pseudos: {
    		// Potentially complex pseudos
    		"not": markFunction(function( selector ) {
    			// Trim the selector passed to compile
    			// to avoid treating leading and trailing
    			// spaces as combinators
    			var input = [],
    				results = [],
    				matcher = compile( selector.replace( rtrim, "$1" ) );

    			return matcher[ expando ] ?
    				markFunction(function( seed, matches, context, xml ) {
    					var elem,
    						unmatched = matcher( seed, null, xml, [] ),
    						i = seed.length;

    					// Match elements unmatched by `matcher`
    					while ( i-- ) {
    						if ( (elem = unmatched[i]) ) {
    							seed[i] = !(matches[i] = elem);
    						}
    					}
    				}) :
    				function( elem, context, xml ) {
    					input[0] = elem;
    					matcher( input, null, xml, results );
    					// Don't keep the element (issue #299)
    					input[0] = null;
    					return !results.pop();
    				};
    		}),

    		"has": markFunction(function( selector ) {
    			return function( elem ) {
    				return Sizzle( selector, elem ).length > 0;
    			};
    		}),

    		"contains": markFunction(function( text ) {
    			text = text.replace( runescape, funescape );
    			return function( elem ) {
    				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
    			};
    		}),

    		// "Whether an element is represented by a :lang() selector
    		// is based solely on the element's language value
    		// being equal to the identifier C,
    		// or beginning with the identifier C immediately followed by "-".
    		// The matching of C against the element's language value is performed case-insensitively.
    		// The identifier C does not have to be a valid language name."
    		// http://www.w3.org/TR/selectors/#lang-pseudo
    		"lang": markFunction( function( lang ) {
    			// lang value must be a valid identifier
    			if ( !ridentifier.test(lang || "") ) {
    				Sizzle.error( "unsupported lang: " + lang );
    			}
    			lang = lang.replace( runescape, funescape ).toLowerCase();
    			return function( elem ) {
    				var elemLang;
    				do {
    					if ( (elemLang = documentIsHTML ?
    						elem.lang :
    						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {

    						elemLang = elemLang.toLowerCase();
    						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
    					}
    				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
    				return false;
    			};
    		}),

    		// Miscellaneous
    		"target": function( elem ) {
    			var hash = window.location && window.location.hash;
    			return hash && hash.slice( 1 ) === elem.id;
    		},

    		"root": function( elem ) {
    			return elem === docElem;
    		},

    		"focus": function( elem ) {
    			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
    		},

    		// Boolean properties
    		"enabled": createDisabledPseudo( false ),
    		"disabled": createDisabledPseudo( true ),

    		"checked": function( elem ) {
    			// In CSS3, :checked should return both checked and selected elements
    			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
    			var nodeName = elem.nodeName.toLowerCase();
    			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
    		},

    		"selected": function( elem ) {
    			// Accessing this property makes selected-by-default
    			// options in Safari work properly
    			if ( elem.parentNode ) {
    				elem.parentNode.selectedIndex;
    			}

    			return elem.selected === true;
    		},

    		// Contents
    		"empty": function( elem ) {
    			// http://www.w3.org/TR/selectors/#empty-pseudo
    			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
    			//   but not by others (comment: 8; processing instruction: 7; etc.)
    			// nodeType < 6 works because attributes (2) do not appear as children
    			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
    				if ( elem.nodeType < 6 ) {
    					return false;
    				}
    			}
    			return true;
    		},

    		"parent": function( elem ) {
    			return !Expr.pseudos["empty"]( elem );
    		},

    		// Element/input types
    		"header": function( elem ) {
    			return rheader.test( elem.nodeName );
    		},

    		"input": function( elem ) {
    			return rinputs.test( elem.nodeName );
    		},

    		"button": function( elem ) {
    			var name = elem.nodeName.toLowerCase();
    			return name === "input" && elem.type === "button" || name === "button";
    		},

    		"text": function( elem ) {
    			var attr;
    			return elem.nodeName.toLowerCase() === "input" &&
    				elem.type === "text" &&

    				// Support: IE<8
    				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
    				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
    		},

    		// Position-in-collection
    		"first": createPositionalPseudo(function() {
    			return [ 0 ];
    		}),

    		"last": createPositionalPseudo(function( matchIndexes, length ) {
    			return [ length - 1 ];
    		}),

    		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
    			return [ argument < 0 ? argument + length : argument ];
    		}),

    		"even": createPositionalPseudo(function( matchIndexes, length ) {
    			var i = 0;
    			for ( ; i < length; i += 2 ) {
    				matchIndexes.push( i );
    			}
    			return matchIndexes;
    		}),

    		"odd": createPositionalPseudo(function( matchIndexes, length ) {
    			var i = 1;
    			for ( ; i < length; i += 2 ) {
    				matchIndexes.push( i );
    			}
    			return matchIndexes;
    		}),

    		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
    			var i = argument < 0 ? argument + length : argument;
    			for ( ; --i >= 0; ) {
    				matchIndexes.push( i );
    			}
    			return matchIndexes;
    		}),

    		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
    			var i = argument < 0 ? argument + length : argument;
    			for ( ; ++i < length; ) {
    				matchIndexes.push( i );
    			}
    			return matchIndexes;
    		})
    	}
    };

    Expr.pseudos["nth"] = Expr.pseudos["eq"];

    // Add button/input type pseudos
    for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
    	Expr.pseudos[ i ] = createInputPseudo( i );
    }
    for ( i in { submit: true, reset: true } ) {
    	Expr.pseudos[ i ] = createButtonPseudo( i );
    }

    // Easy API for creating new setFilters
    function setFilters() {}
    setFilters.prototype = Expr.filters = Expr.pseudos;
    Expr.setFilters = new setFilters();

    tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
    	var matched, match, tokens, type,
    		soFar, groups, preFilters,
    		cached = tokenCache[ selector + " " ];

    	if ( cached ) {
    		return parseOnly ? 0 : cached.slice( 0 );
    	}

    	soFar = selector;
    	groups = [];
    	preFilters = Expr.preFilter;

    	while ( soFar ) {

    		// Comma and first run
    		if ( !matched || (match = rcomma.exec( soFar )) ) {
    			if ( match ) {
    				// Don't consume trailing commas as valid
    				soFar = soFar.slice( match[0].length ) || soFar;
    			}
    			groups.push( (tokens = []) );
    		}

    		matched = false;

    		// Combinators
    		if ( (match = rcombinators.exec( soFar )) ) {
    			matched = match.shift();
    			tokens.push({
    				value: matched,
    				// Cast descendant combinators to space
    				type: match[0].replace( rtrim, " " )
    			});
    			soFar = soFar.slice( matched.length );
    		}

    		// Filters
    		for ( type in Expr.filter ) {
    			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
    				(match = preFilters[ type ]( match ))) ) {
    				matched = match.shift();
    				tokens.push({
    					value: matched,
    					type: type,
    					matches: match
    				});
    				soFar = soFar.slice( matched.length );
    			}
    		}

    		if ( !matched ) {
    			break;
    		}
    	}

    	// Return the length of the invalid excess
    	// if we're just parsing
    	// Otherwise, throw an error or return tokens
    	return parseOnly ?
    		soFar.length :
    		soFar ?
    			Sizzle.error( selector ) :
    			// Cache the tokens
    			tokenCache( selector, groups ).slice( 0 );
    };

    function toSelector( tokens ) {
    	var i = 0,
    		len = tokens.length,
    		selector = "";
    	for ( ; i < len; i++ ) {
    		selector += tokens[i].value;
    	}
    	return selector;
    }

    function addCombinator( matcher, combinator, base ) {
    	var dir = combinator.dir,
    		skip = combinator.next,
    		key = skip || dir,
    		checkNonElements = base && key === "parentNode",
    		doneName = done++;

    	return combinator.first ?
    		// Check against closest ancestor/preceding element
    		function( elem, context, xml ) {
    			while ( (elem = elem[ dir ]) ) {
    				if ( elem.nodeType === 1 || checkNonElements ) {
    					return matcher( elem, context, xml );
    				}
    			}
    			return false;
    		} :

    		// Check against all ancestor/preceding elements
    		function( elem, context, xml ) {
    			var oldCache, uniqueCache, outerCache,
    				newCache = [ dirruns, doneName ];

    			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
    			if ( xml ) {
    				while ( (elem = elem[ dir ]) ) {
    					if ( elem.nodeType === 1 || checkNonElements ) {
    						if ( matcher( elem, context, xml ) ) {
    							return true;
    						}
    					}
    				}
    			} else {
    				while ( (elem = elem[ dir ]) ) {
    					if ( elem.nodeType === 1 || checkNonElements ) {
    						outerCache = elem[ expando ] || (elem[ expando ] = {});

    						// Support: IE <9 only
    						// Defend against cloned attroperties (jQuery gh-1709)
    						uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});

    						if ( skip && skip === elem.nodeName.toLowerCase() ) {
    							elem = elem[ dir ] || elem;
    						} else if ( (oldCache = uniqueCache[ key ]) &&
    							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {

    							// Assign to newCache so results back-propagate to previous elements
    							return (newCache[ 2 ] = oldCache[ 2 ]);
    						} else {
    							// Reuse newcache so results back-propagate to previous elements
    							uniqueCache[ key ] = newCache;

    							// A match means we're done; a fail means we have to keep checking
    							if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
    								return true;
    							}
    						}
    					}
    				}
    			}
    			return false;
    		};
    }

    function elementMatcher( matchers ) {
    	return matchers.length > 1 ?
    		function( elem, context, xml ) {
    			var i = matchers.length;
    			while ( i-- ) {
    				if ( !matchers[i]( elem, context, xml ) ) {
    					return false;
    				}
    			}
    			return true;
    		} :
    		matchers[0];
    }

    function multipleContexts( selector, contexts, results ) {
    	var i = 0,
    		len = contexts.length;
    	for ( ; i < len; i++ ) {
    		Sizzle( selector, contexts[i], results );
    	}
    	return results;
    }

    function condense( unmatched, map, filter, context, xml ) {
    	var elem,
    		newUnmatched = [],
    		i = 0,
    		len = unmatched.length,
    		mapped = map != null;

    	for ( ; i < len; i++ ) {
    		if ( (elem = unmatched[i]) ) {
    			if ( !filter || filter( elem, context, xml ) ) {
    				newUnmatched.push( elem );
    				if ( mapped ) {
    					map.push( i );
    				}
    			}
    		}
    	}

    	return newUnmatched;
    }

    function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
    	if ( postFilter && !postFilter[ expando ] ) {
    		postFilter = setMatcher( postFilter );
    	}
    	if ( postFinder && !postFinder[ expando ] ) {
    		postFinder = setMatcher( postFinder, postSelector );
    	}
    	return markFunction(function( seed, results, context, xml ) {
    		var temp, i, elem,
    			preMap = [],
    			postMap = [],
    			preexisting = results.length,

    			// Get initial elements from seed or context
    			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),

    			// Prefilter to get matcher input, preserving a map for seed-results synchronization
    			matcherIn = preFilter && ( seed || !selector ) ?
    				condense( elems, preMap, preFilter, context, xml ) :
    				elems,

    			matcherOut = matcher ?
    				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
    				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?

    					// ...intermediate processing is necessary
    					[] :

    					// ...otherwise use results directly
    					results :
    				matcherIn;

    		// Find primary matches
    		if ( matcher ) {
    			matcher( matcherIn, matcherOut, context, xml );
    		}

    		// Apply postFilter
    		if ( postFilter ) {
    			temp = condense( matcherOut, postMap );
    			postFilter( temp, [], context, xml );

    			// Un-match failing elements by moving them back to matcherIn
    			i = temp.length;
    			while ( i-- ) {
    				if ( (elem = temp[i]) ) {
    					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
    				}
    			}
    		}

    		if ( seed ) {
    			if ( postFinder || preFilter ) {
    				if ( postFinder ) {
    					// Get the final matcherOut by condensing this intermediate into postFinder contexts
    					temp = [];
    					i = matcherOut.length;
    					while ( i-- ) {
    						if ( (elem = matcherOut[i]) ) {
    							// Restore matcherIn since elem is not yet a final match
    							temp.push( (matcherIn[i] = elem) );
    						}
    					}
    					postFinder( null, (matcherOut = []), temp, xml );
    				}

    				// Move matched elements from seed to results to keep them synchronized
    				i = matcherOut.length;
    				while ( i-- ) {
    					if ( (elem = matcherOut[i]) &&
    						(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {

    						seed[temp] = !(results[temp] = elem);
    					}
    				}
    			}

    		// Add elements to results, through postFinder if defined
    		} else {
    			matcherOut = condense(
    				matcherOut === results ?
    					matcherOut.splice( preexisting, matcherOut.length ) :
    					matcherOut
    			);
    			if ( postFinder ) {
    				postFinder( null, results, matcherOut, xml );
    			} else {
    				push.apply( results, matcherOut );
    			}
    		}
    	});
    }

    function matcherFromTokens( tokens ) {
    	var checkContext, matcher, j,
    		len = tokens.length,
    		leadingRelative = Expr.relative[ tokens[0].type ],
    		implicitRelative = leadingRelative || Expr.relative[" "],
    		i = leadingRelative ? 1 : 0,

    		// The foundational matcher ensures that elements are reachable from top-level context(s)
    		matchContext = addCombinator( function( elem ) {
    			return elem === checkContext;
    		}, implicitRelative, true ),
    		matchAnyContext = addCombinator( function( elem ) {
    			return indexOf( checkContext, elem ) > -1;
    		}, implicitRelative, true ),
    		matchers = [ function( elem, context, xml ) {
    			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
    				(checkContext = context).nodeType ?
    					matchContext( elem, context, xml ) :
    					matchAnyContext( elem, context, xml ) );
    			// Avoid hanging onto element (issue #299)
    			checkContext = null;
    			return ret;
    		} ];

    	for ( ; i < len; i++ ) {
    		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
    			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
    		} else {
    			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );

    			// Return special upon seeing a positional matcher
    			if ( matcher[ expando ] ) {
    				// Find the next relative operator (if any) for proper handling
    				j = ++i;
    				for ( ; j < len; j++ ) {
    					if ( Expr.relative[ tokens[j].type ] ) {
    						break;
    					}
    				}
    				return setMatcher(
    					i > 1 && elementMatcher( matchers ),
    					i > 1 && toSelector(
    						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
    						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
    					).replace( rtrim, "$1" ),
    					matcher,
    					i < j && matcherFromTokens( tokens.slice( i, j ) ),
    					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
    					j < len && toSelector( tokens )
    				);
    			}
    			matchers.push( matcher );
    		}
    	}

    	return elementMatcher( matchers );
    }

    function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
    	var bySet = setMatchers.length > 0,
    		byElement = elementMatchers.length > 0,
    		superMatcher = function( seed, context, xml, results, outermost ) {
    			var elem, j, matcher,
    				matchedCount = 0,
    				i = "0",
    				unmatched = seed && [],
    				setMatched = [],
    				contextBackup = outermostContext,
    				// We must always have either seed elements or outermost context
    				elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
    				// Use integer dirruns iff this is the outermost matcher
    				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
    				len = elems.length;

    			if ( outermost ) {
    				outermostContext = context === document || context || outermost;
    			}

    			// Add elements passing elementMatchers directly to results
    			// Support: IE<9, Safari
    			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
    			for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
    				if ( byElement && elem ) {
    					j = 0;
    					if ( !context && elem.ownerDocument !== document ) {
    						setDocument( elem );
    						xml = !documentIsHTML;
    					}
    					while ( (matcher = elementMatchers[j++]) ) {
    						if ( matcher( elem, context || document, xml) ) {
    							results.push( elem );
    							break;
    						}
    					}
    					if ( outermost ) {
    						dirruns = dirrunsUnique;
    					}
    				}

    				// Track unmatched elements for set filters
    				if ( bySet ) {
    					// They will have gone through all possible matchers
    					if ( (elem = !matcher && elem) ) {
    						matchedCount--;
    					}

    					// Lengthen the array for every element, matched or not
    					if ( seed ) {
    						unmatched.push( elem );
    					}
    				}
    			}

    			// `i` is now the count of elements visited above, and adding it to `matchedCount`
    			// makes the latter nonnegative.
    			matchedCount += i;

    			// Apply set filters to unmatched elements
    			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
    			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
    			// no element matchers and no seed.
    			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
    			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
    			// numerically zero.
    			if ( bySet && i !== matchedCount ) {
    				j = 0;
    				while ( (matcher = setMatchers[j++]) ) {
    					matcher( unmatched, setMatched, context, xml );
    				}

    				if ( seed ) {
    					// Reintegrate element matches to eliminate the need for sorting
    					if ( matchedCount > 0 ) {
    						while ( i-- ) {
    							if ( !(unmatched[i] || setMatched[i]) ) {
    								setMatched[i] = pop.call( results );
    							}
    						}
    					}

    					// Discard index placeholder values to get only actual matches
    					setMatched = condense( setMatched );
    				}

    				// Add matches to results
    				push.apply( results, setMatched );

    				// Seedless set matches succeeding multiple successful matchers stipulate sorting
    				if ( outermost && !seed && setMatched.length > 0 &&
    					( matchedCount + setMatchers.length ) > 1 ) {

    					Sizzle.uniqueSort( results );
    				}
    			}

    			// Override manipulation of globals by nested matchers
    			if ( outermost ) {
    				dirruns = dirrunsUnique;
    				outermostContext = contextBackup;
    			}

    			return unmatched;
    		};

    	return bySet ?
    		markFunction( superMatcher ) :
    		superMatcher;
    }

    compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
    	var i,
    		setMatchers = [],
    		elementMatchers = [],
    		cached = compilerCache[ selector + " " ];

    	if ( !cached ) {
    		// Generate a function of recursive functions that can be used to check each element
    		if ( !match ) {
    			match = tokenize( selector );
    		}
    		i = match.length;
    		while ( i-- ) {
    			cached = matcherFromTokens( match[i] );
    			if ( cached[ expando ] ) {
    				setMatchers.push( cached );
    			} else {
    				elementMatchers.push( cached );
    			}
    		}

    		// Cache the compiled function
    		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );

    		// Save selector and tokenization
    		cached.selector = selector;
    	}
    	return cached;
    };

    /**
     * A low-level selection function that works with Sizzle's compiled
     *  selector functions
     * @param {String|Function} selector A selector or a pre-compiled
     *  selector function built with Sizzle.compile
     * @param {Element} context
     * @param {Array} [results]
     * @param {Array} [seed] A set of elements to match against
     */
    select = Sizzle.select = function( selector, context, results, seed ) {
    	var i, tokens, token, type, find,
    		compiled = typeof selector === "function" && selector,
    		match = !seed && tokenize( (selector = compiled.selector || selector) );

    	results = results || [];

    	// Try to minimize operations if there is only one selector in the list and no seed
    	// (the latter of which guarantees us context)
    	if ( match.length === 1 ) {

    		// Reduce context if the leading compound selector is an ID
    		tokens = match[0] = match[0].slice( 0 );
    		if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
    				context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) {

    			context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
    			if ( !context ) {
    				return results;

    			// Precompiled matchers will still verify ancestry, so step up a level
    			} else if ( compiled ) {
    				context = context.parentNode;
    			}

    			selector = selector.slice( tokens.shift().value.length );
    		}

    		// Fetch a seed set for right-to-left matching
    		i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
    		while ( i-- ) {
    			token = tokens[i];

    			// Abort if we hit a combinator
    			if ( Expr.relative[ (type = token.type) ] ) {
    				break;
    			}
    			if ( (find = Expr.find[ type ]) ) {
    				// Search, expanding context for leading sibling combinators
    				if ( (seed = find(
    					token.matches[0].replace( runescape, funescape ),
    					rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
    				)) ) {

    					// If seed is empty or no tokens remain, we can return early
    					tokens.splice( i, 1 );
    					selector = seed.length && toSelector( tokens );
    					if ( !selector ) {
    						push.apply( results, seed );
    						return results;
    					}

    					break;
    				}
    			}
    		}
    	}

    	// Compile and execute a filtering function if one is not provided
    	// Provide `match` to avoid retokenization if we modified the selector above
    	( compiled || compile( selector, match ) )(
    		seed,
    		context,
    		!documentIsHTML,
    		results,
    		!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
    	);
    	return results;
    };

    // One-time assignments

    // Sort stability
    support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;

    // Support: Chrome 14-35+
    // Always assume duplicates if they aren't passed to the comparison function
    support.detectDuplicates = !!hasDuplicate;

    // Initialize against the default document
    setDocument();

    // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
    // Detached nodes confoundingly follow *each other*
    support.sortDetached = assert(function( el ) {
    	// Should return 1, but returns 4 (following)
    	return el.compareDocumentPosition( document.createElement("fieldset") ) & 1;
    });

    // Support: IE<8
    // Prevent attribute/property "interpolation"
    // https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
    if ( !assert(function( el ) {
    	el.innerHTML = "<a href='#'></a>";
    	return el.firstChild.getAttribute("href") === "#" ;
    }) ) {
    	addHandle( "type|href|height|width", function( elem, name, isXML ) {
    		if ( !isXML ) {
    			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
    		}
    	});
    }

    // Support: IE<9
    // Use defaultValue in place of getAttribute("value")
    if ( !support.attributes || !assert(function( el ) {
    	el.innerHTML = "<input/>";
    	el.firstChild.setAttribute( "value", "" );
    	return el.firstChild.getAttribute( "value" ) === "";
    }) ) {
    	addHandle( "value", function( elem, name, isXML ) {
    		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
    			return elem.defaultValue;
    		}
    	});
    }

    // Support: IE<9
    // Use getAttributeNode to fetch booleans when getAttribute lies
    if ( !assert(function( el ) {
    	return el.getAttribute("disabled") == null;
    }) ) {
    	addHandle( booleans, function( elem, name, isXML ) {
    		var val;
    		if ( !isXML ) {
    			return elem[ name ] === true ? name.toLowerCase() :
    					(val = elem.getAttributeNode( name )) && val.specified ?
    					val.value :
    				null;
    		}
    	});
    }

    return Sizzle;

    })( window );

    jQuery.find = Sizzle;
    jQuery.expr = Sizzle.selectors;

    // Deprecated
    jQuery.expr[ ":" ] = jQuery.expr.pseudos;
    jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
    jQuery.text = Sizzle.getText;
    jQuery.isXMLDoc = Sizzle.isXML;
    jQuery.contains = Sizzle.contains;
    jQuery.escapeSelector = Sizzle.escape;

    var dir = function( elem, dir, until ) {
    	var matched = [],
    		truncate = until !== undefined;

    	while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
    		if ( elem.nodeType === 1 ) {
    			if ( truncate && jQuery( elem ).is( until ) ) {
    				break;
    			}
    			matched.push( elem );
    		}
    	}
    	return matched;
    };

    var siblings = function( n, elem ) {
    	var matched = [];

    	for ( ; n; n = n.nextSibling ) {
    		if ( n.nodeType === 1 && n !== elem ) {
    			matched.push( n );
    		}
    	}

    	return matched;
    };

    var rneedsContext = jQuery.expr.match.needsContext;

    var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );

    var risSimple = /^.[^:#\[\.,]*$/;

    // Implement the identical functionality for filter and not
    function winnow( elements, qualifier, not ) {
    	if ( jQuery.isFunction( qualifier ) ) {
    		return jQuery.grep( elements, function( elem, i ) {
    			return !!qualifier.call( elem, i, elem ) !== not;
    		} );
    	}

    	// Single element
    	if ( qualifier.nodeType ) {
    		return jQuery.grep( elements, function( elem ) {
    			return ( elem === qualifier ) !== not;
    		} );
    	}

    	// Arraylike of elements (jQuery, arguments, Array)
    	if ( typeof qualifier !== "string" ) {
    		return jQuery.grep( elements, function( elem ) {
    			return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
    		} );
    	}

    	// Simple selector that can be filtered directly, removing non-Elements
    	if ( risSimple.test( qualifier ) ) {
    		return jQuery.filter( qualifier, elements, not );
    	}

    	// Complex selector, compare the two sets, removing non-Elements
    	qualifier = jQuery.filter( qualifier, elements );
    	return jQuery.grep( elements, function( elem ) {
    		return ( indexOf.call( qualifier, elem ) > -1 ) !== not && elem.nodeType === 1;
    	} );
    }

    jQuery.filter = function( expr, elems, not ) {
    	var elem = elems[ 0 ];

    	if ( not ) {
    		expr = ":not(" + expr + ")";
    	}

    	if ( elems.length === 1 && elem.nodeType === 1 ) {
    		return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
    	}

    	return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
    		return elem.nodeType === 1;
    	} ) );
    };

    jQuery.fn.extend( {
    	find: function( selector ) {
    		var i, ret,
    			len = this.length,
    			self = this;

    		if ( typeof selector !== "string" ) {
    			return this.pushStack( jQuery( selector ).filter( function() {
    				for ( i = 0; i < len; i++ ) {
    					if ( jQuery.contains( self[ i ], this ) ) {
    						return true;
    					}
    				}
    			} ) );
    		}

    		ret = this.pushStack( [] );

    		for ( i = 0; i < len; i++ ) {
    			jQuery.find( selector, self[ i ], ret );
    		}

    		return len > 1 ? jQuery.uniqueSort( ret ) : ret;
    	},
    	filter: function( selector ) {
    		return this.pushStack( winnow( this, selector || [], false ) );
    	},
    	not: function( selector ) {
    		return this.pushStack( winnow( this, selector || [], true ) );
    	},
    	is: function( selector ) {
    		return !!winnow(
    			this,

    			// If this is a positional/relative selector, check membership in the returned set
    			// so $("p:first").is("p:last") won't return true for a doc with two "p".
    			typeof selector === "string" && rneedsContext.test( selector ) ?
    				jQuery( selector ) :
    				selector || [],
    			false
    		).length;
    	}
    } );

    // Initialize a jQuery object

    // A central reference to the root jQuery(document)
    var rootjQuery,

    	// A simple way to check for HTML strings
    	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
    	// Strict HTML recognition (#11290: must start with <)
    	// Shortcut simple #id case for speed
    	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,

    	init = jQuery.fn.init = function( selector, context, root ) {
    		var match, elem;

    		// HANDLE: $(""), $(null), $(undefined), $(false)
    		if ( !selector ) {
    			return this;
    		}

    		// Method init() accepts an alternate rootjQuery
    		// so migrate can support jQuery.sub (gh-2101)
    		root = root || rootjQuery;

    		// Handle HTML strings
    		if ( typeof selector === "string" ) {
    			if ( selector[ 0 ] === "<" &&
    				selector[ selector.length - 1 ] === ">" &&
    				selector.length >= 3 ) {

    				// Assume that strings that start and end with <> are HTML and skip the regex check
    				match = [ null, selector, null ];

    			} else {
    				match = rquickExpr.exec( selector );
    			}

    			// Match html or make sure no context is specified for #id
    			if ( match && ( match[ 1 ] || !context ) ) {

    				// HANDLE: $(html) -> $(array)
    				if ( match[ 1 ] ) {
    					context = context instanceof jQuery ? context[ 0 ] : context;

    					// Option to run scripts is true for back-compat
    					// Intentionally let the error be thrown if parseHTML is not present
    					jQuery.merge( this, jQuery.parseHTML(
    						match[ 1 ],
    						context && context.nodeType ? context.ownerDocument || context : document,
    						true
    					) );

    					// HANDLE: $(html, props)
    					if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
    						for ( match in context ) {

    							// Properties of context are called as methods if possible
    							if ( jQuery.isFunction( this[ match ] ) ) {
    								this[ match ]( context[ match ] );

    							// ...and otherwise set as attributes
    							} else {
    								this.attr( match, context[ match ] );
    							}
    						}
    					}

    					return this;

    				// HANDLE: $(#id)
    				} else {
    					elem = document.getElementById( match[ 2 ] );

    					if ( elem ) {

    						// Inject the element directly into the jQuery object
    						this[ 0 ] = elem;
    						this.length = 1;
    					}
    					return this;
    				}

    			// HANDLE: $(expr, $(...))
    			} else if ( !context || context.jquery ) {
    				return ( context || root ).find( selector );

    			// HANDLE: $(expr, context)
    			// (which is just equivalent to: $(context).find(expr)
    			} else {
    				return this.constructor( context ).find( selector );
    			}

    		// HANDLE: $(DOMElement)
    		} else if ( selector.nodeType ) {
    			this[ 0 ] = selector;
    			this.length = 1;
    			return this;

    		// HANDLE: $(function)
    		// Shortcut for document ready
    		} else if ( jQuery.isFunction( selector ) ) {
    			return root.ready !== undefined ?
    				root.ready( selector ) :

    				// Execute immediately if ready is not present
    				selector( jQuery );
    		}

    		return jQuery.makeArray( selector, this );
    	};

    // Give the init function the jQuery prototype for later instantiation
    init.prototype = jQuery.fn;

    // Initialize central reference
    rootjQuery = jQuery( document );

    var rparentsprev = /^(?:parents|prev(?:Until|All))/,

    	// Methods guaranteed to produce a unique set when starting from a unique set
    	guaranteedUnique = {
    		children: true,
    		contents: true,
    		next: true,
    		prev: true
    	};

    jQuery.fn.extend( {
    	has: function( target ) {
    		var targets = jQuery( target, this ),
    			l = targets.length;

    		return this.filter( function() {
    			var i = 0;
    			for ( ; i < l; i++ ) {
    				if ( jQuery.contains( this, targets[ i ] ) ) {
    					return true;
    				}
    			}
    		} );
    	},

    	closest: function( selectors, context ) {
    		var cur,
    			i = 0,
    			l = this.length,
    			matched = [],
    			targets = typeof selectors !== "string" && jQuery( selectors );

    		// Positional selectors never match, since there's no _selection_ context
    		if ( !rneedsContext.test( selectors ) ) {
    			for ( ; i < l; i++ ) {
    				for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {

    					// Always skip document fragments
    					if ( cur.nodeType < 11 && ( targets ?
    						targets.index( cur ) > -1 :

    						// Don't pass non-elements to Sizzle
    						cur.nodeType === 1 &&
    							jQuery.find.matchesSelector( cur, selectors ) ) ) {

    						matched.push( cur );
    						break;
    					}
    				}
    			}
    		}

    		return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
    	},

    	// Determine the position of an element within the set
    	index: function( elem ) {

    		// No argument, return index in parent
    		if ( !elem ) {
    			return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
    		}

    		// Index in selector
    		if ( typeof elem === "string" ) {
    			return indexOf.call( jQuery( elem ), this[ 0 ] );
    		}

    		// Locate the position of the desired element
    		return indexOf.call( this,

    			// If it receives a jQuery object, the first element is used
    			elem.jquery ? elem[ 0 ] : elem
    		);
    	},

    	add: function( selector, context ) {
    		return this.pushStack(
    			jQuery.uniqueSort(
    				jQuery.merge( this.get(), jQuery( selector, context ) )
    			)
    		);
    	},

    	addBack: function( selector ) {
    		return this.add( selector == null ?
    			this.prevObject : this.prevObject.filter( selector )
    		);
    	}
    } );

    function sibling( cur, dir ) {
    	while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
    	return cur;
    }

    jQuery.each( {
    	parent: function( elem ) {
    		var parent = elem.parentNode;
    		return parent && parent.nodeType !== 11 ? parent : null;
    	},
    	parents: function( elem ) {
    		return dir( elem, "parentNode" );
    	},
    	parentsUntil: function( elem, i, until ) {
    		return dir( elem, "parentNode", until );
    	},
    	next: function( elem ) {
    		return sibling( elem, "nextSibling" );
    	},
    	prev: function( elem ) {
    		return sibling( elem, "previousSibling" );
    	},
    	nextAll: function( elem ) {
    		return dir( elem, "nextSibling" );
    	},
    	prevAll: function( elem ) {
    		return dir( elem, "previousSibling" );
    	},
    	nextUntil: function( elem, i, until ) {
    		return dir( elem, "nextSibling", until );
    	},
    	prevUntil: function( elem, i, until ) {
    		return dir( elem, "previousSibling", until );
    	},
    	siblings: function( elem ) {
    		return siblings( ( elem.parentNode || {} ).firstChild, elem );
    	},
    	children: function( elem ) {
    		return siblings( elem.firstChild );
    	},
    	contents: function( elem ) {
    		return elem.contentDocument || jQuery.merge( [], elem.childNodes );
    	}
    }, function( name, fn ) {
    	jQuery.fn[ name ] = function( until, selector ) {
    		var matched = jQuery.map( this, fn, until );

    		if ( name.slice( -5 ) !== "Until" ) {
    			selector = until;
    		}

    		if ( selector && typeof selector === "string" ) {
    			matched = jQuery.filter( selector, matched );
    		}

    		if ( this.length > 1 ) {

    			// Remove duplicates
    			if ( !guaranteedUnique[ name ] ) {
    				jQuery.uniqueSort( matched );
    			}

    			// Reverse order for parents* and prev-derivatives
    			if ( rparentsprev.test( name ) ) {
    				matched.reverse();
    			}
    		}

    		return this.pushStack( matched );
    	};
    } );
    var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );

    // Convert String-formatted options into Object-formatted ones
    function createOptions( options ) {
    	var object = {};
    	jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
    		object[ flag ] = true;
    	} );
    	return object;
    }

    /*
     * Create a callback list using the following parameters:
     *
     *	options: an optional list of space-separated options that will change how
     *			the callback list behaves or a more traditional option object
     *
     * By default a callback list will act like an event callback list and can be
     * "fired" multiple times.
     *
     * Possible options:
     *
     *	once:			will ensure the callback list can only be fired once (like a Deferred)
     *
     *	memory:			will keep track of previous values and will call any callback added
     *					after the list has been fired right away with the latest "memorized"
     *					values (like a Deferred)
     *
     *	unique:			will ensure a callback can only be added once (no duplicate in the list)
     *
     *	stopOnFalse:	interrupt callings when a callback returns false
     *
     */
    jQuery.Callbacks = function( options ) {

    	// Convert options from String-formatted to Object-formatted if needed
    	// (we check in cache first)
    	options = typeof options === "string" ?
    		createOptions( options ) :
    		jQuery.extend( {}, options );

    	var // Flag to know if list is currently firing
    		firing,

    		// Last fire value for non-forgettable lists
    		memory,

    		// Flag to know if list was already fired
    		fired,

    		// Flag to prevent firing
    		locked,

    		// Actual callback list
    		list = [],

    		// Queue of execution data for repeatable lists
    		queue = [],

    		// Index of currently firing callback (modified by add/remove as needed)
    		firingIndex = -1,

    		// Fire callbacks
    		fire = function() {

    			// Enforce single-firing
    			locked = options.once;

    			// Execute callbacks for all pending executions,
    			// respecting firingIndex overrides and runtime changes
    			fired = firing = true;
    			for ( ; queue.length; firingIndex = -1 ) {
    				memory = queue.shift();
    				while ( ++firingIndex < list.length ) {

    					// Run callback and check for early termination
    					if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
    						options.stopOnFalse ) {

    						// Jump to end and forget the data so .add doesn't re-fire
    						firingIndex = list.length;
    						memory = false;
    					}
    				}
    			}

    			// Forget the data if we're done with it
    			if ( !options.memory ) {
    				memory = false;
    			}

    			firing = false;

    			// Clean up if we're done firing for good
    			if ( locked ) {

    				// Keep an empty list if we have data for future add calls
    				if ( memory ) {
    					list = [];

    				// Otherwise, this object is spent
    				} else {
    					list = "";
    				}
    			}
    		},

    		// Actual Callbacks object
    		self = {

    			// Add a callback or a collection of callbacks to the list
    			add: function() {
    				if ( list ) {

    					// If we have memory from a past run, we should fire after adding
    					if ( memory && !firing ) {
    						firingIndex = list.length - 1;
    						queue.push( memory );
    					}

    					( function add( args ) {
    						jQuery.each( args, function( _, arg ) {
    							if ( jQuery.isFunction( arg ) ) {
    								if ( !options.unique || !self.has( arg ) ) {
    									list.push( arg );
    								}
    							} else if ( arg && arg.length && jQuery.type( arg ) !== "string" ) {

    								// Inspect recursively
    								add( arg );
    							}
    						} );
    					} )( arguments );

    					if ( memory && !firing ) {
    						fire();
    					}
    				}
    				return this;
    			},

    			// Remove a callback from the list
    			remove: function() {
    				jQuery.each( arguments, function( _, arg ) {
    					var index;
    					while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
    						list.splice( index, 1 );

    						// Handle firing indexes
    						if ( index <= firingIndex ) {
    							firingIndex--;
    						}
    					}
    				} );
    				return this;
    			},

    			// Check if a given callback is in the list.
    			// If no argument is given, return whether or not list has callbacks attached.
    			has: function( fn ) {
    				return fn ?
    					jQuery.inArray( fn, list ) > -1 :
    					list.length > 0;
    			},

    			// Remove all callbacks from the list
    			empty: function() {
    				if ( list ) {
    					list = [];
    				}
    				return this;
    			},

    			// Disable .fire and .add
    			// Abort any current/pending executions
    			// Clear all callbacks and values
    			disable: function() {
    				locked = queue = [];
    				list = memory = "";
    				return this;
    			},
    			disabled: function() {
    				return !list;
    			},

    			// Disable .fire
    			// Also disable .add unless we have memory (since it would have no effect)
    			// Abort any pending executions
    			lock: function() {
    				locked = queue = [];
    				if ( !memory && !firing ) {
    					list = memory = "";
    				}
    				return this;
    			},
    			locked: function() {
    				return !!locked;
    			},

    			// Call all callbacks with the given context and arguments
    			fireWith: function( context, args ) {
    				if ( !locked ) {
    					args = args || [];
    					args = [ context, args.slice ? args.slice() : args ];
    					queue.push( args );
    					if ( !firing ) {
    						fire();
    					}
    				}
    				return this;
    			},

    			// Call all the callbacks with the given arguments
    			fire: function() {
    				self.fireWith( this, arguments );
    				return this;
    			},

    			// To know if the callbacks have already been called at least once
    			fired: function() {
    				return !!fired;
    			}
    		};

    	return self;
    };

    function Identity( v ) {
    	return v;
    }
    function Thrower( ex ) {
    	throw ex;
    }

    function adoptValue( value, resolve, reject ) {
    	var method;

    	try {

    		// Check for promise aspect first to privilege synchronous behavior
    		if ( value && jQuery.isFunction( ( method = value.promise ) ) ) {
    			method.call( value ).done( resolve ).fail( reject );

    		// Other thenables
    		} else if ( value && jQuery.isFunction( ( method = value.then ) ) ) {
    			method.call( value, resolve, reject );

    		// Other non-thenables
    		} else {

    			// Support: Android 4.0 only
    			// Strict mode functions invoked without .call/.apply get global-object context
    			resolve.call( undefined, value );
    		}

    	// For Promises/A+, convert exceptions into rejections
    	// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
    	// Deferred#then to conditionally suppress rejection.
    	} catch ( value ) {

    		// Support: Android 4.0 only
    		// Strict mode functions invoked without .call/.apply get global-object context
    		reject.call( undefined, value );
    	}
    }

    jQuery.extend( {

    	Deferred: function( func ) {
    		var tuples = [

    				// action, add listener, callbacks,
    				// ... .then handlers, argument index, [final state]
    				[ "notify", "progress", jQuery.Callbacks( "memory" ),
    					jQuery.Callbacks( "memory" ), 2 ],
    				[ "resolve", "done", jQuery.Callbacks( "once memory" ),
    					jQuery.Callbacks( "once memory" ), 0, "resolved" ],
    				[ "reject", "fail", jQuery.Callbacks( "once memory" ),
    					jQuery.Callbacks( "once memory" ), 1, "rejected" ]
    			],
    			state = "pending",
    			promise = {
    				state: function() {
    					return state;
    				},
    				always: function() {
    					deferred.done( arguments ).fail( arguments );
    					return this;
    				},
    				"catch": function( fn ) {
    					return promise.then( null, fn );
    				},

    				// Keep pipe for back-compat
    				pipe: function( /* fnDone, fnFail, fnProgress */ ) {
    					var fns = arguments;

    					return jQuery.Deferred( function( newDefer ) {
    						jQuery.each( tuples, function( i, tuple ) {

    							// Map tuples (progress, done, fail) to arguments (done, fail, progress)
    							var fn = jQuery.isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];

    							// deferred.progress(function() { bind to newDefer or newDefer.notify })
    							// deferred.done(function() { bind to newDefer or newDefer.resolve })
    							// deferred.fail(function() { bind to newDefer or newDefer.reject })
    							deferred[ tuple[ 1 ] ]( function() {
    								var returned = fn && fn.apply( this, arguments );
    								if ( returned && jQuery.isFunction( returned.promise ) ) {
    									returned.promise()
    										.progress( newDefer.notify )
    										.done( newDefer.resolve )
    										.fail( newDefer.reject );
    								} else {
    									newDefer[ tuple[ 0 ] + "With" ](
    										this,
    										fn ? [ returned ] : arguments
    									);
    								}
    							} );
    						} );
    						fns = null;
    					} ).promise();
    				},
    				then: function( onFulfilled, onRejected, onProgress ) {
    					var maxDepth = 0;
    					function resolve( depth, deferred, handler, special ) {
    						return function() {
    							var that = this,
    								args = arguments,
    								mightThrow = function() {
    									var returned, then;

    									// Support: Promises/A+ section 2.3.3.3.3
    									// https://promisesaplus.com/#point-59
    									// Ignore double-resolution attempts
    									if ( depth < maxDepth ) {
    										return;
    									}

    									returned = handler.apply( that, args );

    									// Support: Promises/A+ section 2.3.1
    									// https://promisesaplus.com/#point-48
    									if ( returned === deferred.promise() ) {
    										throw new TypeError( "Thenable self-resolution" );
    									}

    									// Support: Promises/A+ sections 2.3.3.1, 3.5
    									// https://promisesaplus.com/#point-54
    									// https://promisesaplus.com/#point-75
    									// Retrieve `then` only once
    									then = returned &&

    										// Support: Promises/A+ section 2.3.4
    										// https://promisesaplus.com/#point-64
    										// Only check objects and functions for thenability
    										( typeof returned === "object" ||
    											typeof returned === "function" ) &&
    										returned.then;

    									// Handle a returned thenable
    									if ( jQuery.isFunction( then ) ) {

    										// Special processors (notify) just wait for resolution
    										if ( special ) {
    											then.call(
    												returned,
    												resolve( maxDepth, deferred, Identity, special ),
    												resolve( maxDepth, deferred, Thrower, special )
    											);

    										// Normal processors (resolve) also hook into progress
    										} else {

    											// ...and disregard older resolution values
    											maxDepth++;

    											then.call(
    												returned,
    												resolve( maxDepth, deferred, Identity, special ),
    												resolve( maxDepth, deferred, Thrower, special ),
    												resolve( maxDepth, deferred, Identity,
    													deferred.notifyWith )
    											);
    										}

    									// Handle all other returned values
    									} else {

    										// Only substitute handlers pass on context
    										// and multiple values (non-spec behavior)
    										if ( handler !== Identity ) {
    											that = undefined;
    											args = [ returned ];
    										}

    										// Process the value(s)
    										// Default process is resolve
    										( special || deferred.resolveWith )( that, args );
    									}
    								},

    								// Only normal processors (resolve) catch and reject exceptions
    								process = special ?
    									mightThrow :
    									function() {
    										try {
    											mightThrow();
    										} catch ( e ) {

    											if ( jQuery.Deferred.exceptionHook ) {
    												jQuery.Deferred.exceptionHook( e,
    													process.stackTrace );
    											}

    											// Support: Promises/A+ section 2.3.3.3.4.1
    											// https://promisesaplus.com/#point-61
    											// Ignore post-resolution exceptions
    											if ( depth + 1 >= maxDepth ) {

    												// Only substitute handlers pass on context
    												// and multiple values (non-spec behavior)
    												if ( handler !== Thrower ) {
    													that = undefined;
    													args = [ e ];
    												}

    												deferred.rejectWith( that, args );
    											}
    										}
    									};

    							// Support: Promises/A+ section 2.3.3.3.1
    							// https://promisesaplus.com/#point-57
    							// Re-resolve promises immediately to dodge false rejection from
    							// subsequent errors
    							if ( depth ) {
    								process();
    							} else {

    								// Call an optional hook to record the stack, in case of exception
    								// since it's otherwise lost when execution goes async
    								if ( jQuery.Deferred.getStackHook ) {
    									process.stackTrace = jQuery.Deferred.getStackHook();
    								}
    								window.setTimeout( process );
    							}
    						};
    					}

    					return jQuery.Deferred( function( newDefer ) {

    						// progress_handlers.add( ... )
    						tuples[ 0 ][ 3 ].add(
    							resolve(
    								0,
    								newDefer,
    								jQuery.isFunction( onProgress ) ?
    									onProgress :
    									Identity,
    								newDefer.notifyWith
    							)
    						);

    						// fulfilled_handlers.add( ... )
    						tuples[ 1 ][ 3 ].add(
    							resolve(
    								0,
    								newDefer,
    								jQuery.isFunction( onFulfilled ) ?
    									onFulfilled :
    									Identity
    							)
    						);

    						// rejected_handlers.add( ... )
    						tuples[ 2 ][ 3 ].add(
    							resolve(
    								0,
    								newDefer,
    								jQuery.isFunction( onRejected ) ?
    									onRejected :
    									Thrower
    							)
    						);
    					} ).promise();
    				},

    				// Get a promise for this deferred
    				// If obj is provided, the promise aspect is added to the object
    				promise: function( obj ) {
    					return obj != null ? jQuery.extend( obj, promise ) : promise;
    				}
    			},
    			deferred = {};

    		// Add list-specific methods
    		jQuery.each( tuples, function( i, tuple ) {
    			var list = tuple[ 2 ],
    				stateString = tuple[ 5 ];

    			// promise.progress = list.add
    			// promise.done = list.add
    			// promise.fail = list.add
    			promise[ tuple[ 1 ] ] = list.add;

    			// Handle state
    			if ( stateString ) {
    				list.add(
    					function() {

    						// state = "resolved" (i.e., fulfilled)
    						// state = "rejected"
    						state = stateString;
    					},

    					// rejected_callbacks.disable
    					// fulfilled_callbacks.disable
    					tuples[ 3 - i ][ 2 ].disable,

    					// progress_callbacks.lock
    					tuples[ 0 ][ 2 ].lock
    				);
    			}

    			// progress_handlers.fire
    			// fulfilled_handlers.fire
    			// rejected_handlers.fire
    			list.add( tuple[ 3 ].fire );

    			// deferred.notify = function() { deferred.notifyWith(...) }
    			// deferred.resolve = function() { deferred.resolveWith(...) }
    			// deferred.reject = function() { deferred.rejectWith(...) }
    			deferred[ tuple[ 0 ] ] = function() {
    				deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
    				return this;
    			};

    			// deferred.notifyWith = list.fireWith
    			// deferred.resolveWith = list.fireWith
    			// deferred.rejectWith = list.fireWith
    			deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
    		} );

    		// Make the deferred a promise
    		promise.promise( deferred );

    		// Call given func if any
    		if ( func ) {
    			func.call( deferred, deferred );
    		}

    		// All done!
    		return deferred;
    	},

    	// Deferred helper
    	when: function( singleValue ) {
    		var

    			// count of uncompleted subordinates
    			remaining = arguments.length,

    			// count of unprocessed arguments
    			i = remaining,

    			// subordinate fulfillment data
    			resolveContexts = Array( i ),
    			resolveValues = slice.call( arguments ),

    			// the master Deferred
    			master = jQuery.Deferred(),

    			// subordinate callback factory
    			updateFunc = function( i ) {
    				return function( value ) {
    					resolveContexts[ i ] = this;
    					resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
    					if ( !( --remaining ) ) {
    						master.resolveWith( resolveContexts, resolveValues );
    					}
    				};
    			};

    		// Single- and empty arguments are adopted like Promise.resolve
    		if ( remaining <= 1 ) {
    			adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject );

    			// Use .then() to unwrap secondary thenables (cf. gh-3000)
    			if ( master.state() === "pending" ||
    				jQuery.isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {

    				return master.then();
    			}
    		}

    		// Multiple arguments are aggregated like Promise.all array elements
    		while ( i-- ) {
    			adoptValue( resolveValues[ i ], updateFunc( i ), master.reject );
    		}

    		return master.promise();
    	}
    } );

    // These usually indicate a programmer mistake during development,
    // warn about them ASAP rather than swallowing them by default.
    var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;

    jQuery.Deferred.exceptionHook = function( error, stack ) {

    	// Support: IE 8 - 9 only
    	// Console exists when dev tools are open, which can happen at any time
    	if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
    		window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack );
    	}
    };

    jQuery.readyException = function( error ) {
    	window.setTimeout( function() {
    		throw error;
    	} );
    };

    // The deferred used on DOM ready
    var readyList = jQuery.Deferred();

    jQuery.fn.ready = function( fn ) {

    	readyList
    		.then( fn )

    		// Wrap jQuery.readyException in a function so that the lookup
    		// happens at the time of error handling instead of callback
    		// registration.
    		.catch( function( error ) {
    			jQuery.readyException( error );
    		} );

    	return this;
    };

    jQuery.extend( {

    	// Is the DOM ready to be used? Set to true once it occurs.
    	isReady: false,

    	// A counter to track how many items to wait for before
    	// the ready event fires. See #6781
    	readyWait: 1,

    	// Hold (or release) the ready event
    	holdReady: function( hold ) {
    		if ( hold ) {
    			jQuery.readyWait++;
    		} else {
    			jQuery.ready( true );
    		}
    	},

    	// Handle when the DOM is ready
    	ready: function( wait ) {

    		// Abort if there are pending holds or we're already ready
    		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
    			return;
    		}

    		// Remember that the DOM is ready
    		jQuery.isReady = true;

    		// If a normal DOM Ready event fired, decrement, and wait if need be
    		if ( wait !== true && --jQuery.readyWait > 0 ) {
    			return;
    		}

    		// If there are functions bound, to execute
    		readyList.resolveWith( document, [ jQuery ] );
    	}
    } );

    jQuery.ready.then = readyList.then;

    // The ready event handler and self cleanup method
    function completed() {
    	document.removeEventListener( "DOMContentLoaded", completed );
    	window.removeEventListener( "load", completed );
    	jQuery.ready();
    }

    // Catch cases where $(document).ready() is called
    // after the browser event has already occurred.
    // Support: IE <=9 - 10 only
    // Older IE sometimes signals "interactive" too soon
    if ( document.readyState === "complete" ||
    	( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {

    	// Handle it asynchronously to allow scripts the opportunity to delay ready
    	window.setTimeout( jQuery.ready );

    } else {

    	// Use the handy event callback
    	document.addEventListener( "DOMContentLoaded", completed );

    	// A fallback to window.onload, that will always work
    	window.addEventListener( "load", completed );
    }

    // Multifunctional method to get and set values of a collection
    // The value/s can optionally be executed if it's a function
    var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
    	var i = 0,
    		len = elems.length,
    		bulk = key == null;

    	// Sets many values
    	if ( jQuery.type( key ) === "object" ) {
    		chainable = true;
    		for ( i in key ) {
    			access( elems, fn, i, key[ i ], true, emptyGet, raw );
    		}

    	// Sets one value
    	} else if ( value !== undefined ) {
    		chainable = true;

    		if ( !jQuery.isFunction( value ) ) {
    			raw = true;
    		}

    		if ( bulk ) {

    			// Bulk operations run against the entire set
    			if ( raw ) {
    				fn.call( elems, value );
    				fn = null;

    			// ...except when executing function values
    			} else {
    				bulk = fn;
    				fn = function( elem, key, value ) {
    					return bulk.call( jQuery( elem ), value );
    				};
    			}
    		}

    		if ( fn ) {
    			for ( ; i < len; i++ ) {
    				fn(
    					elems[ i ], key, raw ?
    					value :
    					value.call( elems[ i ], i, fn( elems[ i ], key ) )
    				);
    			}
    		}
    	}

    	if ( chainable ) {
    		return elems;
    	}

    	// Gets
    	if ( bulk ) {
    		return fn.call( elems );
    	}

    	return len ? fn( elems[ 0 ], key ) : emptyGet;
    };
    var acceptData = function( owner ) {

    	// Accepts only:
    	//  - Node
    	//    - Node.ELEMENT_NODE
    	//    - Node.DOCUMENT_NODE
    	//  - Object
    	//    - Any
    	return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
    };

    function Data() {
    	this.expando = jQuery.expando + Data.uid++;
    }

    Data.uid = 1;

    Data.prototype = {

    	cache: function( owner ) {

    		// Check if the owner object already has a cache
    		var value = owner[ this.expando ];

    		// If not, create one
    		if ( !value ) {
    			value = {};

    			// We can accept data for non-element nodes in modern browsers,
    			// but we should not, see #8335.
    			// Always return an empty object.
    			if ( acceptData( owner ) ) {

    				// If it is a node unlikely to be stringify-ed or looped over
    				// use plain assignment
    				if ( owner.nodeType ) {
    					owner[ this.expando ] = value;

    				// Otherwise secure it in a non-enumerable property
    				// configurable must be true to allow the property to be
    				// deleted when data is removed
    				} else {
    					Object.defineProperty( owner, this.expando, {
    						value: value,
    						configurable: true
    					} );
    				}
    			}
    		}

    		return value;
    	},
    	set: function( owner, data, value ) {
    		var prop,
    			cache = this.cache( owner );

    		// Handle: [ owner, key, value ] args
    		// Always use camelCase key (gh-2257)
    		if ( typeof data === "string" ) {
    			cache[ jQuery.camelCase( data ) ] = value;

    		// Handle: [ owner, { properties } ] args
    		} else {

    			// Copy the properties one-by-one to the cache object
    			for ( prop in data ) {
    				cache[ jQuery.camelCase( prop ) ] = data[ prop ];
    			}
    		}
    		return cache;
    	},
    	get: function( owner, key ) {
    		return key === undefined ?
    			this.cache( owner ) :

    			// Always use camelCase key (gh-2257)
    			owner[ this.expando ] && owner[ this.expando ][ jQuery.camelCase( key ) ];
    	},
    	access: function( owner, key, value ) {

    		// In cases where either:
    		//
    		//   1. No key was specified
    		//   2. A string key was specified, but no value provided
    		//
    		// Take the "read" path and allow the get method to determine
    		// which value to return, respectively either:
    		//
    		//   1. The entire cache object
    		//   2. The data stored at the key
    		//
    		if ( key === undefined ||
    				( ( key && typeof key === "string" ) && value === undefined ) ) {

    			return this.get( owner, key );
    		}

    		// When the key is not a string, or both a key and value
    		// are specified, set or extend (existing objects) with either:
    		//
    		//   1. An object of properties
    		//   2. A key and value
    		//
    		this.set( owner, key, value );

    		// Since the "set" path can have two possible entry points
    		// return the expected data based on which path was taken[*]
    		return value !== undefined ? value : key;
    	},
    	remove: function( owner, key ) {
    		var i,
    			cache = owner[ this.expando ];

    		if ( cache === undefined ) {
    			return;
    		}

    		if ( key !== undefined ) {

    			// Support array or space separated string of keys
    			if ( jQuery.isArray( key ) ) {

    				// If key is an array of keys...
    				// We always set camelCase keys, so remove that.
    				key = key.map( jQuery.camelCase );
    			} else {
    				key = jQuery.camelCase( key );

    				// If a key with the spaces exists, use it.
    				// Otherwise, create an array by matching non-whitespace
    				key = key in cache ?
    					[ key ] :
    					( key.match( rnothtmlwhite ) || [] );
    			}

    			i = key.length;

    			while ( i-- ) {
    				delete cache[ key[ i ] ];
    			}
    		}

    		// Remove the expando if there's no more data
    		if ( key === undefined || jQuery.isEmptyObject( cache ) ) {

    			// Support: Chrome <=35 - 45
    			// Webkit & Blink performance suffers when deleting properties
    			// from DOM nodes, so set to undefined instead
    			// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
    			if ( owner.nodeType ) {
    				owner[ this.expando ] = undefined;
    			} else {
    				delete owner[ this.expando ];
    			}
    		}
    	},
    	hasData: function( owner ) {
    		var cache = owner[ this.expando ];
    		return cache !== undefined && !jQuery.isEmptyObject( cache );
    	}
    };
    var dataPriv = new Data();

    var dataUser = new Data();

    //	Implementation Summary
    //
    //	1. Enforce API surface and semantic compatibility with 1.9.x branch
    //	2. Improve the module's maintainability by reducing the storage
    //		paths to a single mechanism.
    //	3. Use the same single mechanism to support "private" and "user" data.
    //	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
    //	5. Avoid exposing implementation details on user objects (eg. expando properties)
    //	6. Provide a clear path for implementation upgrade to WeakMap in 2014

    var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
    	rmultiDash = /[A-Z]/g;

    function getData( data ) {
    	if ( data === "true" ) {
    		return true;
    	}

    	if ( data === "false" ) {
    		return false;
    	}

    	if ( data === "null" ) {
    		return null;
    	}

    	// Only convert to a number if it doesn't change the string
    	if ( data === +data + "" ) {
    		return +data;
    	}

    	if ( rbrace.test( data ) ) {
    		return JSON.parse( data );
    	}

    	return data;
    }

    function dataAttr( elem, key, data ) {
    	var name;

    	// If nothing was found internally, try to fetch any
    	// data from the HTML5 data-* attribute
    	if ( data === undefined && elem.nodeType === 1 ) {
    		name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
    		data = elem.getAttribute( name );

    		if ( typeof data === "string" ) {
    			try {
    				data = getData( data );
    			} catch ( e ) {}

    			// Make sure we set the data so it isn't changed later
    			dataUser.set( elem, key, data );
    		} else {
    			data = undefined;
    		}
    	}
    	return data;
    }

    jQuery.extend( {
    	hasData: function( elem ) {
    		return dataUser.hasData( elem ) || dataPriv.hasData( elem );
    	},

    	data: function( elem, name, data ) {
    		return dataUser.access( elem, name, data );
    	},

    	removeData: function( elem, name ) {
    		dataUser.remove( elem, name );
    	},

    	// TODO: Now that all calls to _data and _removeData have been replaced
    	// with direct calls to dataPriv methods, these can be deprecated.
    	_data: function( elem, name, data ) {
    		return dataPriv.access( elem, name, data );
    	},

    	_removeData: function( elem, name ) {
    		dataPriv.remove( elem, name );
    	}
    } );

    jQuery.fn.extend( {
    	data: function( key, value ) {
    		var i, name, data,
    			elem = this[ 0 ],
    			attrs = elem && elem.attributes;

    		// Gets all values
    		if ( key === undefined ) {
    			if ( this.length ) {
    				data = dataUser.get( elem );

    				if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
    					i = attrs.length;
    					while ( i-- ) {

    						// Support: IE 11 only
    						// The attrs elements can be null (#14894)
    						if ( attrs[ i ] ) {
    							name = attrs[ i ].name;
    							if ( name.indexOf( "data-" ) === 0 ) {
    								name = jQuery.camelCase( name.slice( 5 ) );
    								dataAttr( elem, name, data[ name ] );
    							}
    						}
    					}
    					dataPriv.set( elem, "hasDataAttrs", true );
    				}
    			}

    			return data;
    		}

    		// Sets multiple values
    		if ( typeof key === "object" ) {
    			return this.each( function() {
    				dataUser.set( this, key );
    			} );
    		}

    		return access( this, function( value ) {
    			var data;

    			// The calling jQuery object (element matches) is not empty
    			// (and therefore has an element appears at this[ 0 ]) and the
    			// `value` parameter was not undefined. An empty jQuery object
    			// will result in `undefined` for elem = this[ 0 ] which will
    			// throw an exception if an attempt to read a data cache is made.
    			if ( elem && value === undefined ) {

    				// Attempt to get data from the cache
    				// The key will always be camelCased in Data
    				data = dataUser.get( elem, key );
    				if ( data !== undefined ) {
    					return data;
    				}

    				// Attempt to "discover" the data in
    				// HTML5 custom data-* attrs
    				data = dataAttr( elem, key );
    				if ( data !== undefined ) {
    					return data;
    				}

    				// We tried really hard, but the data doesn't exist.
    				return;
    			}

    			// Set the data...
    			this.each( function() {

    				// We always store the camelCased key
    				dataUser.set( this, key, value );
    			} );
    		}, null, value, arguments.length > 1, null, true );
    	},

    	removeData: function( key ) {
    		return this.each( function() {
    			dataUser.remove( this, key );
    		} );
    	}
    } );

    jQuery.extend( {
    	queue: function( elem, type, data ) {
    		var queue;

    		if ( elem ) {
    			type = ( type || "fx" ) + "queue";
    			queue = dataPriv.get( elem, type );

    			// Speed up dequeue by getting out quickly if this is just a lookup
    			if ( data ) {
    				if ( !queue || jQuery.isArray( data ) ) {
    					queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
    				} else {
    					queue.push( data );
    				}
    			}
    			return queue || [];
    		}
    	},

    	dequeue: function( elem, type ) {
    		type = type || "fx";

    		var queue = jQuery.queue( elem, type ),
    			startLength = queue.length,
    			fn = queue.shift(),
    			hooks = jQuery._queueHooks( elem, type ),
    			next = function() {
    				jQuery.dequeue( elem, type );
    			};

    		// If the fx queue is dequeued, always remove the progress sentinel
    		if ( fn === "inprogress" ) {
    			fn = queue.shift();
    			startLength--;
    		}

    		if ( fn ) {

    			// Add a progress sentinel to prevent the fx queue from being
    			// automatically dequeued
    			if ( type === "fx" ) {
    				queue.unshift( "inprogress" );
    			}

    			// Clear up the last queue stop function
    			delete hooks.stop;
    			fn.call( elem, next, hooks );
    		}

    		if ( !startLength && hooks ) {
    			hooks.empty.fire();
    		}
    	},

    	// Not public - generate a queueHooks object, or return the current one
    	_queueHooks: function( elem, type ) {
    		var key = type + "queueHooks";
    		return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
    			empty: jQuery.Callbacks( "once memory" ).add( function() {
    				dataPriv.remove( elem, [ type + "queue", key ] );
    			} )
    		} );
    	}
    } );

    jQuery.fn.extend( {
    	queue: function( type, data ) {
    		var setter = 2;

    		if ( typeof type !== "string" ) {
    			data = type;
    			type = "fx";
    			setter--;
    		}

    		if ( arguments.length < setter ) {
    			return jQuery.queue( this[ 0 ], type );
    		}

    		return data === undefined ?
    			this :
    			this.each( function() {
    				var queue = jQuery.queue( this, type, data );

    				// Ensure a hooks for this queue
    				jQuery._queueHooks( this, type );

    				if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
    					jQuery.dequeue( this, type );
    				}
    			} );
    	},
    	dequeue: function( type ) {
    		return this.each( function() {
    			jQuery.dequeue( this, type );
    		} );
    	},
    	clearQueue: function( type ) {
    		return this.queue( type || "fx", [] );
    	},

    	// Get a promise resolved when queues of a certain type
    	// are emptied (fx is the type by default)
    	promise: function( type, obj ) {
    		var tmp,
    			count = 1,
    			defer = jQuery.Deferred(),
    			elements = this,
    			i = this.length,
    			resolve = function() {
    				if ( !( --count ) ) {
    					defer.resolveWith( elements, [ elements ] );
    				}
    			};

    		if ( typeof type !== "string" ) {
    			obj = type;
    			type = undefined;
    		}
    		type = type || "fx";

    		while ( i-- ) {
    			tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
    			if ( tmp && tmp.empty ) {
    				count++;
    				tmp.empty.add( resolve );
    			}
    		}
    		resolve();
    		return defer.promise( obj );
    	}
    } );
    var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;

    var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );

    var cssExpand = [ "Top", "Right", "Bottom", "Left" ];

    var isHiddenWithinTree = function( elem, el ) {

    		// isHiddenWithinTree might be called from jQuery#filter function;
    		// in that case, element will be second argument
    		elem = el || elem;

    		// Inline style trumps all
    		return elem.style.display === "none" ||
    			elem.style.display === "" &&

    			// Otherwise, check computed style
    			// Support: Firefox <=43 - 45
    			// Disconnected elements can have computed display: none, so first confirm that elem is
    			// in the document.
    			jQuery.contains( elem.ownerDocument, elem ) &&

    			jQuery.css( elem, "display" ) === "none";
    	};

    var swap = function( elem, options, callback, args ) {
    	var ret, name,
    		old = {};

    	// Remember the old values, and insert the new ones
    	for ( name in options ) {
    		old[ name ] = elem.style[ name ];
    		elem.style[ name ] = options[ name ];
    	}

    	ret = callback.apply( elem, args || [] );

    	// Revert the old values
    	for ( name in options ) {
    		elem.style[ name ] = old[ name ];
    	}

    	return ret;
    };

    function adjustCSS( elem, prop, valueParts, tween ) {
    	var adjusted,
    		scale = 1,
    		maxIterations = 20,
    		currentValue = tween ?
    			function() {
    				return tween.cur();
    			} :
    			function() {
    				return jQuery.css( elem, prop, "" );
    			},
    		initial = currentValue(),
    		unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),

    		// Starting value computation is required for potential unit mismatches
    		initialInUnit = ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
    			rcssNum.exec( jQuery.css( elem, prop ) );

    	if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {

    		// Trust units reported by jQuery.css
    		unit = unit || initialInUnit[ 3 ];

    		// Make sure we update the tween properties later on
    		valueParts = valueParts || [];

    		// Iteratively approximate from a nonzero starting point
    		initialInUnit = +initial || 1;

    		do {

    			// If previous iteration zeroed out, double until we get *something*.
    			// Use string for doubling so we don't accidentally see scale as unchanged below
    			scale = scale || ".5";

    			// Adjust and apply
    			initialInUnit = initialInUnit / scale;
    			jQuery.style( elem, prop, initialInUnit + unit );

    		// Update scale, tolerating zero or NaN from tween.cur()
    		// Break the loop if scale is unchanged or perfect, or if we've just had enough.
    		} while (
    			scale !== ( scale = currentValue() / initial ) && scale !== 1 && --maxIterations
    		);
    	}

    	if ( valueParts ) {
    		initialInUnit = +initialInUnit || +initial || 0;

    		// Apply relative offset (+=/-=) if specified
    		adjusted = valueParts[ 1 ] ?
    			initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
    			+valueParts[ 2 ];
    		if ( tween ) {
    			tween.unit = unit;
    			tween.start = initialInUnit;
    			tween.end = adjusted;
    		}
    	}
    	return adjusted;
    }

    var defaultDisplayMap = {};

    function getDefaultDisplay( elem ) {
    	var temp,
    		doc = elem.ownerDocument,
    		nodeName = elem.nodeName,
    		display = defaultDisplayMap[ nodeName ];

    	if ( display ) {
    		return display;
    	}

    	temp = doc.body.appendChild( doc.createElement( nodeName ) );
    	display = jQuery.css( temp, "display" );

    	temp.parentNode.removeChild( temp );

    	if ( display === "none" ) {
    		display = "block";
    	}
    	defaultDisplayMap[ nodeName ] = display;

    	return display;
    }

    function showHide( elements, show ) {
    	var display, elem,
    		values = [],
    		index = 0,
    		length = elements.length;

    	// Determine new display value for elements that need to change
    	for ( ; index < length; index++ ) {
    		elem = elements[ index ];
    		if ( !elem.style ) {
    			continue;
    		}

    		display = elem.style.display;
    		if ( show ) {

    			// Since we force visibility upon cascade-hidden elements, an immediate (and slow)
    			// check is required in this first loop unless we have a nonempty display value (either
    			// inline or about-to-be-restored)
    			if ( display === "none" ) {
    				values[ index ] = dataPriv.get( elem, "display" ) || null;
    				if ( !values[ index ] ) {
    					elem.style.display = "";
    				}
    			}
    			if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
    				values[ index ] = getDefaultDisplay( elem );
    			}
    		} else {
    			if ( display !== "none" ) {
    				values[ index ] = "none";

    				// Remember what we're overwriting
    				dataPriv.set( elem, "display", display );
    			}
    		}
    	}

    	// Set the display of the elements in a second loop to avoid constant reflow
    	for ( index = 0; index < length; index++ ) {
    		if ( values[ index ] != null ) {
    			elements[ index ].style.display = values[ index ];
    		}
    	}

    	return elements;
    }

    jQuery.fn.extend( {
    	show: function() {
    		return showHide( this, true );
    	},
    	hide: function() {
    		return showHide( this );
    	},
    	toggle: function( state ) {
    		if ( typeof state === "boolean" ) {
    			return state ? this.show() : this.hide();
    		}

    		return this.each( function() {
    			if ( isHiddenWithinTree( this ) ) {
    				jQuery( this ).show();
    			} else {
    				jQuery( this ).hide();
    			}
    		} );
    	}
    } );
    var rcheckableType = ( /^(?:checkbox|radio)$/i );

    var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]+)/i );

    var rscriptType = ( /^$|\/(?:java|ecma)script/i );

    // We have to close these tags to support XHTML (#13200)
    var wrapMap = {

    	// Support: IE <=9 only
    	option: [ 1, "<select multiple='multiple'>", "</select>" ],

    	// XHTML parsers do not magically insert elements in the
    	// same way that tag soup parsers do. So we cannot shorten
    	// this by omitting <tbody> or other required elements.
    	thead: [ 1, "<table>", "</table>" ],
    	col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
    	tr: [ 2, "<table><tbody>", "</tbody></table>" ],
    	td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],

    	_default: [ 0, "", "" ]
    };

    // Support: IE <=9 only
    wrapMap.optgroup = wrapMap.option;

    wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
    wrapMap.th = wrapMap.td;

    function getAll( context, tag ) {

    	// Support: IE <=9 - 11 only
    	// Use typeof to avoid zero-argument method invocation on host objects (#15151)
    	var ret;

    	if ( typeof context.getElementsByTagName !== "undefined" ) {
    		ret = context.getElementsByTagName( tag || "*" );

    	} else if ( typeof context.querySelectorAll !== "undefined" ) {
    		ret = context.querySelectorAll( tag || "*" );

    	} else {
    		ret = [];
    	}

    	if ( tag === undefined || tag && jQuery.nodeName( context, tag ) ) {
    		return jQuery.merge( [ context ], ret );
    	}

    	return ret;
    }

    // Mark scripts as having already been evaluated
    function setGlobalEval( elems, refElements ) {
    	var i = 0,
    		l = elems.length;

    	for ( ; i < l; i++ ) {
    		dataPriv.set(
    			elems[ i ],
    			"globalEval",
    			!refElements || dataPriv.get( refElements[ i ], "globalEval" )
    		);
    	}
    }

    var rhtml = /<|&#?\w+;/;

    function buildFragment( elems, context, scripts, selection, ignored ) {
    	var elem, tmp, tag, wrap, contains, j,
    		fragment = context.createDocumentFragment(),
    		nodes = [],
    		i = 0,
    		l = elems.length;

    	for ( ; i < l; i++ ) {
    		elem = elems[ i ];

    		if ( elem || elem === 0 ) {

    			// Add nodes directly
    			if ( jQuery.type( elem ) === "object" ) {

    				// Support: Android <=4.0 only, PhantomJS 1 only
    				// push.apply(_, arraylike) throws on ancient WebKit
    				jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );

    			// Convert non-html into a text node
    			} else if ( !rhtml.test( elem ) ) {
    				nodes.push( context.createTextNode( elem ) );

    			// Convert html into DOM nodes
    			} else {
    				tmp = tmp || fragment.appendChild( context.createElement( "div" ) );

    				// Deserialize a standard representation
    				tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
    				wrap = wrapMap[ tag ] || wrapMap._default;
    				tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];

    				// Descend through wrappers to the right content
    				j = wrap[ 0 ];
    				while ( j-- ) {
    					tmp = tmp.lastChild;
    				}

    				// Support: Android <=4.0 only, PhantomJS 1 only
    				// push.apply(_, arraylike) throws on ancient WebKit
    				jQuery.merge( nodes, tmp.childNodes );

    				// Remember the top-level container
    				tmp = fragment.firstChild;

    				// Ensure the created nodes are orphaned (#12392)
    				tmp.textContent = "";
    			}
    		}
    	}

    	// Remove wrapper from fragment
    	fragment.textContent = "";

    	i = 0;
    	while ( ( elem = nodes[ i++ ] ) ) {

    		// Skip elements already in the context collection (trac-4087)
    		if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
    			if ( ignored ) {
    				ignored.push( elem );
    			}
    			continue;
    		}

    		contains = jQuery.contains( elem.ownerDocument, elem );

    		// Append to fragment
    		tmp = getAll( fragment.appendChild( elem ), "script" );

    		// Preserve script evaluation history
    		if ( contains ) {
    			setGlobalEval( tmp );
    		}

    		// Capture executables
    		if ( scripts ) {
    			j = 0;
    			while ( ( elem = tmp[ j++ ] ) ) {
    				if ( rscriptType.test( elem.type || "" ) ) {
    					scripts.push( elem );
    				}
    			}
    		}
    	}

    	return fragment;
    }

    ( function() {
    	var fragment = document.createDocumentFragment(),
    		div = fragment.appendChild( document.createElement( "div" ) ),
    		input = document.createElement( "input" );

    	// Support: Android 4.0 - 4.3 only
    	// Check state lost if the name is set (#11217)
    	// Support: Windows Web Apps (WWA)
    	// `name` and `type` must use .setAttribute for WWA (#14901)
    	input.setAttribute( "type", "radio" );
    	input.setAttribute( "checked", "checked" );
    	input.setAttribute( "name", "t" );

    	div.appendChild( input );

    	// Support: Android <=4.1 only
    	// Older WebKit doesn't clone checked state correctly in fragments
    	support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;

    	// Support: IE <=11 only
    	// Make sure textarea (and checkbox) defaultValue is properly cloned
    	div.innerHTML = "<textarea>x</textarea>";
    	support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
    } )();
    var documentElement = document.documentElement;

    var
    	rkeyEvent = /^key/,
    	rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
    	rtypenamespace = /^([^.]*)(?:\.(.+)|)/;

    function returnTrue() {
    	return true;
    }

    function returnFalse() {
    	return false;
    }

    // Support: IE <=9 only
    // See #13393 for more info
    function safeActiveElement() {
    	try {
    		return document.activeElement;
    	} catch ( err ) { }
    }

    function on( elem, types, selector, data, fn, one ) {
    	var origFn, type;

    	// Types can be a map of types/handlers
    	if ( typeof types === "object" ) {

    		// ( types-Object, selector, data )
    		if ( typeof selector !== "string" ) {

    			// ( types-Object, data )
    			data = data || selector;
    			selector = undefined;
    		}
    		for ( type in types ) {
    			on( elem, type, selector, data, types[ type ], one );
    		}
    		return elem;
    	}

    	if ( data == null && fn == null ) {

    		// ( types, fn )
    		fn = selector;
    		data = selector = undefined;
    	} else if ( fn == null ) {
    		if ( typeof selector === "string" ) {

    			// ( types, selector, fn )
    			fn = data;
    			data = undefined;
    		} else {

    			// ( types, data, fn )
    			fn = data;
    			data = selector;
    			selector = undefined;
    		}
    	}
    	if ( fn === false ) {
    		fn = returnFalse;
    	} else if ( !fn ) {
    		return elem;
    	}

    	if ( one === 1 ) {
    		origFn = fn;
    		fn = function( event ) {

    			// Can use an empty set, since event contains the info
    			jQuery().off( event );
    			return origFn.apply( this, arguments );
    		};

    		// Use same guid so caller can remove using origFn
    		fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
    	}
    	return elem.each( function() {
    		jQuery.event.add( this, types, fn, data, selector );
    	} );
    }

    /*
     * Helper functions for managing events -- not part of the public interface.
     * Props to Dean Edwards' addEvent library for many of the ideas.
     */
    jQuery.event = {

    	global: {},

    	add: function( elem, types, handler, data, selector ) {

    		var handleObjIn, eventHandle, tmp,
    			events, t, handleObj,
    			special, handlers, type, namespaces, origType,
    			elemData = dataPriv.get( elem );

    		// Don't attach events to noData or text/comment nodes (but allow plain objects)
    		if ( !elemData ) {
    			return;
    		}

    		// Caller can pass in an object of custom data in lieu of the handler
    		if ( handler.handler ) {
    			handleObjIn = handler;
    			handler = handleObjIn.handler;
    			selector = handleObjIn.selector;
    		}

    		// Ensure that invalid selectors throw exceptions at attach time
    		// Evaluate against documentElement in case elem is a non-element node (e.g., document)
    		if ( selector ) {
    			jQuery.find.matchesSelector( documentElement, selector );
    		}

    		// Make sure that the handler has a unique ID, used to find/remove it later
    		if ( !handler.guid ) {
    			handler.guid = jQuery.guid++;
    		}

    		// Init the element's event structure and main handler, if this is the first
    		if ( !( events = elemData.events ) ) {
    			events = elemData.events = {};
    		}
    		if ( !( eventHandle = elemData.handle ) ) {
    			eventHandle = elemData.handle = function( e ) {

    				// Discard the second event of a jQuery.event.trigger() and
    				// when an event is called after a page has unloaded
    				return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
    					jQuery.event.dispatch.apply( elem, arguments ) : undefined;
    			};
    		}

    		// Handle multiple events separated by a space
    		types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
    		t = types.length;
    		while ( t-- ) {
    			tmp = rtypenamespace.exec( types[ t ] ) || [];
    			type = origType = tmp[ 1 ];
    			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();

    			// There *must* be a type, no attaching namespace-only handlers
    			if ( !type ) {
    				continue;
    			}

    			// If event changes its type, use the special event handlers for the changed type
    			special = jQuery.event.special[ type ] || {};

    			// If selector defined, determine special event api type, otherwise given type
    			type = ( selector ? special.delegateType : special.bindType ) || type;

    			// Update special based on newly reset type
    			special = jQuery.event.special[ type ] || {};

    			// handleObj is passed to all event handlers
    			handleObj = jQuery.extend( {
    				type: type,
    				origType: origType,
    				data: data,
    				handler: handler,
    				guid: handler.guid,
    				selector: selector,
    				needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
    				namespace: namespaces.join( "." )
    			}, handleObjIn );

    			// Init the event handler queue if we're the first
    			if ( !( handlers = events[ type ] ) ) {
    				handlers = events[ type ] = [];
    				handlers.delegateCount = 0;

    				// Only use addEventListener if the special events handler returns false
    				if ( !special.setup ||
    					special.setup.call( elem, data, namespaces, eventHandle ) === false ) {

    					if ( elem.addEventListener ) {
    						elem.addEventListener( type, eventHandle );
    					}
    				}
    			}

    			if ( special.add ) {
    				special.add.call( elem, handleObj );

    				if ( !handleObj.handler.guid ) {
    					handleObj.handler.guid = handler.guid;
    				}
    			}

    			// Add to the element's handler list, delegates in front
    			if ( selector ) {
    				handlers.splice( handlers.delegateCount++, 0, handleObj );
    			} else {
    				handlers.push( handleObj );
    			}

    			// Keep track of which events have ever been used, for event optimization
    			jQuery.event.global[ type ] = true;
    		}

    	},

    	// Detach an event or set of events from an element
    	remove: function( elem, types, handler, selector, mappedTypes ) {

    		var j, origCount, tmp,
    			events, t, handleObj,
    			special, handlers, type, namespaces, origType,
    			elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );

    		if ( !elemData || !( events = elemData.events ) ) {
    			return;
    		}

    		// Once for each type.namespace in types; type may be omitted
    		types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
    		t = types.length;
    		while ( t-- ) {
    			tmp = rtypenamespace.exec( types[ t ] ) || [];
    			type = origType = tmp[ 1 ];
    			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();

    			// Unbind all events (on this namespace, if provided) for the element
    			if ( !type ) {
    				for ( type in events ) {
    					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
    				}
    				continue;
    			}

    			special = jQuery.event.special[ type ] || {};
    			type = ( selector ? special.delegateType : special.bindType ) || type;
    			handlers = events[ type ] || [];
    			tmp = tmp[ 2 ] &&
    				new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );

    			// Remove matching events
    			origCount = j = handlers.length;
    			while ( j-- ) {
    				handleObj = handlers[ j ];

    				if ( ( mappedTypes || origType === handleObj.origType ) &&
    					( !handler || handler.guid === handleObj.guid ) &&
    					( !tmp || tmp.test( handleObj.namespace ) ) &&
    					( !selector || selector === handleObj.selector ||
    						selector === "**" && handleObj.selector ) ) {
    					handlers.splice( j, 1 );

    					if ( handleObj.selector ) {
    						handlers.delegateCount--;
    					}
    					if ( special.remove ) {
    						special.remove.call( elem, handleObj );
    					}
    				}
    			}

    			// Remove generic event handler if we removed something and no more handlers exist
    			// (avoids potential for endless recursion during removal of special event handlers)
    			if ( origCount && !handlers.length ) {
    				if ( !special.teardown ||
    					special.teardown.call( elem, namespaces, elemData.handle ) === false ) {

    					jQuery.removeEvent( elem, type, elemData.handle );
    				}

    				delete events[ type ];
    			}
    		}

    		// Remove data and the expando if it's no longer used
    		if ( jQuery.isEmptyObject( events ) ) {
    			dataPriv.remove( elem, "handle events" );
    		}
    	},

    	dispatch: function( nativeEvent ) {

    		// Make a writable jQuery.Event from the native event object
    		var event = jQuery.event.fix( nativeEvent );

    		var i, j, ret, matched, handleObj, handlerQueue,
    			args = new Array( arguments.length ),
    			handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [],
    			special = jQuery.event.special[ event.type ] || {};

    		// Use the fix-ed jQuery.Event rather than the (read-only) native event
    		args[ 0 ] = event;

    		for ( i = 1; i < arguments.length; i++ ) {
    			args[ i ] = arguments[ i ];
    		}

    		event.delegateTarget = this;

    		// Call the preDispatch hook for the mapped type, and let it bail if desired
    		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
    			return;
    		}

    		// Determine handlers
    		handlerQueue = jQuery.event.handlers.call( this, event, handlers );

    		// Run delegates first; they may want to stop propagation beneath us
    		i = 0;
    		while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
    			event.currentTarget = matched.elem;

    			j = 0;
    			while ( ( handleObj = matched.handlers[ j++ ] ) &&
    				!event.isImmediatePropagationStopped() ) {

    				// Triggered event must either 1) have no namespace, or 2) have namespace(s)
    				// a subset or equal to those in the bound event (both can have no namespace).
    				if ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) {

    					event.handleObj = handleObj;
    					event.data = handleObj.data;

    					ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
    						handleObj.handler ).apply( matched.elem, args );

    					if ( ret !== undefined ) {
    						if ( ( event.result = ret ) === false ) {
    							event.preventDefault();
    							event.stopPropagation();
    						}
    					}
    				}
    			}
    		}

    		// Call the postDispatch hook for the mapped type
    		if ( special.postDispatch ) {
    			special.postDispatch.call( this, event );
    		}

    		return event.result;
    	},

    	handlers: function( event, handlers ) {
    		var i, handleObj, sel, matchedHandlers, matchedSelectors,
    			handlerQueue = [],
    			delegateCount = handlers.delegateCount,
    			cur = event.target;

    		// Find delegate handlers
    		if ( delegateCount &&

    			// Support: IE <=9
    			// Black-hole SVG <use> instance trees (trac-13180)
    			cur.nodeType &&

    			// Support: Firefox <=42
    			// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
    			// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
    			// Support: IE 11 only
    			// ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
    			!( event.type === "click" && event.button >= 1 ) ) {

    			for ( ; cur !== this; cur = cur.parentNode || this ) {

    				// Don't check non-elements (#13208)
    				// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
    				if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
    					matchedHandlers = [];
    					matchedSelectors = {};
    					for ( i = 0; i < delegateCount; i++ ) {
    						handleObj = handlers[ i ];

    						// Don't conflict with Object.prototype properties (#13203)
    						sel = handleObj.selector + " ";

    						if ( matchedSelectors[ sel ] === undefined ) {
    							matchedSelectors[ sel ] = handleObj.needsContext ?
    								jQuery( sel, this ).index( cur ) > -1 :
    								jQuery.find( sel, this, null, [ cur ] ).length;
    						}
    						if ( matchedSelectors[ sel ] ) {
    							matchedHandlers.push( handleObj );
    						}
    					}
    					if ( matchedHandlers.length ) {
    						handlerQueue.push( { elem: cur, handlers: matchedHandlers } );
    					}
    				}
    			}
    		}

    		// Add the remaining (directly-bound) handlers
    		cur = this;
    		if ( delegateCount < handlers.length ) {
    			handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
    		}

    		return handlerQueue;
    	},

    	addProp: function( name, hook ) {
    		Object.defineProperty( jQuery.Event.prototype, name, {
    			enumerable: true,
    			configurable: true,

    			get: jQuery.isFunction( hook ) ?
    				function() {
    					if ( this.originalEvent ) {
    							return hook( this.originalEvent );
    					}
    				} :
    				function() {
    					if ( this.originalEvent ) {
    							return this.originalEvent[ name ];
    					}
    				},

    			set: function( value ) {
    				Object.defineProperty( this, name, {
    					enumerable: true,
    					configurable: true,
    					writable: true,
    					value: value
    				} );
    			}
    		} );
    	},

    	fix: function( originalEvent ) {
    		return originalEvent[ jQuery.expando ] ?
    			originalEvent :
    			new jQuery.Event( originalEvent );
    	},

    	special: {
    		load: {

    			// Prevent triggered image.load events from bubbling to window.load
    			noBubble: true
    		},
    		focus: {

    			// Fire native event if possible so blur/focus sequence is correct
    			trigger: function() {
    				if ( this !== safeActiveElement() && this.focus ) {
    					this.focus();
    					return false;
    				}
    			},
    			delegateType: "focusin"
    		},
    		blur: {
    			trigger: function() {
    				if ( this === safeActiveElement() && this.blur ) {
    					this.blur();
    					return false;
    				}
    			},
    			delegateType: "focusout"
    		},
    		click: {

    			// For checkbox, fire native event so checked state will be right
    			trigger: function() {
    				if ( this.type === "checkbox" && this.click && jQuery.nodeName( this, "input" ) ) {
    					this.click();
    					return false;
    				}
    			},

    			// For cross-browser consistency, don't fire native .click() on links
    			_default: function( event ) {
    				return jQuery.nodeName( event.target, "a" );
    			}
    		},

    		beforeunload: {
    			postDispatch: function( event ) {

    				// Support: Firefox 20+
    				// Firefox doesn't alert if the returnValue field is not set.
    				if ( event.result !== undefined && event.originalEvent ) {
    					event.originalEvent.returnValue = event.result;
    				}
    			}
    		}
    	}
    };

    jQuery.removeEvent = function( elem, type, handle ) {

    	// This "if" is needed for plain objects
    	if ( elem.removeEventListener ) {
    		elem.removeEventListener( type, handle );
    	}
    };

    jQuery.Event = function( src, props ) {

    	// Allow instantiation without the 'new' keyword
    	if ( !( this instanceof jQuery.Event ) ) {
    		return new jQuery.Event( src, props );
    	}

    	// Event object
    	if ( src && src.type ) {
    		this.originalEvent = src;
    		this.type = src.type;

    		// Events bubbling up the document may have been marked as prevented
    		// by a handler lower down the tree; reflect the correct value.
    		this.isDefaultPrevented = src.defaultPrevented ||
    				src.defaultPrevented === undefined &&

    				// Support: Android <=2.3 only
    				src.returnValue === false ?
    			returnTrue :
    			returnFalse;

    		// Create target properties
    		// Support: Safari <=6 - 7 only
    		// Target should not be a text node (#504, #13143)
    		this.target = ( src.target && src.target.nodeType === 3 ) ?
    			src.target.parentNode :
    			src.target;

    		this.currentTarget = src.currentTarget;
    		this.relatedTarget = src.relatedTarget;

    	// Event type
    	} else {
    		this.type = src;
    	}

    	// Put explicitly provided properties onto the event object
    	if ( props ) {
    		jQuery.extend( this, props );
    	}

    	// Create a timestamp if incoming event doesn't have one
    	this.timeStamp = src && src.timeStamp || jQuery.now();

    	// Mark it as fixed
    	this[ jQuery.expando ] = true;
    };

    // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
    // https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
    jQuery.Event.prototype = {
    	constructor: jQuery.Event,
    	isDefaultPrevented: returnFalse,
    	isPropagationStopped: returnFalse,
    	isImmediatePropagationStopped: returnFalse,
    	isSimulated: false,

    	preventDefault: function() {
    		var e = this.originalEvent;

    		this.isDefaultPrevented = returnTrue;

    		if ( e && !this.isSimulated ) {
    			e.preventDefault();
    		}
    	},
    	stopPropagation: function() {
    		var e = this.originalEvent;

    		this.isPropagationStopped = returnTrue;

    		if ( e && !this.isSimulated ) {
    			e.stopPropagation();
    		}
    	},
    	stopImmediatePropagation: function() {
    		var e = this.originalEvent;

    		this.isImmediatePropagationStopped = returnTrue;

    		if ( e && !this.isSimulated ) {
    			e.stopImmediatePropagation();
    		}

    		this.stopPropagation();
    	}
    };

    // Includes all common event props including KeyEvent and MouseEvent specific props
    jQuery.each( {
    	altKey: true,
    	bubbles: true,
    	cancelable: true,
    	changedTouches: true,
    	ctrlKey: true,
    	detail: true,
    	eventPhase: true,
    	metaKey: true,
    	pageX: true,
    	pageY: true,
    	shiftKey: true,
    	view: true,
    	"char": true,
    	charCode: true,
    	key: true,
    	keyCode: true,
    	button: true,
    	buttons: true,
    	clientX: true,
    	clientY: true,
    	offsetX: true,
    	offsetY: true,
    	pointerId: true,
    	pointerType: true,
    	screenX: true,
    	screenY: true,
    	targetTouches: true,
    	toElement: true,
    	touches: true,

    	which: function( event ) {
    		var button = event.button;

    		// Add which for key events
    		if ( event.which == null && rkeyEvent.test( event.type ) ) {
    			return event.charCode != null ? event.charCode : event.keyCode;
    		}

    		// Add which for click: 1 === left; 2 === middle; 3 === right
    		if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) {
    			if ( button & 1 ) {
    				return 1;
    			}

    			if ( button & 2 ) {
    				return 3;
    			}

    			if ( button & 4 ) {
    				return 2;
    			}

    			return 0;
    		}

    		return event.which;
    	}
    }, jQuery.event.addProp );

    // Create mouseenter/leave events using mouseover/out and event-time checks
    // so that event delegation works in jQuery.
    // Do the same for pointerenter/pointerleave and pointerover/pointerout
    //
    // Support: Safari 7 only
    // Safari sends mouseenter too often; see:
    // https://bugs.chromium.org/p/chromium/issues/detail?id=470258
    // for the description of the bug (it existed in older Chrome versions as well).
    jQuery.each( {
    	mouseenter: "mouseover",
    	mouseleave: "mouseout",
    	pointerenter: "pointerover",
    	pointerleave: "pointerout"
    }, function( orig, fix ) {
    	jQuery.event.special[ orig ] = {
    		delegateType: fix,
    		bindType: fix,

    		handle: function( event ) {
    			var ret,
    				target = this,
    				related = event.relatedTarget,
    				handleObj = event.handleObj;

    			// For mouseenter/leave call the handler if related is outside the target.
    			// NB: No relatedTarget if the mouse left/entered the browser window
    			if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
    				event.type = handleObj.origType;
    				ret = handleObj.handler.apply( this, arguments );
    				event.type = fix;
    			}
    			return ret;
    		}
    	};
    } );

    jQuery.fn.extend( {

    	on: function( types, selector, data, fn ) {
    		return on( this, types, selector, data, fn );
    	},
    	one: function( types, selector, data, fn ) {
    		return on( this, types, selector, data, fn, 1 );
    	},
    	off: function( types, selector, fn ) {
    		var handleObj, type;
    		if ( types && types.preventDefault && types.handleObj ) {

    			// ( event )  dispatched jQuery.Event
    			handleObj = types.handleObj;
    			jQuery( types.delegateTarget ).off(
    				handleObj.namespace ?
    					handleObj.origType + "." + handleObj.namespace :
    					handleObj.origType,
    				handleObj.selector,
    				handleObj.handler
    			);
    			return this;
    		}
    		if ( typeof types === "object" ) {

    			// ( types-object [, selector] )
    			for ( type in types ) {
    				this.off( type, selector, types[ type ] );
    			}
    			return this;
    		}
    		if ( selector === false || typeof selector === "function" ) {

    			// ( types [, fn] )
    			fn = selector;
    			selector = undefined;
    		}
    		if ( fn === false ) {
    			fn = returnFalse;
    		}
    		return this.each( function() {
    			jQuery.event.remove( this, types, fn, selector );
    		} );
    	}
    } );

    var

    	/* eslint-disable max-len */

    	// See https://github.com/eslint/eslint/issues/3229
    	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,

    	/* eslint-enable */

    	// Support: IE <=10 - 11, Edge 12 - 13
    	// In IE/Edge using regex groups here causes severe slowdowns.
    	// See https://connect.microsoft.com/IE/feedback/details/1736512/
    	rnoInnerhtml = /<script|<style|<link/i,

    	// checked="checked" or checked
    	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
    	rscriptTypeMasked = /^true\/(.*)/,
    	rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;

    function manipulationTarget( elem, content ) {
    	if ( jQuery.nodeName( elem, "table" ) &&
    		jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {

    		return elem.getElementsByTagName( "tbody" )[ 0 ] || elem;
    	}

    	return elem;
    }

    // Replace/restore the type attribute of script elements for safe DOM manipulation
    function disableScript( elem ) {
    	elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
    	return elem;
    }
    function restoreScript( elem ) {
    	var match = rscriptTypeMasked.exec( elem.type );

    	if ( match ) {
    		elem.type = match[ 1 ];
    	} else {
    		elem.removeAttribute( "type" );
    	}

    	return elem;
    }

    function cloneCopyEvent( src, dest ) {
    	var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;

    	if ( dest.nodeType !== 1 ) {
    		return;
    	}

    	// 1. Copy private data: events, handlers, etc.
    	if ( dataPriv.hasData( src ) ) {
    		pdataOld = dataPriv.access( src );
    		pdataCur = dataPriv.set( dest, pdataOld );
    		events = pdataOld.events;

    		if ( events ) {
    			delete pdataCur.handle;
    			pdataCur.events = {};

    			for ( type in events ) {
    				for ( i = 0, l = events[ type ].length; i < l; i++ ) {
    					jQuery.event.add( dest, type, events[ type ][ i ] );
    				}
    			}
    		}
    	}

    	// 2. Copy user data
    	if ( dataUser.hasData( src ) ) {
    		udataOld = dataUser.access( src );
    		udataCur = jQuery.extend( {}, udataOld );

    		dataUser.set( dest, udataCur );
    	}
    }

    // Fix IE bugs, see support tests
    function fixInput( src, dest ) {
    	var nodeName = dest.nodeName.toLowerCase();

    	// Fails to persist the checked state of a cloned checkbox or radio button.
    	if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
    		dest.checked = src.checked;

    	// Fails to return the selected option to the default selected state when cloning options
    	} else if ( nodeName === "input" || nodeName === "textarea" ) {
    		dest.defaultValue = src.defaultValue;
    	}
    }

    function domManip( collection, args, callback, ignored ) {

    	// Flatten any nested arrays
    	args = concat.apply( [], args );

    	var fragment, first, scripts, hasScripts, node, doc,
    		i = 0,
    		l = collection.length,
    		iNoClone = l - 1,
    		value = args[ 0 ],
    		isFunction = jQuery.isFunction( value );

    	// We can't cloneNode fragments that contain checked, in WebKit
    	if ( isFunction ||
    			( l > 1 && typeof value === "string" &&
    				!support.checkClone && rchecked.test( value ) ) ) {
    		return collection.each( function( index ) {
    			var self = collection.eq( index );
    			if ( isFunction ) {
    				args[ 0 ] = value.call( this, index, self.html() );
    			}
    			domManip( self, args, callback, ignored );
    		} );
    	}

    	if ( l ) {
    		fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
    		first = fragment.firstChild;

    		if ( fragment.childNodes.length === 1 ) {
    			fragment = first;
    		}

    		// Require either new content or an interest in ignored elements to invoke the callback
    		if ( first || ignored ) {
    			scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
    			hasScripts = scripts.length;

    			// Use the original fragment for the last item
    			// instead of the first because it can end up
    			// being emptied incorrectly in certain situations (#8070).
    			for ( ; i < l; i++ ) {
    				node = fragment;

    				if ( i !== iNoClone ) {
    					node = jQuery.clone( node, true, true );

    					// Keep references to cloned scripts for later restoration
    					if ( hasScripts ) {

    						// Support: Android <=4.0 only, PhantomJS 1 only
    						// push.apply(_, arraylike) throws on ancient WebKit
    						jQuery.merge( scripts, getAll( node, "script" ) );
    					}
    				}

    				callback.call( collection[ i ], node, i );
    			}

    			if ( hasScripts ) {
    				doc = scripts[ scripts.length - 1 ].ownerDocument;

    				// Reenable scripts
    				jQuery.map( scripts, restoreScript );

    				// Evaluate executable scripts on first document insertion
    				for ( i = 0; i < hasScripts; i++ ) {
    					node = scripts[ i ];
    					if ( rscriptType.test( node.type || "" ) &&
    						!dataPriv.access( node, "globalEval" ) &&
    						jQuery.contains( doc, node ) ) {

    						if ( node.src ) {

    							// Optional AJAX dependency, but won't run scripts if not present
    							if ( jQuery._evalUrl ) {
    								jQuery._evalUrl( node.src );
    							}
    						} else {
    							DOMEval( node.textContent.replace( rcleanScript, "" ), doc );
    						}
    					}
    				}
    			}
    		}
    	}

    	return collection;
    }

    function remove( elem, selector, keepData ) {
    	var node,
    		nodes = selector ? jQuery.filter( selector, elem ) : elem,
    		i = 0;

    	for ( ; ( node = nodes[ i ] ) != null; i++ ) {
    		if ( !keepData && node.nodeType === 1 ) {
    			jQuery.cleanData( getAll( node ) );
    		}

    		if ( node.parentNode ) {
    			if ( keepData && jQuery.contains( node.ownerDocument, node ) ) {
    				setGlobalEval( getAll( node, "script" ) );
    			}
    			node.parentNode.removeChild( node );
    		}
    	}

    	return elem;
    }

    jQuery.extend( {
    	htmlPrefilter: function( html ) {
    		return html.replace( rxhtmlTag, "<$1></$2>" );
    	},

    	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
    		var i, l, srcElements, destElements,
    			clone = elem.cloneNode( true ),
    			inPage = jQuery.contains( elem.ownerDocument, elem );

    		// Fix IE cloning issues
    		if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
    				!jQuery.isXMLDoc( elem ) ) {

    			// We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
    			destElements = getAll( clone );
    			srcElements = getAll( elem );

    			for ( i = 0, l = srcElements.length; i < l; i++ ) {
    				fixInput( srcElements[ i ], destElements[ i ] );
    			}
    		}

    		// Copy the events from the original to the clone
    		if ( dataAndEvents ) {
    			if ( deepDataAndEvents ) {
    				srcElements = srcElements || getAll( elem );
    				destElements = destElements || getAll( clone );

    				for ( i = 0, l = srcElements.length; i < l; i++ ) {
    					cloneCopyEvent( srcElements[ i ], destElements[ i ] );
    				}
    			} else {
    				cloneCopyEvent( elem, clone );
    			}
    		}

    		// Preserve script evaluation history
    		destElements = getAll( clone, "script" );
    		if ( destElements.length > 0 ) {
    			setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
    		}

    		// Return the cloned set
    		return clone;
    	},

    	cleanData: function( elems ) {
    		var data, elem, type,
    			special = jQuery.event.special,
    			i = 0;

    		for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
    			if ( acceptData( elem ) ) {
    				if ( ( data = elem[ dataPriv.expando ] ) ) {
    					if ( data.events ) {
    						for ( type in data.events ) {
    							if ( special[ type ] ) {
    								jQuery.event.remove( elem, type );

    							// This is a shortcut to avoid jQuery.event.remove's overhead
    							} else {
    								jQuery.removeEvent( elem, type, data.handle );
    							}
    						}
    					}

    					// Support: Chrome <=35 - 45+
    					// Assign undefined instead of using delete, see Data#remove
    					elem[ dataPriv.expando ] = undefined;
    				}
    				if ( elem[ dataUser.expando ] ) {

    					// Support: Chrome <=35 - 45+
    					// Assign undefined instead of using delete, see Data#remove
    					elem[ dataUser.expando ] = undefined;
    				}
    			}
    		}
    	}
    } );

    jQuery.fn.extend( {
    	detach: function( selector ) {
    		return remove( this, selector, true );
    	},

    	remove: function( selector ) {
    		return remove( this, selector );
    	},

    	text: function( value ) {
    		return access( this, function( value ) {
    			return value === undefined ?
    				jQuery.text( this ) :
    				this.empty().each( function() {
    					if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
    						this.textContent = value;
    					}
    				} );
    		}, null, value, arguments.length );
    	},

    	append: function() {
    		return domManip( this, arguments, function( elem ) {
    			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
    				var target = manipulationTarget( this, elem );
    				target.appendChild( elem );
    			}
    		} );
    	},

    	prepend: function() {
    		return domManip( this, arguments, function( elem ) {
    			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
    				var target = manipulationTarget( this, elem );
    				target.insertBefore( elem, target.firstChild );
    			}
    		} );
    	},

    	before: function() {
    		return domManip( this, arguments, function( elem ) {
    			if ( this.parentNode ) {
    				this.parentNode.insertBefore( elem, this );
    			}
    		} );
    	},

    	after: function() {
    		return domManip( this, arguments, function( elem ) {
    			if ( this.parentNode ) {
    				this.parentNode.insertBefore( elem, this.nextSibling );
    			}
    		} );
    	},

    	empty: function() {
    		var elem,
    			i = 0;

    		for ( ; ( elem = this[ i ] ) != null; i++ ) {
    			if ( elem.nodeType === 1 ) {

    				// Prevent memory leaks
    				jQuery.cleanData( getAll( elem, false ) );

    				// Remove any remaining nodes
    				elem.textContent = "";
    			}
    		}

    		return this;
    	},

    	clone: function( dataAndEvents, deepDataAndEvents ) {
    		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
    		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;

    		return this.map( function() {
    			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
    		} );
    	},

    	html: function( value ) {
    		return access( this, function( value ) {
    			var elem = this[ 0 ] || {},
    				i = 0,
    				l = this.length;

    			if ( value === undefined && elem.nodeType === 1 ) {
    				return elem.innerHTML;
    			}

    			// See if we can take a shortcut and just use innerHTML
    			if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
    				!wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {

    				value = jQuery.htmlPrefilter( value );

    				try {
    					for ( ; i < l; i++ ) {
    						elem = this[ i ] || {};

    						// Remove element nodes and prevent memory leaks
    						if ( elem.nodeType === 1 ) {
    							jQuery.cleanData( getAll( elem, false ) );
    							elem.innerHTML = value;
    						}
    					}

    					elem = 0;

    				// If using innerHTML throws an exception, use the fallback method
    				} catch ( e ) {}
    			}

    			if ( elem ) {
    				this.empty().append( value );
    			}
    		}, null, value, arguments.length );
    	},

    	replaceWith: function() {
    		var ignored = [];

    		// Make the changes, replacing each non-ignored context element with the new content
    		return domManip( this, arguments, function( elem ) {
    			var parent = this.parentNode;

    			if ( jQuery.inArray( this, ignored ) < 0 ) {
    				jQuery.cleanData( getAll( this ) );
    				if ( parent ) {
    					parent.replaceChild( elem, this );
    				}
    			}

    		// Force callback invocation
    		}, ignored );
    	}
    } );

    jQuery.each( {
    	appendTo: "append",
    	prependTo: "prepend",
    	insertBefore: "before",
    	insertAfter: "after",
    	replaceAll: "replaceWith"
    }, function( name, original ) {
    	jQuery.fn[ name ] = function( selector ) {
    		var elems,
    			ret = [],
    			insert = jQuery( selector ),
    			last = insert.length - 1,
    			i = 0;

    		for ( ; i <= last; i++ ) {
    			elems = i === last ? this : this.clone( true );
    			jQuery( insert[ i ] )[ original ]( elems );

    			// Support: Android <=4.0 only, PhantomJS 1 only
    			// .get() because push.apply(_, arraylike) throws on ancient WebKit
    			push.apply( ret, elems.get() );
    		}

    		return this.pushStack( ret );
    	};
    } );
    var rmargin = ( /^margin/ );

    var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );

    var getStyles = function( elem ) {

    		// Support: IE <=11 only, Firefox <=30 (#15098, #14150)
    		// IE throws on elements created in popups
    		// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
    		var view = elem.ownerDocument.defaultView;

    		if ( !view || !view.opener ) {
    			view = window;
    		}

    		return view.getComputedStyle( elem );
    	};

    ( function() {

    	// Executing both pixelPosition & boxSizingReliable tests require only one layout
    	// so they're executed at the same time to save the second computation.
    	function computeStyleTests() {

    		// This is a singleton, we need to execute it only once
    		if ( !div ) {
    			return;
    		}

    		div.style.cssText =
    			"box-sizing:border-box;" +
    			"position:relative;display:block;" +
    			"margin:auto;border:1px;padding:1px;" +
    			"top:1%;width:50%";
    		div.innerHTML = "";
    		documentElement.appendChild( container );

    		var divStyle = window.getComputedStyle( div );
    		pixelPositionVal = divStyle.top !== "1%";

    		// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
    		reliableMarginLeftVal = divStyle.marginLeft === "2px";
    		boxSizingReliableVal = divStyle.width === "4px";

    		// Support: Android 4.0 - 4.3 only
    		// Some styles come back with percentage values, even though they shouldn't
    		div.style.marginRight = "50%";
    		pixelMarginRightVal = divStyle.marginRight === "4px";

    		documentElement.removeChild( container );

    		// Nullify the div so it wouldn't be stored in the memory and
    		// it will also be a sign that checks already performed
    		div = null;
    	}

    	var pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, reliableMarginLeftVal,
    		container = document.createElement( "div" ),
    		div = document.createElement( "div" );

    	// Finish early in limited (non-browser) environments
    	if ( !div.style ) {
    		return;
    	}

    	// Support: IE <=9 - 11 only
    	// Style of cloned element affects source element cloned (#8908)
    	div.style.backgroundClip = "content-box";
    	div.cloneNode( true ).style.backgroundClip = "";
    	support.clearCloneStyle = div.style.backgroundClip === "content-box";

    	container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" +
    		"padding:0;margin-top:1px;position:absolute";
    	container.appendChild( div );

    	jQuery.extend( support, {
    		pixelPosition: function() {
    			computeStyleTests();
    			return pixelPositionVal;
    		},
    		boxSizingReliable: function() {
    			computeStyleTests();
    			return boxSizingReliableVal;
    		},
    		pixelMarginRight: function() {
    			computeStyleTests();
    			return pixelMarginRightVal;
    		},
    		reliableMarginLeft: function() {
    			computeStyleTests();
    			return reliableMarginLeftVal;
    		}
    	} );
    } )();

    function curCSS( elem, name, computed ) {
    	var width, minWidth, maxWidth, ret,
    		style = elem.style;

    	computed = computed || getStyles( elem );

    	// Support: IE <=9 only
    	// getPropertyValue is only needed for .css('filter') (#12537)
    	if ( computed ) {
    		ret = computed.getPropertyValue( name ) || computed[ name ];

    		if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) {
    			ret = jQuery.style( elem, name );
    		}

    		// A tribute to the "awesome hack by Dean Edwards"
    		// Android Browser returns percentage for some values,
    		// but width seems to be reliably pixels.
    		// This is against the CSSOM draft spec:
    		// https://drafts.csswg.org/cssom/#resolved-values
    		if ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) {

    			// Remember the original values
    			width = style.width;
    			minWidth = style.minWidth;
    			maxWidth = style.maxWidth;

    			// Put in the new values to get a computed value out
    			style.minWidth = style.maxWidth = style.width = ret;
    			ret = computed.width;

    			// Revert the changed values
    			style.width = width;
    			style.minWidth = minWidth;
    			style.maxWidth = maxWidth;
    		}
    	}

    	return ret !== undefined ?

    		// Support: IE <=9 - 11 only
    		// IE returns zIndex value as an integer.
    		ret + "" :
    		ret;
    }

    function addGetHookIf( conditionFn, hookFn ) {

    	// Define the hook, we'll check on the first run if it's really needed.
    	return {
    		get: function() {
    			if ( conditionFn() ) {

    				// Hook not needed (or it's not possible to use it due
    				// to missing dependency), remove it.
    				delete this.get;
    				return;
    			}

    			// Hook needed; redefine it so that the support test is not executed again.
    			return ( this.get = hookFn ).apply( this, arguments );
    		}
    	};
    }

    var

    	// Swappable if display is none or starts with table
    	// except "table", "table-cell", or "table-caption"
    	// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
    	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
    	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
    	cssNormalTransform = {
    		letterSpacing: "0",
    		fontWeight: "400"
    	},

    	cssPrefixes = [ "Webkit", "Moz", "ms" ],
    	emptyStyle = document.createElement( "div" ).style;

    // Return a css property mapped to a potentially vendor prefixed property
    function vendorPropName( name ) {

    	// Shortcut for names that are not vendor prefixed
    	if ( name in emptyStyle ) {
    		return name;
    	}

    	// Check for vendor prefixed names
    	var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
    		i = cssPrefixes.length;

    	while ( i-- ) {
    		name = cssPrefixes[ i ] + capName;
    		if ( name in emptyStyle ) {
    			return name;
    		}
    	}
    }

    function setPositiveNumber( elem, value, subtract ) {

    	// Any relative (+/-) values have already been
    	// normalized at this point
    	var matches = rcssNum.exec( value );
    	return matches ?

    		// Guard against undefined "subtract", e.g., when used as in cssHooks
    		Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
    		value;
    }

    function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
    	var i,
    		val = 0;

    	// If we already have the right measurement, avoid augmentation
    	if ( extra === ( isBorderBox ? "border" : "content" ) ) {
    		i = 4;

    	// Otherwise initialize for horizontal or vertical properties
    	} else {
    		i = name === "width" ? 1 : 0;
    	}

    	for ( ; i < 4; i += 2 ) {

    		// Both box models exclude margin, so add it if we want it
    		if ( extra === "margin" ) {
    			val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
    		}

    		if ( isBorderBox ) {

    			// border-box includes padding, so remove it if we want content
    			if ( extra === "content" ) {
    				val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
    			}

    			// At this point, extra isn't border nor margin, so remove border
    			if ( extra !== "margin" ) {
    				val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
    			}
    		} else {

    			// At this point, extra isn't content, so add padding
    			val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );

    			// At this point, extra isn't content nor padding, so add border
    			if ( extra !== "padding" ) {
    				val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
    			}
    		}
    	}

    	return val;
    }

    function getWidthOrHeight( elem, name, extra ) {

    	// Start with offset property, which is equivalent to the border-box value
    	var val,
    		valueIsBorderBox = true,
    		styles = getStyles( elem ),
    		isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";

    	// Support: IE <=11 only
    	// Running getBoundingClientRect on a disconnected node
    	// in IE throws an error.
    	if ( elem.getClientRects().length ) {
    		val = elem.getBoundingClientRect()[ name ];
    	}

    	// Some non-html elements return undefined for offsetWidth, so check for null/undefined
    	// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
    	// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
    	if ( val <= 0 || val == null ) {

    		// Fall back to computed then uncomputed css if necessary
    		val = curCSS( elem, name, styles );
    		if ( val < 0 || val == null ) {
    			val = elem.style[ name ];
    		}

    		// Computed unit is not pixels. Stop here and return.
    		if ( rnumnonpx.test( val ) ) {
    			return val;
    		}

    		// Check for style in case a browser which returns unreliable values
    		// for getComputedStyle silently falls back to the reliable elem.style
    		valueIsBorderBox = isBorderBox &&
    			( support.boxSizingReliable() || val === elem.style[ name ] );

    		// Normalize "", auto, and prepare for extra
    		val = parseFloat( val ) || 0;
    	}

    	// Use the active box-sizing model to add/subtract irrelevant styles
    	return ( val +
    		augmentWidthOrHeight(
    			elem,
    			name,
    			extra || ( isBorderBox ? "border" : "content" ),
    			valueIsBorderBox,
    			styles
    		)
    	) + "px";
    }

    jQuery.extend( {

    	// Add in style property hooks for overriding the default
    	// behavior of getting and setting a style property
    	cssHooks: {
    		opacity: {
    			get: function( elem, computed ) {
    				if ( computed ) {

    					// We should always get a number back from opacity
    					var ret = curCSS( elem, "opacity" );
    					return ret === "" ? "1" : ret;
    				}
    			}
    		}
    	},

    	// Don't automatically add "px" to these possibly-unitless properties
    	cssNumber: {
    		"animationIterationCount": true,
    		"columnCount": true,
    		"fillOpacity": true,
    		"flexGrow": true,
    		"flexShrink": true,
    		"fontWeight": true,
    		"lineHeight": true,
    		"opacity": true,
    		"order": true,
    		"orphans": true,
    		"widows": true,
    		"zIndex": true,
    		"zoom": true
    	},

    	// Add in properties whose names you wish to fix before
    	// setting or getting the value
    	cssProps: {
    		"float": "cssFloat"
    	},

    	// Get and set the style property on a DOM Node
    	style: function( elem, name, value, extra ) {

    		// Don't set styles on text and comment nodes
    		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
    			return;
    		}

    		// Make sure that we're working with the right name
    		var ret, type, hooks,
    			origName = jQuery.camelCase( name ),
    			style = elem.style;

    		name = jQuery.cssProps[ origName ] ||
    			( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );

    		// Gets hook for the prefixed version, then unprefixed version
    		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];

    		// Check if we're setting a value
    		if ( value !== undefined ) {
    			type = typeof value;

    			// Convert "+=" or "-=" to relative numbers (#7345)
    			if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
    				value = adjustCSS( elem, name, ret );

    				// Fixes bug #9237
    				type = "number";
    			}

    			// Make sure that null and NaN values aren't set (#7116)
    			if ( value == null || value !== value ) {
    				return;
    			}

    			// If a number was passed in, add the unit (except for certain CSS properties)
    			if ( type === "number" ) {
    				value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
    			}

    			// background-* props affect original clone's values
    			if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
    				style[ name ] = "inherit";
    			}

    			// If a hook was provided, use that value, otherwise just set the specified value
    			if ( !hooks || !( "set" in hooks ) ||
    				( value = hooks.set( elem, value, extra ) ) !== undefined ) {

    				style[ name ] = value;
    			}

    		} else {

    			// If a hook was provided get the non-computed value from there
    			if ( hooks && "get" in hooks &&
    				( ret = hooks.get( elem, false, extra ) ) !== undefined ) {

    				return ret;
    			}

    			// Otherwise just get the value from the style object
    			return style[ name ];
    		}
    	},

    	css: function( elem, name, extra, styles ) {
    		var val, num, hooks,
    			origName = jQuery.camelCase( name );

    		// Make sure that we're working with the right name
    		name = jQuery.cssProps[ origName ] ||
    			( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );

    		// Try prefixed name followed by the unprefixed name
    		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];

    		// If a hook was provided get the computed value from there
    		if ( hooks && "get" in hooks ) {
    			val = hooks.get( elem, true, extra );
    		}

    		// Otherwise, if a way to get the computed value exists, use that
    		if ( val === undefined ) {
    			val = curCSS( elem, name, styles );
    		}

    		// Convert "normal" to computed value
    		if ( val === "normal" && name in cssNormalTransform ) {
    			val = cssNormalTransform[ name ];
    		}

    		// Make numeric if forced or a qualifier was provided and val looks numeric
    		if ( extra === "" || extra ) {
    			num = parseFloat( val );
    			return extra === true || isFinite( num ) ? num || 0 : val;
    		}
    		return val;
    	}
    } );

    jQuery.each( [ "height", "width" ], function( i, name ) {
    	jQuery.cssHooks[ name ] = {
    		get: function( elem, computed, extra ) {
    			if ( computed ) {

    				// Certain elements can have dimension info if we invisibly show them
    				// but it must have a current display style that would benefit
    				return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&

    					// Support: Safari 8+
    					// Table columns in Safari have non-zero offsetWidth & zero
    					// getBoundingClientRect().width unless display is changed.
    					// Support: IE <=11 only
    					// Running getBoundingClientRect on a disconnected node
    					// in IE throws an error.
    					( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
    						swap( elem, cssShow, function() {
    							return getWidthOrHeight( elem, name, extra );
    						} ) :
    						getWidthOrHeight( elem, name, extra );
    			}
    		},

    		set: function( elem, value, extra ) {
    			var matches,
    				styles = extra && getStyles( elem ),
    				subtract = extra && augmentWidthOrHeight(
    					elem,
    					name,
    					extra,
    					jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
    					styles
    				);

    			// Convert to pixels if value adjustment is needed
    			if ( subtract && ( matches = rcssNum.exec( value ) ) &&
    				( matches[ 3 ] || "px" ) !== "px" ) {

    				elem.style[ name ] = value;
    				value = jQuery.css( elem, name );
    			}

    			return setPositiveNumber( elem, value, subtract );
    		}
    	};
    } );

    jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
    	function( elem, computed ) {
    		if ( computed ) {
    			return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
    				elem.getBoundingClientRect().left -
    					swap( elem, { marginLeft: 0 }, function() {
    						return elem.getBoundingClientRect().left;
    					} )
    				) + "px";
    		}
    	}
    );

    // These hooks are used by animate to expand properties
    jQuery.each( {
    	margin: "",
    	padding: "",
    	border: "Width"
    }, function( prefix, suffix ) {
    	jQuery.cssHooks[ prefix + suffix ] = {
    		expand: function( value ) {
    			var i = 0,
    				expanded = {},

    				// Assumes a single number if not a string
    				parts = typeof value === "string" ? value.split( " " ) : [ value ];

    			for ( ; i < 4; i++ ) {
    				expanded[ prefix + cssExpand[ i ] + suffix ] =
    					parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
    			}

    			return expanded;
    		}
    	};

    	if ( !rmargin.test( prefix ) ) {
    		jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
    	}
    } );

    jQuery.fn.extend( {
    	css: function( name, value ) {
    		return access( this, function( elem, name, value ) {
    			var styles, len,
    				map = {},
    				i = 0;

    			if ( jQuery.isArray( name ) ) {
    				styles = getStyles( elem );
    				len = name.length;

    				for ( ; i < len; i++ ) {
    					map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
    				}

    				return map;
    			}

    			return value !== undefined ?
    				jQuery.style( elem, name, value ) :
    				jQuery.css( elem, name );
    		}, name, value, arguments.length > 1 );
    	}
    } );

    function Tween( elem, options, prop, end, easing ) {
    	return new Tween.prototype.init( elem, options, prop, end, easing );
    }
    jQuery.Tween = Tween;

    Tween.prototype = {
    	constructor: Tween,
    	init: function( elem, options, prop, end, easing, unit ) {
    		this.elem = elem;
    		this.prop = prop;
    		this.easing = easing || jQuery.easing._default;
    		this.options = options;
    		this.start = this.now = this.cur();
    		this.end = end;
    		this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
    	},
    	cur: function() {
    		var hooks = Tween.propHooks[ this.prop ];

    		return hooks && hooks.get ?
    			hooks.get( this ) :
    			Tween.propHooks._default.get( this );
    	},
    	run: function( percent ) {
    		var eased,
    			hooks = Tween.propHooks[ this.prop ];

    		if ( this.options.duration ) {
    			this.pos = eased = jQuery.easing[ this.easing ](
    				percent, this.options.duration * percent, 0, 1, this.options.duration
    			);
    		} else {
    			this.pos = eased = percent;
    		}
    		this.now = ( this.end - this.start ) * eased + this.start;

    		if ( this.options.step ) {
    			this.options.step.call( this.elem, this.now, this );
    		}

    		if ( hooks && hooks.set ) {
    			hooks.set( this );
    		} else {
    			Tween.propHooks._default.set( this );
    		}
    		return this;
    	}
    };

    Tween.prototype.init.prototype = Tween.prototype;

    Tween.propHooks = {
    	_default: {
    		get: function( tween ) {
    			var result;

    			// Use a property on the element directly when it is not a DOM element,
    			// or when there is no matching style property that exists.
    			if ( tween.elem.nodeType !== 1 ||
    				tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
    				return tween.elem[ tween.prop ];
    			}

    			// Passing an empty string as a 3rd parameter to .css will automatically
    			// attempt a parseFloat and fallback to a string if the parse fails.
    			// Simple values such as "10px" are parsed to Float;
    			// complex values such as "rotate(1rad)" are returned as-is.
    			result = jQuery.css( tween.elem, tween.prop, "" );

    			// Empty strings, null, undefined and "auto" are converted to 0.
    			return !result || result === "auto" ? 0 : result;
    		},
    		set: function( tween ) {

    			// Use step hook for back compat.
    			// Use cssHook if its there.
    			// Use .style if available and use plain properties where available.
    			if ( jQuery.fx.step[ tween.prop ] ) {
    				jQuery.fx.step[ tween.prop ]( tween );
    			} else if ( tween.elem.nodeType === 1 &&
    				( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||
    					jQuery.cssHooks[ tween.prop ] ) ) {
    				jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
    			} else {
    				tween.elem[ tween.prop ] = tween.now;
    			}
    		}
    	}
    };

    // Support: IE <=9 only
    // Panic based approach to setting things on disconnected nodes
    Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
    	set: function( tween ) {
    		if ( tween.elem.nodeType && tween.elem.parentNode ) {
    			tween.elem[ tween.prop ] = tween.now;
    		}
    	}
    };

    jQuery.easing = {
    	linear: function( p ) {
    		return p;
    	},
    	swing: function( p ) {
    		return 0.5 - Math.cos( p * Math.PI ) / 2;
    	},
    	_default: "swing"
    };

    jQuery.fx = Tween.prototype.init;

    // Back compat <1.8 extension point
    jQuery.fx.step = {};

    var
    	fxNow, timerId,
    	rfxtypes = /^(?:toggle|show|hide)$/,
    	rrun = /queueHooks$/;

    function raf() {
    	if ( timerId ) {
    		window.requestAnimationFrame( raf );
    		jQuery.fx.tick();
    	}
    }

    // Animations created synchronously will run synchronously
    function createFxNow() {
    	window.setTimeout( function() {
    		fxNow = undefined;
    	} );
    	return ( fxNow = jQuery.now() );
    }

    // Generate parameters to create a standard animation
    function genFx( type, includeWidth ) {
    	var which,
    		i = 0,
    		attrs = { height: type };

    	// If we include width, step value is 1 to do all cssExpand values,
    	// otherwise step value is 2 to skip over Left and Right
    	includeWidth = includeWidth ? 1 : 0;
    	for ( ; i < 4; i += 2 - includeWidth ) {
    		which = cssExpand[ i ];
    		attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
    	}

    	if ( includeWidth ) {
    		attrs.opacity = attrs.width = type;
    	}

    	return attrs;
    }

    function createTween( value, prop, animation ) {
    	var tween,
    		collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
    		index = 0,
    		length = collection.length;
    	for ( ; index < length; index++ ) {
    		if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {

    			// We're done with this property
    			return tween;
    		}
    	}
    }

    function defaultPrefilter( elem, props, opts ) {
    	var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
    		isBox = "width" in props || "height" in props,
    		anim = this,
    		orig = {},
    		style = elem.style,
    		hidden = elem.nodeType && isHiddenWithinTree( elem ),
    		dataShow = dataPriv.get( elem, "fxshow" );

    	// Queue-skipping animations hijack the fx hooks
    	if ( !opts.queue ) {
    		hooks = jQuery._queueHooks( elem, "fx" );
    		if ( hooks.unqueued == null ) {
    			hooks.unqueued = 0;
    			oldfire = hooks.empty.fire;
    			hooks.empty.fire = function() {
    				if ( !hooks.unqueued ) {
    					oldfire();
    				}
    			};
    		}
    		hooks.unqueued++;

    		anim.always( function() {

    			// Ensure the complete handler is called before this completes
    			anim.always( function() {
    				hooks.unqueued--;
    				if ( !jQuery.queue( elem, "fx" ).length ) {
    					hooks.empty.fire();
    				}
    			} );
    		} );
    	}

    	// Detect show/hide animations
    	for ( prop in props ) {
    		value = props[ prop ];
    		if ( rfxtypes.test( value ) ) {
    			delete props[ prop ];
    			toggle = toggle || value === "toggle";
    			if ( value === ( hidden ? "hide" : "show" ) ) {

    				// Pretend to be hidden if this is a "show" and
    				// there is still data from a stopped show/hide
    				if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
    					hidden = true;

    				// Ignore all other no-op show/hide data
    				} else {
    					continue;
    				}
    			}
    			orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
    		}
    	}

    	// Bail out if this is a no-op like .hide().hide()
    	propTween = !jQuery.isEmptyObject( props );
    	if ( !propTween && jQuery.isEmptyObject( orig ) ) {
    		return;
    	}

    	// Restrict "overflow" and "display" styles during box animations
    	if ( isBox && elem.nodeType === 1 ) {

    		// Support: IE <=9 - 11, Edge 12 - 13
    		// Record all 3 overflow attributes because IE does not infer the shorthand
    		// from identically-valued overflowX and overflowY
    		opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];

    		// Identify a display type, preferring old show/hide data over the CSS cascade
    		restoreDisplay = dataShow && dataShow.display;
    		if ( restoreDisplay == null ) {
    			restoreDisplay = dataPriv.get( elem, "display" );
    		}
    		display = jQuery.css( elem, "display" );
    		if ( display === "none" ) {
    			if ( restoreDisplay ) {
    				display = restoreDisplay;
    			} else {

    				// Get nonempty value(s) by temporarily forcing visibility
    				showHide( [ elem ], true );
    				restoreDisplay = elem.style.display || restoreDisplay;
    				display = jQuery.css( elem, "display" );
    				showHide( [ elem ] );
    			}
    		}

    		// Animate inline elements as inline-block
    		if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) {
    			if ( jQuery.css( elem, "float" ) === "none" ) {

    				// Restore the original display value at the end of pure show/hide animations
    				if ( !propTween ) {
    					anim.done( function() {
    						style.display = restoreDisplay;
    					} );
    					if ( restoreDisplay == null ) {
    						display = style.display;
    						restoreDisplay = display === "none" ? "" : display;
    					}
    				}
    				style.display = "inline-block";
    			}
    		}
    	}

    	if ( opts.overflow ) {
    		style.overflow = "hidden";
    		anim.always( function() {
    			style.overflow = opts.overflow[ 0 ];
    			style.overflowX = opts.overflow[ 1 ];
    			style.overflowY = opts.overflow[ 2 ];
    		} );
    	}

    	// Implement show/hide animations
    	propTween = false;
    	for ( prop in orig ) {

    		// General show/hide setup for this element animation
    		if ( !propTween ) {
    			if ( dataShow ) {
    				if ( "hidden" in dataShow ) {
    					hidden = dataShow.hidden;
    				}
    			} else {
    				dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } );
    			}

    			// Store hidden/visible for toggle so `.stop().toggle()` "reverses"
    			if ( toggle ) {
    				dataShow.hidden = !hidden;
    			}

    			// Show elements before animating them
    			if ( hidden ) {
    				showHide( [ elem ], true );
    			}

    			/* eslint-disable no-loop-func */

    			anim.done( function() {

    			/* eslint-enable no-loop-func */

    				// The final step of a "hide" animation is actually hiding the element
    				if ( !hidden ) {
    					showHide( [ elem ] );
    				}
    				dataPriv.remove( elem, "fxshow" );
    				for ( prop in orig ) {
    					jQuery.style( elem, prop, orig[ prop ] );
    				}
    			} );
    		}

    		// Per-property setup
    		propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
    		if ( !( prop in dataShow ) ) {
    			dataShow[ prop ] = propTween.start;
    			if ( hidden ) {
    				propTween.end = propTween.start;
    				propTween.start = 0;
    			}
    		}
    	}
    }

    function propFilter( props, specialEasing ) {
    	var index, name, easing, value, hooks;

    	// camelCase, specialEasing and expand cssHook pass
    	for ( index in props ) {
    		name = jQuery.camelCase( index );
    		easing = specialEasing[ name ];
    		value = props[ index ];
    		if ( jQuery.isArray( value ) ) {
    			easing = value[ 1 ];
    			value = props[ index ] = value[ 0 ];
    		}

    		if ( index !== name ) {
    			props[ name ] = value;
    			delete props[ index ];
    		}

    		hooks = jQuery.cssHooks[ name ];
    		if ( hooks && "expand" in hooks ) {
    			value = hooks.expand( value );
    			delete props[ name ];

    			// Not quite $.extend, this won't overwrite existing keys.
    			// Reusing 'index' because we have the correct "name"
    			for ( index in value ) {
    				if ( !( index in props ) ) {
    					props[ index ] = value[ index ];
    					specialEasing[ index ] = easing;
    				}
    			}
    		} else {
    			specialEasing[ name ] = easing;
    		}
    	}
    }

    function Animation( elem, properties, options ) {
    	var result,
    		stopped,
    		index = 0,
    		length = Animation.prefilters.length,
    		deferred = jQuery.Deferred().always( function() {

    			// Don't match elem in the :animated selector
    			delete tick.elem;
    		} ),
    		tick = function() {
    			if ( stopped ) {
    				return false;
    			}
    			var currentTime = fxNow || createFxNow(),
    				remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),

    				// Support: Android 2.3 only
    				// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
    				temp = remaining / animation.duration || 0,
    				percent = 1 - temp,
    				index = 0,
    				length = animation.tweens.length;

    			for ( ; index < length; index++ ) {
    				animation.tweens[ index ].run( percent );
    			}

    			deferred.notifyWith( elem, [ animation, percent, remaining ] );

    			if ( percent < 1 && length ) {
    				return remaining;
    			} else {
    				deferred.resolveWith( elem, [ animation ] );
    				return false;
    			}
    		},
    		animation = deferred.promise( {
    			elem: elem,
    			props: jQuery.extend( {}, properties ),
    			opts: jQuery.extend( true, {
    				specialEasing: {},
    				easing: jQuery.easing._default
    			}, options ),
    			originalProperties: properties,
    			originalOptions: options,
    			startTime: fxNow || createFxNow(),
    			duration: options.duration,
    			tweens: [],
    			createTween: function( prop, end ) {
    				var tween = jQuery.Tween( elem, animation.opts, prop, end,
    						animation.opts.specialEasing[ prop ] || animation.opts.easing );
    				animation.tweens.push( tween );
    				return tween;
    			},
    			stop: function( gotoEnd ) {
    				var index = 0,

    					// If we are going to the end, we want to run all the tweens
    					// otherwise we skip this part
    					length = gotoEnd ? animation.tweens.length : 0;
    				if ( stopped ) {
    					return this;
    				}
    				stopped = true;
    				for ( ; index < length; index++ ) {
    					animation.tweens[ index ].run( 1 );
    				}

    				// Resolve when we played the last frame; otherwise, reject
    				if ( gotoEnd ) {
    					deferred.notifyWith( elem, [ animation, 1, 0 ] );
    					deferred.resolveWith( elem, [ animation, gotoEnd ] );
    				} else {
    					deferred.rejectWith( elem, [ animation, gotoEnd ] );
    				}
    				return this;
    			}
    		} ),
    		props = animation.props;

    	propFilter( props, animation.opts.specialEasing );

    	for ( ; index < length; index++ ) {
    		result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
    		if ( result ) {
    			if ( jQuery.isFunction( result.stop ) ) {
    				jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
    					jQuery.proxy( result.stop, result );
    			}
    			return result;
    		}
    	}

    	jQuery.map( props, createTween, animation );

    	if ( jQuery.isFunction( animation.opts.start ) ) {
    		animation.opts.start.call( elem, animation );
    	}

    	jQuery.fx.timer(
    		jQuery.extend( tick, {
    			elem: elem,
    			anim: animation,
    			queue: animation.opts.queue
    		} )
    	);

    	// attach callbacks from options
    	return animation.progress( animation.opts.progress )
    		.done( animation.opts.done, animation.opts.complete )
    		.fail( animation.opts.fail )
    		.always( animation.opts.always );
    }

    jQuery.Animation = jQuery.extend( Animation, {

    	tweeners: {
    		"*": [ function( prop, value ) {
    			var tween = this.createTween( prop, value );
    			adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
    			return tween;
    		} ]
    	},

    	tweener: function( props, callback ) {
    		if ( jQuery.isFunction( props ) ) {
    			callback = props;
    			props = [ "*" ];
    		} else {
    			props = props.match( rnothtmlwhite );
    		}

    		var prop,
    			index = 0,
    			length = props.length;

    		for ( ; index < length; index++ ) {
    			prop = props[ index ];
    			Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
    			Animation.tweeners[ prop ].unshift( callback );
    		}
    	},

    	prefilters: [ defaultPrefilter ],

    	prefilter: function( callback, prepend ) {
    		if ( prepend ) {
    			Animation.prefilters.unshift( callback );
    		} else {
    			Animation.prefilters.push( callback );
    		}
    	}
    } );

    jQuery.speed = function( speed, easing, fn ) {
    	var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
    		complete: fn || !fn && easing ||
    			jQuery.isFunction( speed ) && speed,
    		duration: speed,
    		easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
    	};

    	// Go to the end state if fx are off or if document is hidden
    	if ( jQuery.fx.off || document.hidden ) {
    		opt.duration = 0;

    	} else {
    		if ( typeof opt.duration !== "number" ) {
    			if ( opt.duration in jQuery.fx.speeds ) {
    				opt.duration = jQuery.fx.speeds[ opt.duration ];

    			} else {
    				opt.duration = jQuery.fx.speeds._default;
    			}
    		}
    	}

    	// Normalize opt.queue - true/undefined/null -> "fx"
    	if ( opt.queue == null || opt.queue === true ) {
    		opt.queue = "fx";
    	}

    	// Queueing
    	opt.old = opt.complete;

    	opt.complete = function() {
    		if ( jQuery.isFunction( opt.old ) ) {
    			opt.old.call( this );
    		}

    		if ( opt.queue ) {
    			jQuery.dequeue( this, opt.queue );
    		}
    	};

    	return opt;
    };

    jQuery.fn.extend( {
    	fadeTo: function( speed, to, easing, callback ) {

    		// Show any hidden elements after setting opacity to 0
    		return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()

    			// Animate to the value specified
    			.end().animate( { opacity: to }, speed, easing, callback );
    	},
    	animate: function( prop, speed, easing, callback ) {
    		var empty = jQuery.isEmptyObject( prop ),
    			optall = jQuery.speed( speed, easing, callback ),
    			doAnimation = function() {

    				// Operate on a copy of prop so per-property easing won't be lost
    				var anim = Animation( this, jQuery.extend( {}, prop ), optall );

    				// Empty animations, or finishing resolves immediately
    				if ( empty || dataPriv.get( this, "finish" ) ) {
    					anim.stop( true );
    				}
    			};
    			doAnimation.finish = doAnimation;

    		return empty || optall.queue === false ?
    			this.each( doAnimation ) :
    			this.queue( optall.queue, doAnimation );
    	},
    	stop: function( type, clearQueue, gotoEnd ) {
    		var stopQueue = function( hooks ) {
    			var stop = hooks.stop;
    			delete hooks.stop;
    			stop( gotoEnd );
    		};

    		if ( typeof type !== "string" ) {
    			gotoEnd = clearQueue;
    			clearQueue = type;
    			type = undefined;
    		}
    		if ( clearQueue && type !== false ) {
    			this.queue( type || "fx", [] );
    		}

    		return this.each( function() {
    			var dequeue = true,
    				index = type != null && type + "queueHooks",
    				timers = jQuery.timers,
    				data = dataPriv.get( this );

    			if ( index ) {
    				if ( data[ index ] && data[ index ].stop ) {
    					stopQueue( data[ index ] );
    				}
    			} else {
    				for ( index in data ) {
    					if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
    						stopQueue( data[ index ] );
    					}
    				}
    			}

    			for ( index = timers.length; index--; ) {
    				if ( timers[ index ].elem === this &&
    					( type == null || timers[ index ].queue === type ) ) {

    					timers[ index ].anim.stop( gotoEnd );
    					dequeue = false;
    					timers.splice( index, 1 );
    				}
    			}

    			// Start the next in the queue if the last step wasn't forced.
    			// Timers currently will call their complete callbacks, which
    			// will dequeue but only if they were gotoEnd.
    			if ( dequeue || !gotoEnd ) {
    				jQuery.dequeue( this, type );
    			}
    		} );
    	},
    	finish: function( type ) {
    		if ( type !== false ) {
    			type = type || "fx";
    		}
    		return this.each( function() {
    			var index,
    				data = dataPriv.get( this ),
    				queue = data[ type + "queue" ],
    				hooks = data[ type + "queueHooks" ],
    				timers = jQuery.timers,
    				length = queue ? queue.length : 0;

    			// Enable finishing flag on private data
    			data.finish = true;

    			// Empty the queue first
    			jQuery.queue( this, type, [] );

    			if ( hooks && hooks.stop ) {
    				hooks.stop.call( this, true );
    			}

    			// Look for any active animations, and finish them
    			for ( index = timers.length; index--; ) {
    				if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
    					timers[ index ].anim.stop( true );
    					timers.splice( index, 1 );
    				}
    			}

    			// Look for any animations in the old queue and finish them
    			for ( index = 0; index < length; index++ ) {
    				if ( queue[ index ] && queue[ index ].finish ) {
    					queue[ index ].finish.call( this );
    				}
    			}

    			// Turn off finishing flag
    			delete data.finish;
    		} );
    	}
    } );

    jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) {
    	var cssFn = jQuery.fn[ name ];
    	jQuery.fn[ name ] = function( speed, easing, callback ) {
    		return speed == null || typeof speed === "boolean" ?
    			cssFn.apply( this, arguments ) :
    			this.animate( genFx( name, true ), speed, easing, callback );
    	};
    } );

    // Generate shortcuts for custom animations
    jQuery.each( {
    	slideDown: genFx( "show" ),
    	slideUp: genFx( "hide" ),
    	slideToggle: genFx( "toggle" ),
    	fadeIn: { opacity: "show" },
    	fadeOut: { opacity: "hide" },
    	fadeToggle: { opacity: "toggle" }
    }, function( name, props ) {
    	jQuery.fn[ name ] = function( speed, easing, callback ) {
    		return this.animate( props, speed, easing, callback );
    	};
    } );

    jQuery.timers = [];
    jQuery.fx.tick = function() {
    	var timer,
    		i = 0,
    		timers = jQuery.timers;

    	fxNow = jQuery.now();

    	for ( ; i < timers.length; i++ ) {
    		timer = timers[ i ];

    		// Checks the timer has not already been removed
    		if ( !timer() && timers[ i ] === timer ) {
    			timers.splice( i--, 1 );
    		}
    	}

    	if ( !timers.length ) {
    		jQuery.fx.stop();
    	}
    	fxNow = undefined;
    };

    jQuery.fx.timer = function( timer ) {
    	jQuery.timers.push( timer );
    	if ( timer() ) {
    		jQuery.fx.start();
    	} else {
    		jQuery.timers.pop();
    	}
    };

    jQuery.fx.interval = 13;
    jQuery.fx.start = function() {
    	if ( !timerId ) {
    		timerId = window.requestAnimationFrame ?
    			window.requestAnimationFrame( raf ) :
    			window.setInterval( jQuery.fx.tick, jQuery.fx.interval );
    	}
    };

    jQuery.fx.stop = function() {
    	if ( window.cancelAnimationFrame ) {
    		window.cancelAnimationFrame( timerId );
    	} else {
    		window.clearInterval( timerId );
    	}

    	timerId = null;
    };

    jQuery.fx.speeds = {
    	slow: 600,
    	fast: 200,

    	// Default speed
    	_default: 400
    };

    // Based off of the plugin by Clint Helfers, with permission.
    // https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
    jQuery.fn.delay = function( time, type ) {
    	time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
    	type = type || "fx";

    	return this.queue( type, function( next, hooks ) {
    		var timeout = window.setTimeout( next, time );
    		hooks.stop = function() {
    			window.clearTimeout( timeout );
    		};
    	} );
    };

    ( function() {
    	var input = document.createElement( "input" ),
    		select = document.createElement( "select" ),
    		opt = select.appendChild( document.createElement( "option" ) );

    	input.type = "checkbox";

    	// Support: Android <=4.3 only
    	// Default value for a checkbox should be "on"
    	support.checkOn = input.value !== "";

    	// Support: IE <=11 only
    	// Must access selectedIndex to make default options select
    	support.optSelected = opt.selected;

    	// Support: IE <=11 only
    	// An input loses its value after becoming a radio
    	input = document.createElement( "input" );
    	input.value = "t";
    	input.type = "radio";
    	support.radioValue = input.value === "t";
    } )();

    var boolHook,
    	attrHandle = jQuery.expr.attrHandle;

    jQuery.fn.extend( {
    	attr: function( name, value ) {
    		return access( this, jQuery.attr, name, value, arguments.length > 1 );
    	},

    	removeAttr: function( name ) {
    		return this.each( function() {
    			jQuery.removeAttr( this, name );
    		} );
    	}
    } );

    jQuery.extend( {
    	attr: function( elem, name, value ) {
    		var ret, hooks,
    			nType = elem.nodeType;

    		// Don't get/set attributes on text, comment and attribute nodes
    		if ( nType === 3 || nType === 8 || nType === 2 ) {
    			return;
    		}

    		// Fallback to prop when attributes are not supported
    		if ( typeof elem.getAttribute === "undefined" ) {
    			return jQuery.prop( elem, name, value );
    		}

    		// Attribute hooks are determined by the lowercase version
    		// Grab necessary hook if one is defined
    		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
    			hooks = jQuery.attrHooks[ name.toLowerCase() ] ||
    				( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
    		}

    		if ( value !== undefined ) {
    			if ( value === null ) {
    				jQuery.removeAttr( elem, name );
    				return;
    			}

    			if ( hooks && "set" in hooks &&
    				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
    				return ret;
    			}

    			elem.setAttribute( name, value + "" );
    			return value;
    		}

    		if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
    			return ret;
    		}

    		ret = jQuery.find.attr( elem, name );

    		// Non-existent attributes return null, we normalize to undefined
    		return ret == null ? undefined : ret;
    	},

    	attrHooks: {
    		type: {
    			set: function( elem, value ) {
    				if ( !support.radioValue && value === "radio" &&
    					jQuery.nodeName( elem, "input" ) ) {
    					var val = elem.value;
    					elem.setAttribute( "type", value );
    					if ( val ) {
    						elem.value = val;
    					}
    					return value;
    				}
    			}
    		}
    	},

    	removeAttr: function( elem, value ) {
    		var name,
    			i = 0,

    			// Attribute names can contain non-HTML whitespace characters
    			// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
    			attrNames = value && value.match( rnothtmlwhite );

    		if ( attrNames && elem.nodeType === 1 ) {
    			while ( ( name = attrNames[ i++ ] ) ) {
    				elem.removeAttribute( name );
    			}
    		}
    	}
    } );

    // Hooks for boolean attributes
    boolHook = {
    	set: function( elem, value, name ) {
    		if ( value === false ) {

    			// Remove boolean attributes when set to false
    			jQuery.removeAttr( elem, name );
    		} else {
    			elem.setAttribute( name, name );
    		}
    		return name;
    	}
    };

    jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
    	var getter = attrHandle[ name ] || jQuery.find.attr;

    	attrHandle[ name ] = function( elem, name, isXML ) {
    		var ret, handle,
    			lowercaseName = name.toLowerCase();

    		if ( !isXML ) {

    			// Avoid an infinite loop by temporarily removing this function from the getter
    			handle = attrHandle[ lowercaseName ];
    			attrHandle[ lowercaseName ] = ret;
    			ret = getter( elem, name, isXML ) != null ?
    				lowercaseName :
    				null;
    			attrHandle[ lowercaseName ] = handle;
    		}
    		return ret;
    	};
    } );

    var rfocusable = /^(?:input|select|textarea|button)$/i,
    	rclickable = /^(?:a|area)$/i;

    jQuery.fn.extend( {
    	prop: function( name, value ) {
    		return access( this, jQuery.prop, name, value, arguments.length > 1 );
    	},

    	removeProp: function( name ) {
    		return this.each( function() {
    			delete this[ jQuery.propFix[ name ] || name ];
    		} );
    	}
    } );

    jQuery.extend( {
    	prop: function( elem, name, value ) {
    		var ret, hooks,
    			nType = elem.nodeType;

    		// Don't get/set properties on text, comment and attribute nodes
    		if ( nType === 3 || nType === 8 || nType === 2 ) {
    			return;
    		}

    		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {

    			// Fix name and attach hooks
    			name = jQuery.propFix[ name ] || name;
    			hooks = jQuery.propHooks[ name ];
    		}

    		if ( value !== undefined ) {
    			if ( hooks && "set" in hooks &&
    				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
    				return ret;
    			}

    			return ( elem[ name ] = value );
    		}

    		if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
    			return ret;
    		}

    		return elem[ name ];
    	},

    	propHooks: {
    		tabIndex: {
    			get: function( elem ) {

    				// Support: IE <=9 - 11 only
    				// elem.tabIndex doesn't always return the
    				// correct value when it hasn't been explicitly set
    				// https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
    				// Use proper attribute retrieval(#12072)
    				var tabindex = jQuery.find.attr( elem, "tabindex" );

    				if ( tabindex ) {
    					return parseInt( tabindex, 10 );
    				}

    				if (
    					rfocusable.test( elem.nodeName ) ||
    					rclickable.test( elem.nodeName ) &&
    					elem.href
    				) {
    					return 0;
    				}

    				return -1;
    			}
    		}
    	},

    	propFix: {
    		"for": "htmlFor",
    		"class": "className"
    	}
    } );

    // Support: IE <=11 only
    // Accessing the selectedIndex property
    // forces the browser to respect setting selected
    // on the option
    // The getter ensures a default option is selected
    // when in an optgroup
    // eslint rule "no-unused-expressions" is disabled for this code
    // since it considers such accessions noop
    if ( !support.optSelected ) {
    	jQuery.propHooks.selected = {
    		get: function( elem ) {

    			/* eslint no-unused-expressions: "off" */

    			var parent = elem.parentNode;
    			if ( parent && parent.parentNode ) {
    				parent.parentNode.selectedIndex;
    			}
    			return null;
    		},
    		set: function( elem ) {

    			/* eslint no-unused-expressions: "off" */

    			var parent = elem.parentNode;
    			if ( parent ) {
    				parent.selectedIndex;

    				if ( parent.parentNode ) {
    					parent.parentNode.selectedIndex;
    				}
    			}
    		}
    	};
    }

    jQuery.each( [
    	"tabIndex",
    	"readOnly",
    	"maxLength",
    	"cellSpacing",
    	"cellPadding",
    	"rowSpan",
    	"colSpan",
    	"useMap",
    	"frameBorder",
    	"contentEditable"
    ], function() {
    	jQuery.propFix[ this.toLowerCase() ] = this;
    } );

    	// Strip and collapse whitespace according to HTML spec
    	// https://html.spec.whatwg.org/multipage/infrastructure.html#strip-and-collapse-whitespace
    	function stripAndCollapse( value ) {
    		var tokens = value.match( rnothtmlwhite ) || [];
    		return tokens.join( " " );
    	}

    function getClass( elem ) {
    	return elem.getAttribute && elem.getAttribute( "class" ) || "";
    }

    jQuery.fn.extend( {
    	addClass: function( value ) {
    		var classes, elem, cur, curValue, clazz, j, finalValue,
    			i = 0;

    		if ( jQuery.isFunction( value ) ) {
    			return this.each( function( j ) {
    				jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
    			} );
    		}

    		if ( typeof value === "string" && value ) {
    			classes = value.match( rnothtmlwhite ) || [];

    			while ( ( elem = this[ i++ ] ) ) {
    				curValue = getClass( elem );
    				cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );

    				if ( cur ) {
    					j = 0;
    					while ( ( clazz = classes[ j++ ] ) ) {
    						if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
    							cur += clazz + " ";
    						}
    					}

    					// Only assign if different to avoid unneeded rendering.
    					finalValue = stripAndCollapse( cur );
    					if ( curValue !== finalValue ) {
    						elem.setAttribute( "class", finalValue );
    					}
    				}
    			}
    		}

    		return this;
    	},

    	removeClass: function( value ) {
    		var classes, elem, cur, curValue, clazz, j, finalValue,
    			i = 0;

    		if ( jQuery.isFunction( value ) ) {
    			return this.each( function( j ) {
    				jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
    			} );
    		}

    		if ( !arguments.length ) {
    			return this.attr( "class", "" );
    		}

    		if ( typeof value === "string" && value ) {
    			classes = value.match( rnothtmlwhite ) || [];

    			while ( ( elem = this[ i++ ] ) ) {
    				curValue = getClass( elem );

    				// This expression is here for better compressibility (see addClass)
    				cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );

    				if ( cur ) {
    					j = 0;
    					while ( ( clazz = classes[ j++ ] ) ) {

    						// Remove *all* instances
    						while ( cur.indexOf( " " + clazz + " " ) > -1 ) {
    							cur = cur.replace( " " + clazz + " ", " " );
    						}
    					}

    					// Only assign if different to avoid unneeded rendering.
    					finalValue = stripAndCollapse( cur );
    					if ( curValue !== finalValue ) {
    						elem.setAttribute( "class", finalValue );
    					}
    				}
    			}
    		}

    		return this;
    	},

    	toggleClass: function( value, stateVal ) {
    		var type = typeof value;

    		if ( typeof stateVal === "boolean" && type === "string" ) {
    			return stateVal ? this.addClass( value ) : this.removeClass( value );
    		}

    		if ( jQuery.isFunction( value ) ) {
    			return this.each( function( i ) {
    				jQuery( this ).toggleClass(
    					value.call( this, i, getClass( this ), stateVal ),
    					stateVal
    				);
    			} );
    		}

    		return this.each( function() {
    			var className, i, self, classNames;

    			if ( type === "string" ) {

    				// Toggle individual class names
    				i = 0;
    				self = jQuery( this );
    				classNames = value.match( rnothtmlwhite ) || [];

    				while ( ( className = classNames[ i++ ] ) ) {

    					// Check each className given, space separated list
    					if ( self.hasClass( className ) ) {
    						self.removeClass( className );
    					} else {
    						self.addClass( className );
    					}
    				}

    			// Toggle whole class name
    			} else if ( value === undefined || type === "boolean" ) {
    				className = getClass( this );
    				if ( className ) {

    					// Store className if set
    					dataPriv.set( this, "__className__", className );
    				}

    				// If the element has a class name or if we're passed `false`,
    				// then remove the whole classname (if there was one, the above saved it).
    				// Otherwise bring back whatever was previously saved (if anything),
    				// falling back to the empty string if nothing was stored.
    				if ( this.setAttribute ) {
    					this.setAttribute( "class",
    						className || value === false ?
    						"" :
    						dataPriv.get( this, "__className__" ) || ""
    					);
    				}
    			}
    		} );
    	},

    	hasClass: function( selector ) {
    		var className, elem,
    			i = 0;

    		className = " " + selector + " ";
    		while ( ( elem = this[ i++ ] ) ) {
    			if ( elem.nodeType === 1 &&
    				( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) {
    					return true;
    			}
    		}

    		return false;
    	}
    } );

    var rreturn = /\r/g;

    jQuery.fn.extend( {
    	val: function( value ) {
    		var hooks, ret, isFunction,
    			elem = this[ 0 ];

    		if ( !arguments.length ) {
    			if ( elem ) {
    				hooks = jQuery.valHooks[ elem.type ] ||
    					jQuery.valHooks[ elem.nodeName.toLowerCase() ];

    				if ( hooks &&
    					"get" in hooks &&
    					( ret = hooks.get( elem, "value" ) ) !== undefined
    				) {
    					return ret;
    				}

    				ret = elem.value;

    				// Handle most common string cases
    				if ( typeof ret === "string" ) {
    					return ret.replace( rreturn, "" );
    				}

    				// Handle cases where value is null/undef or number
    				return ret == null ? "" : ret;
    			}

    			return;
    		}

    		isFunction = jQuery.isFunction( value );

    		return this.each( function( i ) {
    			var val;

    			if ( this.nodeType !== 1 ) {
    				return;
    			}

    			if ( isFunction ) {
    				val = value.call( this, i, jQuery( this ).val() );
    			} else {
    				val = value;
    			}

    			// Treat null/undefined as ""; convert numbers to string
    			if ( val == null ) {
    				val = "";

    			} else if ( typeof val === "number" ) {
    				val += "";

    			} else if ( jQuery.isArray( val ) ) {
    				val = jQuery.map( val, function( value ) {
    					return value == null ? "" : value + "";
    				} );
    			}

    			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];

    			// If set returns undefined, fall back to normal setting
    			if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
    				this.value = val;
    			}
    		} );
    	}
    } );

    jQuery.extend( {
    	valHooks: {
    		option: {
    			get: function( elem ) {

    				var val = jQuery.find.attr( elem, "value" );
    				return val != null ?
    					val :

    					// Support: IE <=10 - 11 only
    					// option.text throws exceptions (#14686, #14858)
    					// Strip and collapse whitespace
    					// https://html.spec.whatwg.org/#strip-and-collapse-whitespace
    					stripAndCollapse( jQuery.text( elem ) );
    			}
    		},
    		select: {
    			get: function( elem ) {
    				var value, option, i,
    					options = elem.options,
    					index = elem.selectedIndex,
    					one = elem.type === "select-one",
    					values = one ? null : [],
    					max = one ? index + 1 : options.length;

    				if ( index < 0 ) {
    					i = max;

    				} else {
    					i = one ? index : 0;
    				}

    				// Loop through all the selected options
    				for ( ; i < max; i++ ) {
    					option = options[ i ];

    					// Support: IE <=9 only
    					// IE8-9 doesn't update selected after form reset (#2551)
    					if ( ( option.selected || i === index ) &&

    							// Don't return options that are disabled or in a disabled optgroup
    							!option.disabled &&
    							( !option.parentNode.disabled ||
    								!jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {

    						// Get the specific value for the option
    						value = jQuery( option ).val();

    						// We don't need an array for one selects
    						if ( one ) {
    							return value;
    						}

    						// Multi-Selects return an array
    						values.push( value );
    					}
    				}

    				return values;
    			},

    			set: function( elem, value ) {
    				var optionSet, option,
    					options = elem.options,
    					values = jQuery.makeArray( value ),
    					i = options.length;

    				while ( i-- ) {
    					option = options[ i ];

    					/* eslint-disable no-cond-assign */

    					if ( option.selected =
    						jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1
    					) {
    						optionSet = true;
    					}

    					/* eslint-enable no-cond-assign */
    				}

    				// Force browsers to behave consistently when non-matching value is set
    				if ( !optionSet ) {
    					elem.selectedIndex = -1;
    				}
    				return values;
    			}
    		}
    	}
    } );

    // Radios and checkboxes getter/setter
    jQuery.each( [ "radio", "checkbox" ], function() {
    	jQuery.valHooks[ this ] = {
    		set: function( elem, value ) {
    			if ( jQuery.isArray( value ) ) {
    				return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
    			}
    		}
    	};
    	if ( !support.checkOn ) {
    		jQuery.valHooks[ this ].get = function( elem ) {
    			return elem.getAttribute( "value" ) === null ? "on" : elem.value;
    		};
    	}
    } );

    // Return jQuery for attributes-only inclusion

    var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;

    jQuery.extend( jQuery.event, {

    	trigger: function( event, data, elem, onlyHandlers ) {

    		var i, cur, tmp, bubbleType, ontype, handle, special,
    			eventPath = [ elem || document ],
    			type = hasOwn.call( event, "type" ) ? event.type : event,
    			namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];

    		cur = tmp = elem = elem || document;

    		// Don't do events on text and comment nodes
    		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
    			return;
    		}

    		// focus/blur morphs to focusin/out; ensure we're not firing them right now
    		if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
    			return;
    		}

    		if ( type.indexOf( "." ) > -1 ) {

    			// Namespaced trigger; create a regexp to match event type in handle()
    			namespaces = type.split( "." );
    			type = namespaces.shift();
    			namespaces.sort();
    		}
    		ontype = type.indexOf( ":" ) < 0 && "on" + type;

    		// Caller can pass in a jQuery.Event object, Object, or just an event type string
    		event = event[ jQuery.expando ] ?
    			event :
    			new jQuery.Event( type, typeof event === "object" && event );

    		// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
    		event.isTrigger = onlyHandlers ? 2 : 3;
    		event.namespace = namespaces.join( "." );
    		event.rnamespace = event.namespace ?
    			new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
    			null;

    		// Clean up the event in case it is being reused
    		event.result = undefined;
    		if ( !event.target ) {
    			event.target = elem;
    		}

    		// Clone any incoming data and prepend the event, creating the handler arg list
    		data = data == null ?
    			[ event ] :
    			jQuery.makeArray( data, [ event ] );

    		// Allow special events to draw outside the lines
    		special = jQuery.event.special[ type ] || {};
    		if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
    			return;
    		}

    		// Determine event propagation path in advance, per W3C events spec (#9951)
    		// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
    		if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {

    			bubbleType = special.delegateType || type;
    			if ( !rfocusMorph.test( bubbleType + type ) ) {
    				cur = cur.parentNode;
    			}
    			for ( ; cur; cur = cur.parentNode ) {
    				eventPath.push( cur );
    				tmp = cur;
    			}

    			// Only add window if we got to document (e.g., not plain obj or detached DOM)
    			if ( tmp === ( elem.ownerDocument || document ) ) {
    				eventPath.push( tmp.defaultView || tmp.parentWindow || window );
    			}
    		}

    		// Fire handlers on the event path
    		i = 0;
    		while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {

    			event.type = i > 1 ?
    				bubbleType :
    				special.bindType || type;

    			// jQuery handler
    			handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] &&
    				dataPriv.get( cur, "handle" );
    			if ( handle ) {
    				handle.apply( cur, data );
    			}

    			// Native handler
    			handle = ontype && cur[ ontype ];
    			if ( handle && handle.apply && acceptData( cur ) ) {
    				event.result = handle.apply( cur, data );
    				if ( event.result === false ) {
    					event.preventDefault();
    				}
    			}
    		}
    		event.type = type;

    		// If nobody prevented the default action, do it now
    		if ( !onlyHandlers && !event.isDefaultPrevented() ) {

    			if ( ( !special._default ||
    				special._default.apply( eventPath.pop(), data ) === false ) &&
    				acceptData( elem ) ) {

    				// Call a native DOM method on the target with the same name as the event.
    				// Don't do default actions on window, that's where global variables be (#6170)
    				if ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) {

    					// Don't re-trigger an onFOO event when we call its FOO() method
    					tmp = elem[ ontype ];

    					if ( tmp ) {
    						elem[ ontype ] = null;
    					}

    					// Prevent re-triggering of the same event, since we already bubbled it above
    					jQuery.event.triggered = type;
    					elem[ type ]();
    					jQuery.event.triggered = undefined;

    					if ( tmp ) {
    						elem[ ontype ] = tmp;
    					}
    				}
    			}
    		}

    		return event.result;
    	},

    	// Piggyback on a donor event to simulate a different one
    	// Used only for `focus(in | out)` events
    	simulate: function( type, elem, event ) {
    		var e = jQuery.extend(
    			new jQuery.Event(),
    			event,
    			{
    				type: type,
    				isSimulated: true
    			}
    		);

    		jQuery.event.trigger( e, null, elem );
    	}

    } );

    jQuery.fn.extend( {

    	trigger: function( type, data ) {
    		return this.each( function() {
    			jQuery.event.trigger( type, data, this );
    		} );
    	},
    	triggerHandler: function( type, data ) {
    		var elem = this[ 0 ];
    		if ( elem ) {
    			return jQuery.event.trigger( type, data, elem, true );
    		}
    	}
    } );

    jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " +
    	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
    	"change select submit keydown keypress keyup contextmenu" ).split( " " ),
    	function( i, name ) {

    	// Handle event binding
    	jQuery.fn[ name ] = function( data, fn ) {
    		return arguments.length > 0 ?
    			this.on( name, null, data, fn ) :
    			this.trigger( name );
    	};
    } );

    jQuery.fn.extend( {
    	hover: function( fnOver, fnOut ) {
    		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
    	}
    } );

    support.focusin = "onfocusin" in window;

    // Support: Firefox <=44
    // Firefox doesn't have focus(in | out) events
    // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
    //
    // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
    // focus(in | out) events fire after focus & blur events,
    // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
    // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
    if ( !support.focusin ) {
    	jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {

    		// Attach a single capturing handler on the document while someone wants focusin/focusout
    		var handler = function( event ) {
    			jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );
    		};

    		jQuery.event.special[ fix ] = {
    			setup: function() {
    				var doc = this.ownerDocument || this,
    					attaches = dataPriv.access( doc, fix );

    				if ( !attaches ) {
    					doc.addEventListener( orig, handler, true );
    				}
    				dataPriv.access( doc, fix, ( attaches || 0 ) + 1 );
    			},
    			teardown: function() {
    				var doc = this.ownerDocument || this,
    					attaches = dataPriv.access( doc, fix ) - 1;

    				if ( !attaches ) {
    					doc.removeEventListener( orig, handler, true );
    					dataPriv.remove( doc, fix );

    				} else {
    					dataPriv.access( doc, fix, attaches );
    				}
    			}
    		};
    	} );
    }
    var location = window.location;

    var nonce = jQuery.now();

    var rquery = ( /\?/ );

    // Cross-browser xml parsing
    jQuery.parseXML = function( data ) {
    	var xml;
    	if ( !data || typeof data !== "string" ) {
    		return null;
    	}

    	// Support: IE 9 - 11 only
    	// IE throws on parseFromString with invalid input.
    	try {
    		xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" );
    	} catch ( e ) {
    		xml = undefined;
    	}

    	if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) {
    		jQuery.error( "Invalid XML: " + data );
    	}
    	return xml;
    };

    var
    	rbracket = /\[\]$/,
    	rCRLF = /\r?\n/g,
    	rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
    	rsubmittable = /^(?:input|select|textarea|keygen)/i;

    function buildParams( prefix, obj, traditional, add ) {
    	var name;

    	if ( jQuery.isArray( obj ) ) {

    		// Serialize array item.
    		jQuery.each( obj, function( i, v ) {
    			if ( traditional || rbracket.test( prefix ) ) {

    				// Treat each array item as a scalar.
    				add( prefix, v );

    			} else {

    				// Item is non-scalar (array or object), encode its numeric index.
    				buildParams(
    					prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",
    					v,
    					traditional,
    					add
    				);
    			}
    		} );

    	} else if ( !traditional && jQuery.type( obj ) === "object" ) {

    		// Serialize object item.
    		for ( name in obj ) {
    			buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
    		}

    	} else {

    		// Serialize scalar item.
    		add( prefix, obj );
    	}
    }

    // Serialize an array of form elements or a set of
    // key/values into a query string
    jQuery.param = function( a, traditional ) {
    	var prefix,
    		s = [],
    		add = function( key, valueOrFunction ) {

    			// If value is a function, invoke it and use its return value
    			var value = jQuery.isFunction( valueOrFunction ) ?
    				valueOrFunction() :
    				valueOrFunction;

    			s[ s.length ] = encodeURIComponent( key ) + "=" +
    				encodeURIComponent( value == null ? "" : value );
    		};

    	// If an array was passed in, assume that it is an array of form elements.
    	if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {

    		// Serialize the form elements
    		jQuery.each( a, function() {
    			add( this.name, this.value );
    		} );

    	} else {

    		// If traditional, encode the "old" way (the way 1.3.2 or older
    		// did it), otherwise encode params recursively.
    		for ( prefix in a ) {
    			buildParams( prefix, a[ prefix ], traditional, add );
    		}
    	}

    	// Return the resulting serialization
    	return s.join( "&" );
    };

    jQuery.fn.extend( {
    	serialize: function() {
    		return jQuery.param( this.serializeArray() );
    	},
    	serializeArray: function() {
    		return this.map( function() {

    			// Can add propHook for "elements" to filter or add form elements
    			var elements = jQuery.prop( this, "elements" );
    			return elements ? jQuery.makeArray( elements ) : this;
    		} )
    		.filter( function() {
    			var type = this.type;

    			// Use .is( ":disabled" ) so that fieldset[disabled] works
    			return this.name && !jQuery( this ).is( ":disabled" ) &&
    				rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
    				( this.checked || !rcheckableType.test( type ) );
    		} )
    		.map( function( i, elem ) {
    			var val = jQuery( this ).val();

    			if ( val == null ) {
    				return null;
    			}

    			if ( jQuery.isArray( val ) ) {
    				return jQuery.map( val, function( val ) {
    					return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
    				} );
    			}

    			return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
    		} ).get();
    	}
    } );

    var
    	r20 = /%20/g,
    	rhash = /#.*$/,
    	rantiCache = /([?&])_=[^&]*/,
    	rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,

    	// #7653, #8125, #8152: local protocol detection
    	rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
    	rnoContent = /^(?:GET|HEAD)$/,
    	rprotocol = /^\/\//,

    	/* Prefilters
    	 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
    	 * 2) These are called:
    	 *    - BEFORE asking for a transport
    	 *    - AFTER param serialization (s.data is a string if s.processData is true)
    	 * 3) key is the dataType
    	 * 4) the catchall symbol "*" can be used
    	 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
    	 */
    	prefilters = {},

    	/* Transports bindings
    	 * 1) key is the dataType
    	 * 2) the catchall symbol "*" can be used
    	 * 3) selection will start with transport dataType and THEN go to "*" if needed
    	 */
    	transports = {},

    	// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
    	allTypes = "*/".concat( "*" ),

    	// Anchor tag for parsing the document origin
    	originAnchor = document.createElement( "a" );
    	originAnchor.href = location.href;

    // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
    function addToPrefiltersOrTransports( structure ) {

    	// dataTypeExpression is optional and defaults to "*"
    	return function( dataTypeExpression, func ) {

    		if ( typeof dataTypeExpression !== "string" ) {
    			func = dataTypeExpression;
    			dataTypeExpression = "*";
    		}

    		var dataType,
    			i = 0,
    			dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];

    		if ( jQuery.isFunction( func ) ) {

    			// For each dataType in the dataTypeExpression
    			while ( ( dataType = dataTypes[ i++ ] ) ) {

    				// Prepend if requested
    				if ( dataType[ 0 ] === "+" ) {
    					dataType = dataType.slice( 1 ) || "*";
    					( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );

    				// Otherwise append
    				} else {
    					( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
    				}
    			}
    		}
    	};
    }

    // Base inspection function for prefilters and transports
    function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {

    	var inspected = {},
    		seekingTransport = ( structure === transports );

    	function inspect( dataType ) {
    		var selected;
    		inspected[ dataType ] = true;
    		jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
    			var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
    			if ( typeof dataTypeOrTransport === "string" &&
    				!seekingTransport && !inspected[ dataTypeOrTransport ] ) {

    				options.dataTypes.unshift( dataTypeOrTransport );
    				inspect( dataTypeOrTransport );
    				return false;
    			} else if ( seekingTransport ) {
    				return !( selected = dataTypeOrTransport );
    			}
    		} );
    		return selected;
    	}

    	return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
    }

    // A special extend for ajax options
    // that takes "flat" options (not to be deep extended)
    // Fixes #9887
    function ajaxExtend( target, src ) {
    	var key, deep,
    		flatOptions = jQuery.ajaxSettings.flatOptions || {};

    	for ( key in src ) {
    		if ( src[ key ] !== undefined ) {
    			( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
    		}
    	}
    	if ( deep ) {
    		jQuery.extend( true, target, deep );
    	}

    	return target;
    }

    /* Handles responses to an ajax request:
     * - finds the right dataType (mediates between content-type and expected dataType)
     * - returns the corresponding response
     */
    function ajaxHandleResponses( s, jqXHR, responses ) {

    	var ct, type, finalDataType, firstDataType,
    		contents = s.contents,
    		dataTypes = s.dataTypes;

    	// Remove auto dataType and get content-type in the process
    	while ( dataTypes[ 0 ] === "*" ) {
    		dataTypes.shift();
    		if ( ct === undefined ) {
    			ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
    		}
    	}

    	// Check if we're dealing with a known content-type
    	if ( ct ) {
    		for ( type in contents ) {
    			if ( contents[ type ] && contents[ type ].test( ct ) ) {
    				dataTypes.unshift( type );
    				break;
    			}
    		}
    	}

    	// Check to see if we have a response for the expected dataType
    	if ( dataTypes[ 0 ] in responses ) {
    		finalDataType = dataTypes[ 0 ];
    	} else {

    		// Try convertible dataTypes
    		for ( type in responses ) {
    			if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
    				finalDataType = type;
    				break;
    			}
    			if ( !firstDataType ) {
    				firstDataType = type;
    			}
    		}

    		// Or just use first one
    		finalDataType = finalDataType || firstDataType;
    	}

    	// If we found a dataType
    	// We add the dataType to the list if needed
    	// and return the corresponding response
    	if ( finalDataType ) {
    		if ( finalDataType !== dataTypes[ 0 ] ) {
    			dataTypes.unshift( finalDataType );
    		}
    		return responses[ finalDataType ];
    	}
    }

    /* Chain conversions given the request and the original response
     * Also sets the responseXXX fields on the jqXHR instance
     */
    function ajaxConvert( s, response, jqXHR, isSuccess ) {
    	var conv2, current, conv, tmp, prev,
    		converters = {},

    		// Work with a copy of dataTypes in case we need to modify it for conversion
    		dataTypes = s.dataTypes.slice();

    	// Create converters map with lowercased keys
    	if ( dataTypes[ 1 ] ) {
    		for ( conv in s.converters ) {
    			converters[ conv.toLowerCase() ] = s.converters[ conv ];
    		}
    	}

    	current = dataTypes.shift();

    	// Convert to each sequential dataType
    	while ( current ) {

    		if ( s.responseFields[ current ] ) {
    			jqXHR[ s.responseFields[ current ] ] = response;
    		}

    		// Apply the dataFilter if provided
    		if ( !prev && isSuccess && s.dataFilter ) {
    			response = s.dataFilter( response, s.dataType );
    		}

    		prev = current;
    		current = dataTypes.shift();

    		if ( current ) {

    			// There's only work to do if current dataType is non-auto
    			if ( current === "*" ) {

    				current = prev;

    			// Convert response if prev dataType is non-auto and differs from current
    			} else if ( prev !== "*" && prev !== current ) {

    				// Seek a direct converter
    				conv = converters[ prev + " " + current ] || converters[ "* " + current ];

    				// If none found, seek a pair
    				if ( !conv ) {
    					for ( conv2 in converters ) {

    						// If conv2 outputs current
    						tmp = conv2.split( " " );
    						if ( tmp[ 1 ] === current ) {

    							// If prev can be converted to accepted input
    							conv = converters[ prev + " " + tmp[ 0 ] ] ||
    								converters[ "* " + tmp[ 0 ] ];
    							if ( conv ) {

    								// Condense equivalence converters
    								if ( conv === true ) {
    									conv = converters[ conv2 ];

    								// Otherwise, insert the intermediate dataType
    								} else if ( converters[ conv2 ] !== true ) {
    									current = tmp[ 0 ];
    									dataTypes.unshift( tmp[ 1 ] );
    								}
    								break;
    							}
    						}
    					}
    				}

    				// Apply converter (if not an equivalence)
    				if ( conv !== true ) {

    					// Unless errors are allowed to bubble, catch and return them
    					if ( conv && s.throws ) {
    						response = conv( response );
    					} else {
    						try {
    							response = conv( response );
    						} catch ( e ) {
    							return {
    								state: "parsererror",
    								error: conv ? e : "No conversion from " + prev + " to " + current
    							};
    						}
    					}
    				}
    			}
    		}
    	}

    	return { state: "success", data: response };
    }

    jQuery.extend( {

    	// Counter for holding the number of active queries
    	active: 0,

    	// Last-Modified header cache for next request
    	lastModified: {},
    	etag: {},

    	ajaxSettings: {
    		url: location.href,
    		type: "GET",
    		isLocal: rlocalProtocol.test( location.protocol ),
    		global: true,
    		processData: true,
    		async: true,
    		contentType: "application/x-www-form-urlencoded; charset=UTF-8",

    		/*
    		timeout: 0,
    		data: null,
    		dataType: null,
    		username: null,
    		password: null,
    		cache: null,
    		throws: false,
    		traditional: false,
    		headers: {},
    		*/

    		accepts: {
    			"*": allTypes,
    			text: "text/plain",
    			html: "text/html",
    			xml: "application/xml, text/xml",
    			json: "application/json, text/javascript"
    		},

    		contents: {
    			xml: /\bxml\b/,
    			html: /\bhtml/,
    			json: /\bjson\b/
    		},

    		responseFields: {
    			xml: "responseXML",
    			text: "responseText",
    			json: "responseJSON"
    		},

    		// Data converters
    		// Keys separate source (or catchall "*") and destination types with a single space
    		converters: {

    			// Convert anything to text
    			"* text": String,

    			// Text to html (true = no transformation)
    			"text html": true,

    			// Evaluate text as a json expression
    			"text json": JSON.parse,

    			// Parse text as xml
    			"text xml": jQuery.parseXML
    		},

    		// For options that shouldn't be deep extended:
    		// you can add your own custom options here if
    		// and when you create one that shouldn't be
    		// deep extended (see ajaxExtend)
    		flatOptions: {
    			url: true,
    			context: true
    		}
    	},

    	// Creates a full fledged settings object into target
    	// with both ajaxSettings and settings fields.
    	// If target is omitted, writes into ajaxSettings.
    	ajaxSetup: function( target, settings ) {
    		return settings ?

    			// Building a settings object
    			ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :

    			// Extending ajaxSettings
    			ajaxExtend( jQuery.ajaxSettings, target );
    	},

    	ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
    	ajaxTransport: addToPrefiltersOrTransports( transports ),

    	// Main method
    	ajax: function( url, options ) {

    		// If url is an object, simulate pre-1.5 signature
    		if ( typeof url === "object" ) {
    			options = url;
    			url = undefined;
    		}

    		// Force options to be an object
    		options = options || {};

    		var transport,

    			// URL without anti-cache param
    			cacheURL,

    			// Response headers
    			responseHeadersString,
    			responseHeaders,

    			// timeout handle
    			timeoutTimer,

    			// Url cleanup var
    			urlAnchor,

    			// Request state (becomes false upon send and true upon completion)
    			completed,

    			// To know if global events are to be dispatched
    			fireGlobals,

    			// Loop variable
    			i,

    			// uncached part of the url
    			uncached,

    			// Create the final options object
    			s = jQuery.ajaxSetup( {}, options ),

    			// Callbacks context
    			callbackContext = s.context || s,

    			// Context for global events is callbackContext if it is a DOM node or jQuery collection
    			globalEventContext = s.context &&
    				( callbackContext.nodeType || callbackContext.jquery ) ?
    					jQuery( callbackContext ) :
    					jQuery.event,

    			// Deferreds
    			deferred = jQuery.Deferred(),
    			completeDeferred = jQuery.Callbacks( "once memory" ),

    			// Status-dependent callbacks
    			statusCode = s.statusCode || {},

    			// Headers (they are sent all at once)
    			requestHeaders = {},
    			requestHeadersNames = {},

    			// Default abort message
    			strAbort = "canceled",

    			// Fake xhr
    			jqXHR = {
    				readyState: 0,

    				// Builds headers hashtable if needed
    				getResponseHeader: function( key ) {
    					var match;
    					if ( completed ) {
    						if ( !responseHeaders ) {
    							responseHeaders = {};
    							while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
    								responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];
    							}
    						}
    						match = responseHeaders[ key.toLowerCase() ];
    					}
    					return match == null ? null : match;
    				},

    				// Raw string
    				getAllResponseHeaders: function() {
    					return completed ? responseHeadersString : null;
    				},

    				// Caches the header
    				setRequestHeader: function( name, value ) {
    					if ( completed == null ) {
    						name = requestHeadersNames[ name.toLowerCase() ] =
    							requestHeadersNames[ name.toLowerCase() ] || name;
    						requestHeaders[ name ] = value;
    					}
    					return this;
    				},

    				// Overrides response content-type header
    				overrideMimeType: function( type ) {
    					if ( completed == null ) {
    						s.mimeType = type;
    					}
    					return this;
    				},

    				// Status-dependent callbacks
    				statusCode: function( map ) {
    					var code;
    					if ( map ) {
    						if ( completed ) {

    							// Execute the appropriate callbacks
    							jqXHR.always( map[ jqXHR.status ] );
    						} else {

    							// Lazy-add the new callbacks in a way that preserves old ones
    							for ( code in map ) {
    								statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
    							}
    						}
    					}
    					return this;
    				},

    				// Cancel the request
    				abort: function( statusText ) {
    					var finalText = statusText || strAbort;
    					if ( transport ) {
    						transport.abort( finalText );
    					}
    					done( 0, finalText );
    					return this;
    				}
    			};

    		// Attach deferreds
    		deferred.promise( jqXHR );

    		// Add protocol if not provided (prefilters might expect it)
    		// Handle falsy url in the settings object (#10093: consistency with old signature)
    		// We also use the url parameter if available
    		s.url = ( ( url || s.url || location.href ) + "" )
    			.replace( rprotocol, location.protocol + "//" );

    		// Alias method option to type as per ticket #12004
    		s.type = options.method || options.type || s.method || s.type;

    		// Extract dataTypes list
    		s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];

    		// A cross-domain request is in order when the origin doesn't match the current origin.
    		if ( s.crossDomain == null ) {
    			urlAnchor = document.createElement( "a" );

    			// Support: IE <=8 - 11, Edge 12 - 13
    			// IE throws exception on accessing the href property if url is malformed,
    			// e.g. http://example.com:80x/
    			try {
    				urlAnchor.href = s.url;

    				// Support: IE <=8 - 11 only
    				// Anchor's host property isn't correctly set when s.url is relative
    				urlAnchor.href = urlAnchor.href;
    				s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
    					urlAnchor.protocol + "//" + urlAnchor.host;
    			} catch ( e ) {

    				// If there is an error parsing the URL, assume it is crossDomain,
    				// it can be rejected by the transport if it is invalid
    				s.crossDomain = true;
    			}
    		}

    		// Convert data if not already a string
    		if ( s.data && s.processData && typeof s.data !== "string" ) {
    			s.data = jQuery.param( s.data, s.traditional );
    		}

    		// Apply prefilters
    		inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );

    		// If request was aborted inside a prefilter, stop there
    		if ( completed ) {
    			return jqXHR;
    		}

    		// We can fire global events as of now if asked to
    		// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
    		fireGlobals = jQuery.event && s.global;

    		// Watch for a new set of requests
    		if ( fireGlobals && jQuery.active++ === 0 ) {
    			jQuery.event.trigger( "ajaxStart" );
    		}

    		// Uppercase the type
    		s.type = s.type.toUpperCase();

    		// Determine if request has content
    		s.hasContent = !rnoContent.test( s.type );

    		// Save the URL in case we're toying with the If-Modified-Since
    		// and/or If-None-Match header later on
    		// Remove hash to simplify url manipulation
    		cacheURL = s.url.replace( rhash, "" );

    		// More options handling for requests with no content
    		if ( !s.hasContent ) {

    			// Remember the hash so we can put it back
    			uncached = s.url.slice( cacheURL.length );

    			// If data is available, append data to url
    			if ( s.data ) {
    				cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;

    				// #9682: remove data so that it's not used in an eventual retry
    				delete s.data;
    			}

    			// Add or update anti-cache param if needed
    			if ( s.cache === false ) {
    				cacheURL = cacheURL.replace( rantiCache, "$1" );
    				uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached;
    			}

    			// Put hash and anti-cache on the URL that will be requested (gh-1732)
    			s.url = cacheURL + uncached;

    		// Change '%20' to '+' if this is encoded form body content (gh-2658)
    		} else if ( s.data && s.processData &&
    			( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
    			s.data = s.data.replace( r20, "+" );
    		}

    		// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
    		if ( s.ifModified ) {
    			if ( jQuery.lastModified[ cacheURL ] ) {
    				jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
    			}
    			if ( jQuery.etag[ cacheURL ] ) {
    				jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
    			}
    		}

    		// Set the correct header, if data is being sent
    		if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
    			jqXHR.setRequestHeader( "Content-Type", s.contentType );
    		}

    		// Set the Accepts header for the server, depending on the dataType
    		jqXHR.setRequestHeader(
    			"Accept",
    			s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
    				s.accepts[ s.dataTypes[ 0 ] ] +
    					( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
    				s.accepts[ "*" ]
    		);

    		// Check for headers option
    		for ( i in s.headers ) {
    			jqXHR.setRequestHeader( i, s.headers[ i ] );
    		}

    		// Allow custom headers/mimetypes and early abort
    		if ( s.beforeSend &&
    			( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {

    			// Abort if not done already and return
    			return jqXHR.abort();
    		}

    		// Aborting is no longer a cancellation
    		strAbort = "abort";

    		// Install callbacks on deferreds
    		completeDeferred.add( s.complete );
    		jqXHR.done( s.success );
    		jqXHR.fail( s.error );

    		// Get transport
    		transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );

    		// If no transport, we auto-abort
    		if ( !transport ) {
    			done( -1, "No Transport" );
    		} else {
    			jqXHR.readyState = 1;

    			// Send global event
    			if ( fireGlobals ) {
    				globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
    			}

    			// If request was aborted inside ajaxSend, stop there
    			if ( completed ) {
    				return jqXHR;
    			}

    			// Timeout
    			if ( s.async && s.timeout > 0 ) {
    				timeoutTimer = window.setTimeout( function() {
    					jqXHR.abort( "timeout" );
    				}, s.timeout );
    			}

    			try {
    				completed = false;
    				transport.send( requestHeaders, done );
    			} catch ( e ) {

    				// Rethrow post-completion exceptions
    				if ( completed ) {
    					throw e;
    				}

    				// Propagate others as results
    				done( -1, e );
    			}
    		}

    		// Callback for when everything is done
    		function done( status, nativeStatusText, responses, headers ) {
    			var isSuccess, success, error, response, modified,
    				statusText = nativeStatusText;

    			// Ignore repeat invocations
    			if ( completed ) {
    				return;
    			}

    			completed = true;

    			// Clear timeout if it exists
    			if ( timeoutTimer ) {
    				window.clearTimeout( timeoutTimer );
    			}

    			// Dereference transport for early garbage collection
    			// (no matter how long the jqXHR object will be used)
    			transport = undefined;

    			// Cache response headers
    			responseHeadersString = headers || "";

    			// Set readyState
    			jqXHR.readyState = status > 0 ? 4 : 0;

    			// Determine if successful
    			isSuccess = status >= 200 && status < 300 || status === 304;

    			// Get response data
    			if ( responses ) {
    				response = ajaxHandleResponses( s, jqXHR, responses );
    			}

    			// Convert no matter what (that way responseXXX fields are always set)
    			response = ajaxConvert( s, response, jqXHR, isSuccess );

    			// If successful, handle type chaining
    			if ( isSuccess ) {

    				// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
    				if ( s.ifModified ) {
    					modified = jqXHR.getResponseHeader( "Last-Modified" );
    					if ( modified ) {
    						jQuery.lastModified[ cacheURL ] = modified;
    					}
    					modified = jqXHR.getResponseHeader( "etag" );
    					if ( modified ) {
    						jQuery.etag[ cacheURL ] = modified;
    					}
    				}

    				// if no content
    				if ( status === 204 || s.type === "HEAD" ) {
    					statusText = "nocontent";

    				// if not modified
    				} else if ( status === 304 ) {
    					statusText = "notmodified";

    				// If we have data, let's convert it
    				} else {
    					statusText = response.state;
    					success = response.data;
    					error = response.error;
    					isSuccess = !error;
    				}
    			} else {

    				// Extract error from statusText and normalize for non-aborts
    				error = statusText;
    				if ( status || !statusText ) {
    					statusText = "error";
    					if ( status < 0 ) {
    						status = 0;
    					}
    				}
    			}

    			// Set data for the fake xhr object
    			jqXHR.status = status;
    			jqXHR.statusText = ( nativeStatusText || statusText ) + "";

    			// Success/Error
    			if ( isSuccess ) {
    				deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
    			} else {
    				deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
    			}

    			// Status-dependent callbacks
    			jqXHR.statusCode( statusCode );
    			statusCode = undefined;

    			if ( fireGlobals ) {
    				globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
    					[ jqXHR, s, isSuccess ? success : error ] );
    			}

    			// Complete
    			completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );

    			if ( fireGlobals ) {
    				globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );

    				// Handle the global AJAX counter
    				if ( !( --jQuery.active ) ) {
    					jQuery.event.trigger( "ajaxStop" );
    				}
    			}
    		}

    		return jqXHR;
    	},

    	getJSON: function( url, data, callback ) {
    		return jQuery.get( url, data, callback, "json" );
    	},

    	getScript: function( url, callback ) {
    		return jQuery.get( url, undefined, callback, "script" );
    	}
    } );

    jQuery.each( [ "get", "post" ], function( i, method ) {
    	jQuery[ method ] = function( url, data, callback, type ) {

    		// Shift arguments if data argument was omitted
    		if ( jQuery.isFunction( data ) ) {
    			type = type || callback;
    			callback = data;
    			data = undefined;
    		}

    		// The url can be an options object (which then must have .url)
    		return jQuery.ajax( jQuery.extend( {
    			url: url,
    			type: method,
    			dataType: type,
    			data: data,
    			success: callback
    		}, jQuery.isPlainObject( url ) && url ) );
    	};
    } );

    jQuery._evalUrl = function( url ) {
    	return jQuery.ajax( {
    		url: url,

    		// Make this explicit, since user can override this through ajaxSetup (#11264)
    		type: "GET",
    		dataType: "script",
    		cache: true,
    		async: false,
    		global: false,
    		"throws": true
    	} );
    };

    jQuery.fn.extend( {
    	wrapAll: function( html ) {
    		var wrap;

    		if ( this[ 0 ] ) {
    			if ( jQuery.isFunction( html ) ) {
    				html = html.call( this[ 0 ] );
    			}

    			// The elements to wrap the target around
    			wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );

    			if ( this[ 0 ].parentNode ) {
    				wrap.insertBefore( this[ 0 ] );
    			}

    			wrap.map( function() {
    				var elem = this;

    				while ( elem.firstElementChild ) {
    					elem = elem.firstElementChild;
    				}

    				return elem;
    			} ).append( this );
    		}

    		return this;
    	},

    	wrapInner: function( html ) {
    		if ( jQuery.isFunction( html ) ) {
    			return this.each( function( i ) {
    				jQuery( this ).wrapInner( html.call( this, i ) );
    			} );
    		}

    		return this.each( function() {
    			var self = jQuery( this ),
    				contents = self.contents();

    			if ( contents.length ) {
    				contents.wrapAll( html );

    			} else {
    				self.append( html );
    			}
    		} );
    	},

    	wrap: function( html ) {
    		var isFunction = jQuery.isFunction( html );

    		return this.each( function( i ) {
    			jQuery( this ).wrapAll( isFunction ? html.call( this, i ) : html );
    		} );
    	},

    	unwrap: function( selector ) {
    		this.parent( selector ).not( "body" ).each( function() {
    			jQuery( this ).replaceWith( this.childNodes );
    		} );
    		return this;
    	}
    } );

    jQuery.expr.pseudos.hidden = function( elem ) {
    	return !jQuery.expr.pseudos.visible( elem );
    };
    jQuery.expr.pseudos.visible = function( elem ) {
    	return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );
    };

    jQuery.ajaxSettings.xhr = function() {
    	try {
    		return new window.XMLHttpRequest();
    	} catch ( e ) {}
    };

    var xhrSuccessStatus = {

    		// File protocol always yields status code 0, assume 200
    		0: 200,

    		// Support: IE <=9 only
    		// #1450: sometimes IE returns 1223 when it should be 204
    		1223: 204
    	},
    	xhrSupported = jQuery.ajaxSettings.xhr();

    support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
    support.ajax = xhrSupported = !!xhrSupported;

    jQuery.ajaxTransport( function( options ) {
    	var callback, errorCallback;

    	// Cross domain only allowed if supported through XMLHttpRequest
    	if ( support.cors || xhrSupported && !options.crossDomain ) {
    		return {
    			send: function( headers, complete ) {
    				var i,
    					xhr = options.xhr();

    				xhr.open(
    					options.type,
    					options.url,
    					options.async,
    					options.username,
    					options.password
    				);

    				// Apply custom fields if provided
    				if ( options.xhrFields ) {
    					for ( i in options.xhrFields ) {
    						xhr[ i ] = options.xhrFields[ i ];
    					}
    				}

    				// Override mime type if needed
    				if ( options.mimeType && xhr.overrideMimeType ) {
    					xhr.overrideMimeType( options.mimeType );
    				}

    				// X-Requested-With header
    				// For cross-domain requests, seeing as conditions for a preflight are
    				// akin to a jigsaw puzzle, we simply never set it to be sure.
    				// (it can always be set on a per-request basis or even using ajaxSetup)
    				// For same-domain requests, won't change header if already provided.
    				if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) {
    					headers[ "X-Requested-With" ] = "XMLHttpRequest";
    				}

    				// Set headers
    				for ( i in headers ) {
    					xhr.setRequestHeader( i, headers[ i ] );
    				}

    				// Callback
    				callback = function( type ) {
    					return function() {
    						if ( callback ) {
    							callback = errorCallback = xhr.onload =
    								xhr.onerror = xhr.onabort = xhr.onreadystatechange = null;

    							if ( type === "abort" ) {
    								xhr.abort();
    							} else if ( type === "error" ) {

    								// Support: IE <=9 only
    								// On a manual native abort, IE9 throws
    								// errors on any property access that is not readyState
    								if ( typeof xhr.status !== "number" ) {
    									complete( 0, "error" );
    								} else {
    									complete(

    										// File: protocol always yields status 0; see #8605, #14207
    										xhr.status,
    										xhr.statusText
    									);
    								}
    							} else {
    								complete(
    									xhrSuccessStatus[ xhr.status ] || xhr.status,
    									xhr.statusText,

    									// Support: IE <=9 only
    									// IE9 has no XHR2 but throws on binary (trac-11426)
    									// For XHR2 non-text, let the caller handle it (gh-2498)
    									( xhr.responseType || "text" ) !== "text"  ||
    									typeof xhr.responseText !== "string" ?
    										{ binary: xhr.response } :
    										{ text: xhr.responseText },
    									xhr.getAllResponseHeaders()
    								);
    							}
    						}
    					};
    				};

    				// Listen to events
    				xhr.onload = callback();
    				errorCallback = xhr.onerror = callback( "error" );

    				// Support: IE 9 only
    				// Use onreadystatechange to replace onabort
    				// to handle uncaught aborts
    				if ( xhr.onabort !== undefined ) {
    					xhr.onabort = errorCallback;
    				} else {
    					xhr.onreadystatechange = function() {

    						// Check readyState before timeout as it changes
    						if ( xhr.readyState === 4 ) {

    							// Allow onerror to be called first,
    							// but that will not handle a native abort
    							// Also, save errorCallback to a variable
    							// as xhr.onerror cannot be accessed
    							window.setTimeout( function() {
    								if ( callback ) {
    									errorCallback();
    								}
    							} );
    						}
    					};
    				}

    				// Create the abort callback
    				callback = callback( "abort" );

    				try {

    					// Do send the request (this may raise an exception)
    					xhr.send( options.hasContent && options.data || null );
    				} catch ( e ) {

    					// #14683: Only rethrow if this hasn't been notified as an error yet
    					if ( callback ) {
    						throw e;
    					}
    				}
    			},

    			abort: function() {
    				if ( callback ) {
    					callback();
    				}
    			}
    		};
    	}
    } );

    // Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
    jQuery.ajaxPrefilter( function( s ) {
    	if ( s.crossDomain ) {
    		s.contents.script = false;
    	}
    } );

    // Install script dataType
    jQuery.ajaxSetup( {
    	accepts: {
    		script: "text/javascript, application/javascript, " +
    			"application/ecmascript, application/x-ecmascript"
    	},
    	contents: {
    		script: /\b(?:java|ecma)script\b/
    	},
    	converters: {
    		"text script": function( text ) {
    			jQuery.globalEval( text );
    			return text;
    		}
    	}
    } );

    // Handle cache's special case and crossDomain
    jQuery.ajaxPrefilter( "script", function( s ) {
    	if ( s.cache === undefined ) {
    		s.cache = false;
    	}
    	if ( s.crossDomain ) {
    		s.type = "GET";
    	}
    } );

    // Bind script tag hack transport
    jQuery.ajaxTransport( "script", function( s ) {

    	// This transport only deals with cross domain requests
    	if ( s.crossDomain ) {
    		var script, callback;
    		return {
    			send: function( _, complete ) {
    				script = jQuery( "<script>" ).prop( {
    					charset: s.scriptCharset,
    					src: s.url
    				} ).on(
    					"load error",
    					callback = function( evt ) {
    						script.remove();
    						callback = null;
    						if ( evt ) {
    							complete( evt.type === "error" ? 404 : 200, evt.type );
    						}
    					}
    				);

    				// Use native DOM manipulation to avoid our domManip AJAX trickery
    				document.head.appendChild( script[ 0 ] );
    			},
    			abort: function() {
    				if ( callback ) {
    					callback();
    				}
    			}
    		};
    	}
    } );

    var oldCallbacks = [],
    	rjsonp = /(=)\?(?=&|$)|\?\?/;

    // Default jsonp settings
    jQuery.ajaxSetup( {
    	jsonp: "callback",
    	jsonpCallback: function() {
    		var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
    		this[ callback ] = true;
    		return callback;
    	}
    } );

    // Detect, normalize options and install callbacks for jsonp requests
    jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {

    	var callbackName, overwritten, responseContainer,
    		jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
    			"url" :
    			typeof s.data === "string" &&
    				( s.contentType || "" )
    					.indexOf( "application/x-www-form-urlencoded" ) === 0 &&
    				rjsonp.test( s.data ) && "data"
    		);

    	// Handle iff the expected data type is "jsonp" or we have a parameter to set
    	if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {

    		// Get callback name, remembering preexisting value associated with it
    		callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
    			s.jsonpCallback() :
    			s.jsonpCallback;

    		// Insert callback into url or form data
    		if ( jsonProp ) {
    			s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
    		} else if ( s.jsonp !== false ) {
    			s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
    		}

    		// Use data converter to retrieve json after script execution
    		s.converters[ "script json" ] = function() {
    			if ( !responseContainer ) {
    				jQuery.error( callbackName + " was not called" );
    			}
    			return responseContainer[ 0 ];
    		};

    		// Force json dataType
    		s.dataTypes[ 0 ] = "json";

    		// Install callback
    		overwritten = window[ callbackName ];
    		window[ callbackName ] = function() {
    			responseContainer = arguments;
    		};

    		// Clean-up function (fires after converters)
    		jqXHR.always( function() {

    			// If previous value didn't exist - remove it
    			if ( overwritten === undefined ) {
    				jQuery( window ).removeProp( callbackName );

    			// Otherwise restore preexisting value
    			} else {
    				window[ callbackName ] = overwritten;
    			}

    			// Save back as free
    			if ( s[ callbackName ] ) {

    				// Make sure that re-using the options doesn't screw things around
    				s.jsonpCallback = originalSettings.jsonpCallback;

    				// Save the callback name for future use
    				oldCallbacks.push( callbackName );
    			}

    			// Call if it was a function and we have a response
    			if ( responseContainer && jQuery.isFunction( overwritten ) ) {
    				overwritten( responseContainer[ 0 ] );
    			}

    			responseContainer = overwritten = undefined;
    		} );

    		// Delegate to script
    		return "script";
    	}
    } );

    // Support: Safari 8 only
    // In Safari 8 documents created via document.implementation.createHTMLDocument
    // collapse sibling forms: the second one becomes a child of the first one.
    // Because of that, this security measure has to be disabled in Safari 8.
    // https://bugs.webkit.org/show_bug.cgi?id=137337
    support.createHTMLDocument = ( function() {
    	var body = document.implementation.createHTMLDocument( "" ).body;
    	body.innerHTML = "<form></form><form></form>";
    	return body.childNodes.length === 2;
    } )();

    // Argument "data" should be string of html
    // context (optional): If specified, the fragment will be created in this context,
    // defaults to document
    // keepScripts (optional): If true, will include scripts passed in the html string
    jQuery.parseHTML = function( data, context, keepScripts ) {
    	if ( typeof data !== "string" ) {
    		return [];
    	}
    	if ( typeof context === "boolean" ) {
    		keepScripts = context;
    		context = false;
    	}

    	var base, parsed, scripts;

    	if ( !context ) {

    		// Stop scripts or inline event handlers from being executed immediately
    		// by using document.implementation
    		if ( support.createHTMLDocument ) {
    			context = document.implementation.createHTMLDocument( "" );

    			// Set the base href for the created document
    			// so any parsed elements with URLs
    			// are based on the document's URL (gh-2965)
    			base = context.createElement( "base" );
    			base.href = document.location.href;
    			context.head.appendChild( base );
    		} else {
    			context = document;
    		}
    	}

    	parsed = rsingleTag.exec( data );
    	scripts = !keepScripts && [];

    	// Single tag
    	if ( parsed ) {
    		return [ context.createElement( parsed[ 1 ] ) ];
    	}

    	parsed = buildFragment( [ data ], context, scripts );

    	if ( scripts && scripts.length ) {
    		jQuery( scripts ).remove();
    	}

    	return jQuery.merge( [], parsed.childNodes );
    };

    /**
     * Load a url into a page
     */
    jQuery.fn.load = function( url, params, callback ) {
    	var selector, type, response,
    		self = this,
    		off = url.indexOf( " " );

    	if ( off > -1 ) {
    		selector = stripAndCollapse( url.slice( off ) );
    		url = url.slice( 0, off );
    	}

    	// If it's a function
    	if ( jQuery.isFunction( params ) ) {

    		// We assume that it's the callback
    		callback = params;
    		params = undefined;

    	// Otherwise, build a param string
    	} else if ( params && typeof params === "object" ) {
    		type = "POST";
    	}

    	// If we have elements to modify, make the request
    	if ( self.length > 0 ) {
    		jQuery.ajax( {
    			url: url,

    			// If "type" variable is undefined, then "GET" method will be used.
    			// Make value of this field explicit since
    			// user can override it through ajaxSetup method
    			type: type || "GET",
    			dataType: "html",
    			data: params
    		} ).done( function( responseText ) {

    			// Save response for use in complete callback
    			response = arguments;

    			self.html( selector ?

    				// If a selector was specified, locate the right elements in a dummy div
    				// Exclude scripts to avoid IE 'Permission Denied' errors
    				jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :

    				// Otherwise use the full result
    				responseText );

    		// If the request succeeds, this function gets "data", "status", "jqXHR"
    		// but they are ignored because response was set above.
    		// If it fails, this function gets "jqXHR", "status", "error"
    		} ).always( callback && function( jqXHR, status ) {
    			self.each( function() {
    				callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );
    			} );
    		} );
    	}

    	return this;
    };

    // Attach a bunch of functions for handling common AJAX events
    jQuery.each( [
    	"ajaxStart",
    	"ajaxStop",
    	"ajaxComplete",
    	"ajaxError",
    	"ajaxSuccess",
    	"ajaxSend"
    ], function( i, type ) {
    	jQuery.fn[ type ] = function( fn ) {
    		return this.on( type, fn );
    	};
    } );

    jQuery.expr.pseudos.animated = function( elem ) {
    	return jQuery.grep( jQuery.timers, function( fn ) {
    		return elem === fn.elem;
    	} ).length;
    };

    /**
     * Gets a window from an element
     */
    function getWindow( elem ) {
    	return jQuery.isWindow( elem ) ? elem : elem.nodeType === 9 && elem.defaultView;
    }

    jQuery.offset = {
    	setOffset: function( elem, options, i ) {
    		var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
    			position = jQuery.css( elem, "position" ),
    			curElem = jQuery( elem ),
    			props = {};

    		// Set position first, in-case top/left are set even on static elem
    		if ( position === "static" ) {
    			elem.style.position = "relative";
    		}

    		curOffset = curElem.offset();
    		curCSSTop = jQuery.css( elem, "top" );
    		curCSSLeft = jQuery.css( elem, "left" );
    		calculatePosition = ( position === "absolute" || position === "fixed" ) &&
    			( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1;

    		// Need to be able to calculate position if either
    		// top or left is auto and position is either absolute or fixed
    		if ( calculatePosition ) {
    			curPosition = curElem.position();
    			curTop = curPosition.top;
    			curLeft = curPosition.left;

    		} else {
    			curTop = parseFloat( curCSSTop ) || 0;
    			curLeft = parseFloat( curCSSLeft ) || 0;
    		}

    		if ( jQuery.isFunction( options ) ) {

    			// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
    			options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
    		}

    		if ( options.top != null ) {
    			props.top = ( options.top - curOffset.top ) + curTop;
    		}
    		if ( options.left != null ) {
    			props.left = ( options.left - curOffset.left ) + curLeft;
    		}

    		if ( "using" in options ) {
    			options.using.call( elem, props );

    		} else {
    			curElem.css( props );
    		}
    	}
    };

    jQuery.fn.extend( {
    	offset: function( options ) {

    		// Preserve chaining for setter
    		if ( arguments.length ) {
    			return options === undefined ?
    				this :
    				this.each( function( i ) {
    					jQuery.offset.setOffset( this, options, i );
    				} );
    		}

    		var docElem, win, rect, doc,
    			elem = this[ 0 ];

    		if ( !elem ) {
    			return;
    		}

    		// Support: IE <=11 only
    		// Running getBoundingClientRect on a
    		// disconnected node in IE throws an error
    		if ( !elem.getClientRects().length ) {
    			return { top: 0, left: 0 };
    		}

    		rect = elem.getBoundingClientRect();

    		// Make sure element is not hidden (display: none)
    		if ( rect.width || rect.height ) {
    			doc = elem.ownerDocument;
    			win = getWindow( doc );
    			docElem = doc.documentElement;

    			return {
    				top: rect.top + win.pageYOffset - docElem.clientTop,
    				left: rect.left + win.pageXOffset - docElem.clientLeft
    			};
    		}

    		// Return zeros for disconnected and hidden elements (gh-2310)
    		return rect;
    	},

    	position: function() {
    		if ( !this[ 0 ] ) {
    			return;
    		}

    		var offsetParent, offset,
    			elem = this[ 0 ],
    			parentOffset = { top: 0, left: 0 };

    		// Fixed elements are offset from window (parentOffset = {top:0, left: 0},
    		// because it is its only offset parent
    		if ( jQuery.css( elem, "position" ) === "fixed" ) {

    			// Assume getBoundingClientRect is there when computed position is fixed
    			offset = elem.getBoundingClientRect();

    		} else {

    			// Get *real* offsetParent
    			offsetParent = this.offsetParent();

    			// Get correct offsets
    			offset = this.offset();
    			if ( !jQuery.nodeName( offsetParent[ 0 ], "html" ) ) {
    				parentOffset = offsetParent.offset();
    			}

    			// Add offsetParent borders
    			parentOffset = {
    				top: parentOffset.top + jQuery.css( offsetParent[ 0 ], "borderTopWidth", true ),
    				left: parentOffset.left + jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true )
    			};
    		}

    		// Subtract parent offsets and element margins
    		return {
    			top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
    			left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
    		};
    	},

    	// This method will return documentElement in the following cases:
    	// 1) For the element inside the iframe without offsetParent, this method will return
    	//    documentElement of the parent window
    	// 2) For the hidden or detached element
    	// 3) For body or html element, i.e. in case of the html node - it will return itself
    	//
    	// but those exceptions were never presented as a real life use-cases
    	// and might be considered as more preferable results.
    	//
    	// This logic, however, is not guaranteed and can change at any point in the future
    	offsetParent: function() {
    		return this.map( function() {
    			var offsetParent = this.offsetParent;

    			while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) {
    				offsetParent = offsetParent.offsetParent;
    			}

    			return offsetParent || documentElement;
    		} );
    	}
    } );

    // Create scrollLeft and scrollTop methods
    jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
    	var top = "pageYOffset" === prop;

    	jQuery.fn[ method ] = function( val ) {
    		return access( this, function( elem, method, val ) {
    			var win = getWindow( elem );

    			if ( val === undefined ) {
    				return win ? win[ prop ] : elem[ method ];
    			}

    			if ( win ) {
    				win.scrollTo(
    					!top ? val : win.pageXOffset,
    					top ? val : win.pageYOffset
    				);

    			} else {
    				elem[ method ] = val;
    			}
    		}, method, val, arguments.length );
    	};
    } );

    // Support: Safari <=7 - 9.1, Chrome <=37 - 49
    // Add the top/left cssHooks using jQuery.fn.position
    // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
    // Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
    // getComputedStyle returns percent when specified for top/left/bottom/right;
    // rather than make the css module depend on the offset module, just check for it here
    jQuery.each( [ "top", "left" ], function( i, prop ) {
    	jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
    		function( elem, computed ) {
    			if ( computed ) {
    				computed = curCSS( elem, prop );

    				// If curCSS returns percentage, fallback to offset
    				return rnumnonpx.test( computed ) ?
    					jQuery( elem ).position()[ prop ] + "px" :
    					computed;
    			}
    		}
    	);
    } );

    // Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
    jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
    	jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name },
    		function( defaultExtra, funcName ) {

    		// Margin is only for outerHeight, outerWidth
    		jQuery.fn[ funcName ] = function( margin, value ) {
    			var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
    				extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );

    			return access( this, function( elem, type, value ) {
    				var doc;

    				if ( jQuery.isWindow( elem ) ) {

    					// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
    					return funcName.indexOf( "outer" ) === 0 ?
    						elem[ "inner" + name ] :
    						elem.document.documentElement[ "client" + name ];
    				}

    				// Get document width or height
    				if ( elem.nodeType === 9 ) {
    					doc = elem.documentElement;

    					// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
    					// whichever is greatest
    					return Math.max(
    						elem.body[ "scroll" + name ], doc[ "scroll" + name ],
    						elem.body[ "offset" + name ], doc[ "offset" + name ],
    						doc[ "client" + name ]
    					);
    				}

    				return value === undefined ?

    					// Get width or height on the element, requesting but not forcing parseFloat
    					jQuery.css( elem, type, extra ) :

    					// Set width or height on the element
    					jQuery.style( elem, type, value, extra );
    			}, type, chainable ? margin : undefined, chainable );
    		};
    	} );
    } );

    jQuery.fn.extend( {

    	bind: function( types, data, fn ) {
    		return this.on( types, null, data, fn );
    	},
    	unbind: function( types, fn ) {
    		return this.off( types, null, fn );
    	},

    	delegate: function( selector, types, data, fn ) {
    		return this.on( types, selector, data, fn );
    	},
    	undelegate: function( selector, types, fn ) {

    		// ( namespace ) or ( selector, types [, fn] )
    		return arguments.length === 1 ?
    			this.off( selector, "**" ) :
    			this.off( types, selector || "**", fn );
    	}
    } );

    jQuery.parseJSON = JSON.parse;

    // Register as a named AMD module, since jQuery can be concatenated with other
    // files that may use define, but not via a proper concatenation script that
    // understands anonymous AMD modules. A named AMD is safest and most robust
    // way to register. Lowercase jquery is used because AMD module names are
    // derived from file names, and jQuery is normally delivered in a lowercase
    // file name. Do this after creating the global so that if an AMD module wants
    // to call noConflict to hide this version of jQuery, it will work.

    // Note that for maximum portability, libraries that are not jQuery should
    // declare themselves as anonymous modules, and avoid setting a global if an
    // AMD loader is present. jQuery is a special case. For more information, see
    // https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon

    if ( typeof define === "function" && define.amd ) {
    	define( "jquery", [], function() {
    		return jQuery;
    	} );
    }

    var

    	// Map over jQuery in case of overwrite
    	_jQuery = window.jQuery,

    	// Map over the $ in case of overwrite
    	_$ = window.$;

    jQuery.noConflict = function( deep ) {
    	if ( window.$ === jQuery ) {
    		window.$ = _$;
    	}

    	if ( deep && window.jQuery === jQuery ) {
    		window.jQuery = _jQuery;
    	}

    	return jQuery;
    };

    // Expose jQuery and $ identifiers, even in AMD
    // (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
    // and CommonJS for browser emulators (#13566)
    if ( !noGlobal ) {
    	window.jQuery = window.$ = jQuery;
    }

    return jQuery;
    } );

    },{}],9:[function(require,module,exports){
    //! moment.js
    //! version : 2.17.1
    //! authors : Tim Wood, Iskren Chernev, Moment.js contributors
    //! license : MIT
    //! momentjs.com

    ;(function (global, factory) {
        typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
        typeof define === 'function' && define.amd ? define(factory) :
        global.moment = factory()
    }(this, (function () { 'use strict';

    var hookCallback;

    function hooks () {
        return hookCallback.apply(null, arguments);
    }

    // This is done to register the method called with moment()
    // without creating circular dependencies.
    function setHookCallback (callback) {
        hookCallback = callback;
    }

    function isArray(input) {
        return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';
    }

    function isObject(input) {
        // IE8 will treat undefined and null as object if it wasn't for
        // input != null
        return input != null && Object.prototype.toString.call(input) === '[object Object]';
    }

    function isObjectEmpty(obj) {
        var k;
        for (k in obj) {
            // even if its not own property I'd still call it non-empty
            return false;
        }
        return true;
    }

    function isNumber(input) {
        return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]';
    }

    function isDate(input) {
        return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
    }

    function map(arr, fn) {
        var res = [], i;
        for (i = 0; i < arr.length; ++i) {
            res.push(fn(arr[i], i));
        }
        return res;
    }

    function hasOwnProp(a, b) {
        return Object.prototype.hasOwnProperty.call(a, b);
    }

    function extend(a, b) {
        for (var i in b) {
            if (hasOwnProp(b, i)) {
                a[i] = b[i];
            }
        }

        if (hasOwnProp(b, 'toString')) {
            a.toString = b.toString;
        }

        if (hasOwnProp(b, 'valueOf')) {
            a.valueOf = b.valueOf;
        }

        return a;
    }

    function createUTC (input, format, locale, strict) {
        return createLocalOrUTC(input, format, locale, strict, true).utc();
    }

    function defaultParsingFlags() {
        // We need to deep clone this object.
        return {
            empty           : false,
            unusedTokens    : [],
            unusedInput     : [],
            overflow        : -2,
            charsLeftOver   : 0,
            nullInput       : false,
            invalidMonth    : null,
            invalidFormat   : false,
            userInvalidated : false,
            iso             : false,
            parsedDateParts : [],
            meridiem        : null
        };
    }

    function getParsingFlags(m) {
        if (m._pf == null) {
            m._pf = defaultParsingFlags();
        }
        return m._pf;
    }

    var some;
    if (Array.prototype.some) {
        some = Array.prototype.some;
    } else {
        some = function (fun) {
            var t = Object(this);
            var len = t.length >>> 0;

            for (var i = 0; i < len; i++) {
                if (i in t && fun.call(this, t[i], i, t)) {
                    return true;
                }
            }

            return false;
        };
    }

    var some$1 = some;

    function isValid(m) {
        if (m._isValid == null) {
            var flags = getParsingFlags(m);
            var parsedParts = some$1.call(flags.parsedDateParts, function (i) {
                return i != null;
            });
            var isNowValid = !isNaN(m._d.getTime()) &&
                flags.overflow < 0 &&
                !flags.empty &&
                !flags.invalidMonth &&
                !flags.invalidWeekday &&
                !flags.nullInput &&
                !flags.invalidFormat &&
                !flags.userInvalidated &&
                (!flags.meridiem || (flags.meridiem && parsedParts));

            if (m._strict) {
                isNowValid = isNowValid &&
                    flags.charsLeftOver === 0 &&
                    flags.unusedTokens.length === 0 &&
                    flags.bigHour === undefined;
            }

            if (Object.isFrozen == null || !Object.isFrozen(m)) {
                m._isValid = isNowValid;
            }
            else {
                return isNowValid;
            }
        }
        return m._isValid;
    }

    function createInvalid (flags) {
        var m = createUTC(NaN);
        if (flags != null) {
            extend(getParsingFlags(m), flags);
        }
        else {
            getParsingFlags(m).userInvalidated = true;
        }

        return m;
    }

    function isUndefined(input) {
        return input === void 0;
    }

    // Plugins that add properties should also add the key here (null value),
    // so we can properly clone ourselves.
    var momentProperties = hooks.momentProperties = [];

    function copyConfig(to, from) {
        var i, prop, val;

        if (!isUndefined(from._isAMomentObject)) {
            to._isAMomentObject = from._isAMomentObject;
        }
        if (!isUndefined(from._i)) {
            to._i = from._i;
        }
        if (!isUndefined(from._f)) {
            to._f = from._f;
        }
        if (!isUndefined(from._l)) {
            to._l = from._l;
        }
        if (!isUndefined(from._strict)) {
            to._strict = from._strict;
        }
        if (!isUndefined(from._tzm)) {
            to._tzm = from._tzm;
        }
        if (!isUndefined(from._isUTC)) {
            to._isUTC = from._isUTC;
        }
        if (!isUndefined(from._offset)) {
            to._offset = from._offset;
        }
        if (!isUndefined(from._pf)) {
            to._pf = getParsingFlags(from);
        }
        if (!isUndefined(from._locale)) {
            to._locale = from._locale;
        }

        if (momentProperties.length > 0) {
            for (i in momentProperties) {
                prop = momentProperties[i];
                val = from[prop];
                if (!isUndefined(val)) {
                    to[prop] = val;
                }
            }
        }

        return to;
    }

    var updateInProgress = false;

    // Moment prototype object
    function Moment(config) {
        copyConfig(this, config);
        this._d = new Date(config._d != null ? config._d.getTime() : NaN);
        if (!this.isValid()) {
            this._d = new Date(NaN);
        }
        // Prevent infinite loop in case updateOffset creates new moment
        // objects.
        if (updateInProgress === false) {
            updateInProgress = true;
            hooks.updateOffset(this);
            updateInProgress = false;
        }
    }

    function isMoment (obj) {
        return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
    }

    function absFloor (number) {
        if (number < 0) {
            // -0 -> 0
            return Math.ceil(number) || 0;
        } else {
            return Math.floor(number);
        }
    }

    function toInt(argumentForCoercion) {
        var coercedNumber = +argumentForCoercion,
            value = 0;

        if (coercedNumber !== 0 && isFinite(coercedNumber)) {
            value = absFloor(coercedNumber);
        }

        return value;
    }

    // compare two arrays, return the number of differences
    function compareArrays(array1, array2, dontConvert) {
        var len = Math.min(array1.length, array2.length),
            lengthDiff = Math.abs(array1.length - array2.length),
            diffs = 0,
            i;
        for (i = 0; i < len; i++) {
            if ((dontConvert && array1[i] !== array2[i]) ||
                (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
                diffs++;
            }
        }
        return diffs + lengthDiff;
    }

    function warn(msg) {
        if (hooks.suppressDeprecationWarnings === false &&
                (typeof console !==  'undefined') && console.warn) {
            console.warn('Deprecation warning: ' + msg);
        }
    }

    function deprecate(msg, fn) {
        var firstTime = true;

        return extend(function () {
            if (hooks.deprecationHandler != null) {
                hooks.deprecationHandler(null, msg);
            }
            if (firstTime) {
                var args = [];
                var arg;
                for (var i = 0; i < arguments.length; i++) {
                    arg = '';
                    if (typeof arguments[i] === 'object') {
                        arg += '\n[' + i + '] ';
                        for (var key in arguments[0]) {
                            arg += key + ': ' + arguments[0][key] + ', ';
                        }
                        arg = arg.slice(0, -2); // Remove trailing comma and space
                    } else {
                        arg = arguments[i];
                    }
                    args.push(arg);
                }
                warn(msg + '\nArguments: ' + Array.prototype.slice.call(args).join('') + '\n' + (new Error()).stack);
                firstTime = false;
            }
            return fn.apply(this, arguments);
        }, fn);
    }

    var deprecations = {};

    function deprecateSimple(name, msg) {
        if (hooks.deprecationHandler != null) {
            hooks.deprecationHandler(name, msg);
        }
        if (!deprecations[name]) {
            warn(msg);
            deprecations[name] = true;
        }
    }

    hooks.suppressDeprecationWarnings = false;
    hooks.deprecationHandler = null;

    function isFunction(input) {
        return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';
    }

    function set (config) {
        var prop, i;
        for (i in config) {
            prop = config[i];
            if (isFunction(prop)) {
                this[i] = prop;
            } else {
                this['_' + i] = prop;
            }
        }
        this._config = config;
        // Lenient ordinal parsing accepts just a number in addition to
        // number + (possibly) stuff coming from _ordinalParseLenient.
        this._ordinalParseLenient = new RegExp(this._ordinalParse.source + '|' + (/\d{1,2}/).source);
    }

    function mergeConfigs(parentConfig, childConfig) {
        var res = extend({}, parentConfig), prop;
        for (prop in childConfig) {
            if (hasOwnProp(childConfig, prop)) {
                if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
                    res[prop] = {};
                    extend(res[prop], parentConfig[prop]);
                    extend(res[prop], childConfig[prop]);
                } else if (childConfig[prop] != null) {
                    res[prop] = childConfig[prop];
                } else {
                    delete res[prop];
                }
            }
        }
        for (prop in parentConfig) {
            if (hasOwnProp(parentConfig, prop) &&
                    !hasOwnProp(childConfig, prop) &&
                    isObject(parentConfig[prop])) {
                // make sure changes to properties don't modify parent config
                res[prop] = extend({}, res[prop]);
            }
        }
        return res;
    }

    function Locale(config) {
        if (config != null) {
            this.set(config);
        }
    }

    var keys;

    if (Object.keys) {
        keys = Object.keys;
    } else {
        keys = function (obj) {
            var i, res = [];
            for (i in obj) {
                if (hasOwnProp(obj, i)) {
                    res.push(i);
                }
            }
            return res;
        };
    }

    var keys$1 = keys;

    var defaultCalendar = {
        sameDay : '[Today at] LT',
        nextDay : '[Tomorrow at] LT',
        nextWeek : 'dddd [at] LT',
        lastDay : '[Yesterday at] LT',
        lastWeek : '[Last] dddd [at] LT',
        sameElse : 'L'
    };

    function calendar (key, mom, now) {
        var output = this._calendar[key] || this._calendar['sameElse'];
        return isFunction(output) ? output.call(mom, now) : output;
    }

    var defaultLongDateFormat = {
        LTS  : 'h:mm:ss A',
        LT   : 'h:mm A',
        L    : 'MM/DD/YYYY',
        LL   : 'MMMM D, YYYY',
        LLL  : 'MMMM D, YYYY h:mm A',
        LLLL : 'dddd, MMMM D, YYYY h:mm A'
    };

    function longDateFormat (key) {
        var format = this._longDateFormat[key],
            formatUpper = this._longDateFormat[key.toUpperCase()];

        if (format || !formatUpper) {
            return format;
        }

        this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
            return val.slice(1);
        });

        return this._longDateFormat[key];
    }

    var defaultInvalidDate = 'Invalid date';

    function invalidDate () {
        return this._invalidDate;
    }

    var defaultOrdinal = '%d';
    var defaultOrdinalParse = /\d{1,2}/;

    function ordinal (number) {
        return this._ordinal.replace('%d', number);
    }

    var defaultRelativeTime = {
        future : 'in %s',
        past   : '%s ago',
        s  : 'a few seconds',
        m  : 'a minute',
        mm : '%d minutes',
        h  : 'an hour',
        hh : '%d hours',
        d  : 'a day',
        dd : '%d days',
        M  : 'a month',
        MM : '%d months',
        y  : 'a year',
        yy : '%d years'
    };

    function relativeTime (number, withoutSuffix, string, isFuture) {
        var output = this._relativeTime[string];
        return (isFunction(output)) ?
            output(number, withoutSuffix, string, isFuture) :
            output.replace(/%d/i, number);
    }

    function pastFuture (diff, output) {
        var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
        return isFunction(format) ? format(output) : format.replace(/%s/i, output);
    }

    var aliases = {};

    function addUnitAlias (unit, shorthand) {
        var lowerCase = unit.toLowerCase();
        aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
    }

    function normalizeUnits(units) {
        return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
    }

    function normalizeObjectUnits(inputObject) {
        var normalizedInput = {},
            normalizedProp,
            prop;

        for (prop in inputObject) {
            if (hasOwnProp(inputObject, prop)) {
                normalizedProp = normalizeUnits(prop);
                if (normalizedProp) {
                    normalizedInput[normalizedProp] = inputObject[prop];
                }
            }
        }

        return normalizedInput;
    }

    var priorities = {};

    function addUnitPriority(unit, priority) {
        priorities[unit] = priority;
    }

    function getPrioritizedUnits(unitsObj) {
        var units = [];
        for (var u in unitsObj) {
            units.push({unit: u, priority: priorities[u]});
        }
        units.sort(function (a, b) {
            return a.priority - b.priority;
        });
        return units;
    }

    function makeGetSet (unit, keepTime) {
        return function (value) {
            if (value != null) {
                set$1(this, unit, value);
                hooks.updateOffset(this, keepTime);
                return this;
            } else {
                return get(this, unit);
            }
        };
    }

    function get (mom, unit) {
        return mom.isValid() ?
            mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;
    }

    function set$1 (mom, unit, value) {
        if (mom.isValid()) {
            mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
        }
    }

    // MOMENTS

    function stringGet (units) {
        units = normalizeUnits(units);
        if (isFunction(this[units])) {
            return this[units]();
        }
        return this;
    }

    function stringSet (units, value) {
        if (typeof units === 'object') {
            units = normalizeObjectUnits(units);
            var prioritized = getPrioritizedUnits(units);
            for (var i = 0; i < prioritized.length; i++) {
                this[prioritized[i].unit](units[prioritized[i].unit]);
            }
        } else {
            units = normalizeUnits(units);
            if (isFunction(this[units])) {
                return this[units](value);
            }
        }
        return this;
    }

    function zeroFill(number, targetLength, forceSign) {
        var absNumber = '' + Math.abs(number),
            zerosToFill = targetLength - absNumber.length,
            sign = number >= 0;
        return (sign ? (forceSign ? '+' : '') : '-') +
            Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
    }

    var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;

    var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;

    var formatFunctions = {};

    var formatTokenFunctions = {};

    // token:    'M'
    // padded:   ['MM', 2]
    // ordinal:  'Mo'
    // callback: function () { this.month() + 1 }
    function addFormatToken (token, padded, ordinal, callback) {
        var func = callback;
        if (typeof callback === 'string') {
            func = function () {
                return this[callback]();
            };
        }
        if (token) {
            formatTokenFunctions[token] = func;
        }
        if (padded) {
            formatTokenFunctions[padded[0]] = function () {
                return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
            };
        }
        if (ordinal) {
            formatTokenFunctions[ordinal] = function () {
                return this.localeData().ordinal(func.apply(this, arguments), token);
            };
        }
    }

    function removeFormattingTokens(input) {
        if (input.match(/\[[\s\S]/)) {
            return input.replace(/^\[|\]$/g, '');
        }
        return input.replace(/\\/g, '');
    }

    function makeFormatFunction(format) {
        var array = format.match(formattingTokens), i, length;

        for (i = 0, length = array.length; i < length; i++) {
            if (formatTokenFunctions[array[i]]) {
                array[i] = formatTokenFunctions[array[i]];
            } else {
                array[i] = removeFormattingTokens(array[i]);
            }
        }

        return function (mom) {
            var output = '', i;
            for (i = 0; i < length; i++) {
                output += array[i] instanceof Function ? array[i].call(mom, format) : array[i];
            }
            return output;
        };
    }

    // format date using native date object
    function formatMoment(m, format) {
        if (!m.isValid()) {
            return m.localeData().invalidDate();
        }

        format = expandFormat(format, m.localeData());
        formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);

        return formatFunctions[format](m);
    }

    function expandFormat(format, locale) {
        var i = 5;

        function replaceLongDateFormatTokens(input) {
            return locale.longDateFormat(input) || input;
        }

        localFormattingTokens.lastIndex = 0;
        while (i >= 0 && localFormattingTokens.test(format)) {
            format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
            localFormattingTokens.lastIndex = 0;
            i -= 1;
        }

        return format;
    }

    var match1         = /\d/;            //       0 - 9
    var match2         = /\d\d/;          //      00 - 99
    var match3         = /\d{3}/;         //     000 - 999
    var match4         = /\d{4}/;         //    0000 - 9999
    var match6         = /[+-]?\d{6}/;    // -999999 - 999999
    var match1to2      = /\d\d?/;         //       0 - 99
    var match3to4      = /\d\d\d\d?/;     //     999 - 9999
    var match5to6      = /\d\d\d\d\d\d?/; //   99999 - 999999
    var match1to3      = /\d{1,3}/;       //       0 - 999
    var match1to4      = /\d{1,4}/;       //       0 - 9999
    var match1to6      = /[+-]?\d{1,6}/;  // -999999 - 999999

    var matchUnsigned  = /\d+/;           //       0 - inf
    var matchSigned    = /[+-]?\d+/;      //    -inf - inf

    var matchOffset    = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
    var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z

    var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123

    // any word (or two) characters or numbers including two/three word month in arabic.
    // includes scottish gaelic two word and hyphenated months
    var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;

    var regexes = {};

    function addRegexToken (token, regex, strictRegex) {
        regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
            return (isStrict && strictRegex) ? strictRegex : regex;
        };
    }

    function getParseRegexForToken (token, config) {
        if (!hasOwnProp(regexes, token)) {
            return new RegExp(unescapeFormat(token));
        }

        return regexes[token](config._strict, config._locale);
    }

    // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
    function unescapeFormat(s) {
        return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
            return p1 || p2 || p3 || p4;
        }));
    }

    function regexEscape(s) {
        return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
    }

    var tokens = {};

    function addParseToken (token, callback) {
        var i, func = callback;
        if (typeof token === 'string') {
            token = [token];
        }
        if (isNumber(callback)) {
            func = function (input, array) {
                array[callback] = toInt(input);
            };
        }
        for (i = 0; i < token.length; i++) {
            tokens[token[i]] = func;
        }
    }

    function addWeekParseToken (token, callback) {
        addParseToken(token, function (input, array, config, token) {
            config._w = config._w || {};
            callback(input, config._w, config, token);
        });
    }

    function addTimeToArrayFromToken(token, input, config) {
        if (input != null && hasOwnProp(tokens, token)) {
            tokens[token](input, config._a, config, token);
        }
    }

    var YEAR = 0;
    var MONTH = 1;
    var DATE = 2;
    var HOUR = 3;
    var MINUTE = 4;
    var SECOND = 5;
    var MILLISECOND = 6;
    var WEEK = 7;
    var WEEKDAY = 8;

    var indexOf;

    if (Array.prototype.indexOf) {
        indexOf = Array.prototype.indexOf;
    } else {
        indexOf = function (o) {
            // I know
            var i;
            for (i = 0; i < this.length; ++i) {
                if (this[i] === o) {
                    return i;
                }
            }
            return -1;
        };
    }

    var indexOf$1 = indexOf;

    function daysInMonth(year, month) {
        return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
    }

    // FORMATTING

    addFormatToken('M', ['MM', 2], 'Mo', function () {
        return this.month() + 1;
    });

    addFormatToken('MMM', 0, 0, function (format) {
        return this.localeData().monthsShort(this, format);
    });

    addFormatToken('MMMM', 0, 0, function (format) {
        return this.localeData().months(this, format);
    });

    // ALIASES

    addUnitAlias('month', 'M');

    // PRIORITY

    addUnitPriority('month', 8);

    // PARSING

    addRegexToken('M',    match1to2);
    addRegexToken('MM',   match1to2, match2);
    addRegexToken('MMM',  function (isStrict, locale) {
        return locale.monthsShortRegex(isStrict);
    });
    addRegexToken('MMMM', function (isStrict, locale) {
        return locale.monthsRegex(isStrict);
    });

    addParseToken(['M', 'MM'], function (input, array) {
        array[MONTH] = toInt(input) - 1;
    });

    addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
        var month = config._locale.monthsParse(input, token, config._strict);
        // if we didn't find a month name, mark the date as invalid.
        if (month != null) {
            array[MONTH] = month;
        } else {
            getParsingFlags(config).invalidMonth = input;
        }
    });

    // LOCALES

    var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/;
    var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
    function localeMonths (m, format) {
        if (!m) {
            return this._months;
        }
        return isArray(this._months) ? this._months[m.month()] :
            this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];
    }

    var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
    function localeMonthsShort (m, format) {
        if (!m) {
            return this._monthsShort;
        }
        return isArray(this._monthsShort) ? this._monthsShort[m.month()] :
            this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
    }

    function handleStrictParse(monthName, format, strict) {
        var i, ii, mom, llc = monthName.toLocaleLowerCase();
        if (!this._monthsParse) {
            // this is not used
            this._monthsParse = [];
            this._longMonthsParse = [];
            this._shortMonthsParse = [];
            for (i = 0; i < 12; ++i) {
                mom = createUTC([2000, i]);
                this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();
                this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
            }
        }

        if (strict) {
            if (format === 'MMM') {
                ii = indexOf$1.call(this._shortMonthsParse, llc);
                return ii !== -1 ? ii : null;
            } else {
                ii = indexOf$1.call(this._longMonthsParse, llc);
                return ii !== -1 ? ii : null;
            }
        } else {
            if (format === 'MMM') {
                ii = indexOf$1.call(this._shortMonthsParse, llc);
                if (ii !== -1) {
                    return ii;
                }
                ii = indexOf$1.call(this._longMonthsParse, llc);
                return ii !== -1 ? ii : null;
            } else {
                ii = indexOf$1.call(this._longMonthsParse, llc);
                if (ii !== -1) {
                    return ii;
                }
                ii = indexOf$1.call(this._shortMonthsParse, llc);
                return ii !== -1 ? ii : null;
            }
        }
    }

    function localeMonthsParse (monthName, format, strict) {
        var i, mom, regex;

        if (this._monthsParseExact) {
            return handleStrictParse.call(this, monthName, format, strict);
        }

        if (!this._monthsParse) {
            this._monthsParse = [];
            this._longMonthsParse = [];
            this._shortMonthsParse = [];
        }

        // TODO: add sorting
        // Sorting makes sure if one month (or abbr) is a prefix of another
        // see sorting in computeMonthsParse
        for (i = 0; i < 12; i++) {
            // make the regex if we don't have it already
            mom = createUTC([2000, i]);
            if (strict && !this._longMonthsParse[i]) {
                this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
                this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
            }
            if (!strict && !this._monthsParse[i]) {
                regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
                this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
            }
            // test the regex
            if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
                return i;
            } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
                return i;
            } else if (!strict && this._monthsParse[i].test(monthName)) {
                return i;
            }
        }
    }

    // MOMENTS

    function setMonth (mom, value) {
        var dayOfMonth;

        if (!mom.isValid()) {
            // No op
            return mom;
        }

        if (typeof value === 'string') {
            if (/^\d+$/.test(value)) {
                value = toInt(value);
            } else {
                value = mom.localeData().monthsParse(value);
                // TODO: Another silent failure?
                if (!isNumber(value)) {
                    return mom;
                }
            }
        }

        dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
        mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
        return mom;
    }

    function getSetMonth (value) {
        if (value != null) {
            setMonth(this, value);
            hooks.updateOffset(this, true);
            return this;
        } else {
            return get(this, 'Month');
        }
    }

    function getDaysInMonth () {
        return daysInMonth(this.year(), this.month());
    }

    var defaultMonthsShortRegex = matchWord;
    function monthsShortRegex (isStrict) {
        if (this._monthsParseExact) {
            if (!hasOwnProp(this, '_monthsRegex')) {
                computeMonthsParse.call(this);
            }
            if (isStrict) {
                return this._monthsShortStrictRegex;
            } else {
                return this._monthsShortRegex;
            }
        } else {
            if (!hasOwnProp(this, '_monthsShortRegex')) {
                this._monthsShortRegex = defaultMonthsShortRegex;
            }
            return this._monthsShortStrictRegex && isStrict ?
                this._monthsShortStrictRegex : this._monthsShortRegex;
        }
    }

    var defaultMonthsRegex = matchWord;
    function monthsRegex (isStrict) {
        if (this._monthsParseExact) {
            if (!hasOwnProp(this, '_monthsRegex')) {
                computeMonthsParse.call(this);
            }
            if (isStrict) {
                return this._monthsStrictRegex;
            } else {
                return this._monthsRegex;
            }
        } else {
            if (!hasOwnProp(this, '_monthsRegex')) {
                this._monthsRegex = defaultMonthsRegex;
            }
            return this._monthsStrictRegex && isStrict ?
                this._monthsStrictRegex : this._monthsRegex;
        }
    }

    function computeMonthsParse () {
        function cmpLenRev(a, b) {
            return b.length - a.length;
        }

        var shortPieces = [], longPieces = [], mixedPieces = [],
            i, mom;
        for (i = 0; i < 12; i++) {
            // make the regex if we don't have it already
            mom = createUTC([2000, i]);
            shortPieces.push(this.monthsShort(mom, ''));
            longPieces.push(this.months(mom, ''));
            mixedPieces.push(this.months(mom, ''));
            mixedPieces.push(this.monthsShort(mom, ''));
        }
        // Sorting makes sure if one month (or abbr) is a prefix of another it
        // will match the longer piece.
        shortPieces.sort(cmpLenRev);
        longPieces.sort(cmpLenRev);
        mixedPieces.sort(cmpLenRev);
        for (i = 0; i < 12; i++) {
            shortPieces[i] = regexEscape(shortPieces[i]);
            longPieces[i] = regexEscape(longPieces[i]);
        }
        for (i = 0; i < 24; i++) {
            mixedPieces[i] = regexEscape(mixedPieces[i]);
        }

        this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
        this._monthsShortRegex = this._monthsRegex;
        this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
        this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
    }

    // FORMATTING

    addFormatToken('Y', 0, 0, function () {
        var y = this.year();
        return y <= 9999 ? '' + y : '+' + y;
    });

    addFormatToken(0, ['YY', 2], 0, function () {
        return this.year() % 100;
    });

    addFormatToken(0, ['YYYY',   4],       0, 'year');
    addFormatToken(0, ['YYYYY',  5],       0, 'year');
    addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');

    // ALIASES

    addUnitAlias('year', 'y');

    // PRIORITIES

    addUnitPriority('year', 1);

    // PARSING

    addRegexToken('Y',      matchSigned);
    addRegexToken('YY',     match1to2, match2);
    addRegexToken('YYYY',   match1to4, match4);
    addRegexToken('YYYYY',  match1to6, match6);
    addRegexToken('YYYYYY', match1to6, match6);

    addParseToken(['YYYYY', 'YYYYYY'], YEAR);
    addParseToken('YYYY', function (input, array) {
        array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
    });
    addParseToken('YY', function (input, array) {
        array[YEAR] = hooks.parseTwoDigitYear(input);
    });
    addParseToken('Y', function (input, array) {
        array[YEAR] = parseInt(input, 10);
    });

    // HELPERS

    function daysInYear(year) {
        return isLeapYear(year) ? 366 : 365;
    }

    function isLeapYear(year) {
        return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
    }

    // HOOKS

    hooks.parseTwoDigitYear = function (input) {
        return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
    };

    // MOMENTS

    var getSetYear = makeGetSet('FullYear', true);

    function getIsLeapYear () {
        return isLeapYear(this.year());
    }

    function createDate (y, m, d, h, M, s, ms) {
        //can't just apply() to create a date:
        //http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
        var date = new Date(y, m, d, h, M, s, ms);

        //the date constructor remaps years 0-99 to 1900-1999
        if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {
            date.setFullYear(y);
        }
        return date;
    }

    function createUTCDate (y) {
        var date = new Date(Date.UTC.apply(null, arguments));

        //the Date.UTC function remaps years 0-99 to 1900-1999
        if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {
            date.setUTCFullYear(y);
        }
        return date;
    }

    // start-of-first-week - start-of-year
    function firstWeekOffset(year, dow, doy) {
        var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
            fwd = 7 + dow - doy,
            // first-week day local weekday -- which local weekday is fwd
            fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;

        return -fwdlw + fwd - 1;
    }

    //http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
    function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
        var localWeekday = (7 + weekday - dow) % 7,
            weekOffset = firstWeekOffset(year, dow, doy),
            dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
            resYear, resDayOfYear;

        if (dayOfYear <= 0) {
            resYear = year - 1;
            resDayOfYear = daysInYear(resYear) + dayOfYear;
        } else if (dayOfYear > daysInYear(year)) {
            resYear = year + 1;
            resDayOfYear = dayOfYear - daysInYear(year);
        } else {
            resYear = year;
            resDayOfYear = dayOfYear;
        }

        return {
            year: resYear,
            dayOfYear: resDayOfYear
        };
    }

    function weekOfYear(mom, dow, doy) {
        var weekOffset = firstWeekOffset(mom.year(), dow, doy),
            week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
            resWeek, resYear;

        if (week < 1) {
            resYear = mom.year() - 1;
            resWeek = week + weeksInYear(resYear, dow, doy);
        } else if (week > weeksInYear(mom.year(), dow, doy)) {
            resWeek = week - weeksInYear(mom.year(), dow, doy);
            resYear = mom.year() + 1;
        } else {
            resYear = mom.year();
            resWeek = week;
        }

        return {
            week: resWeek,
            year: resYear
        };
    }

    function weeksInYear(year, dow, doy) {
        var weekOffset = firstWeekOffset(year, dow, doy),
            weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
        return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
    }

    // FORMATTING

    addFormatToken('w', ['ww', 2], 'wo', 'week');
    addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');

    // ALIASES

    addUnitAlias('week', 'w');
    addUnitAlias('isoWeek', 'W');

    // PRIORITIES

    addUnitPriority('week', 5);
    addUnitPriority('isoWeek', 5);

    // PARSING

    addRegexToken('w',  match1to2);
    addRegexToken('ww', match1to2, match2);
    addRegexToken('W',  match1to2);
    addRegexToken('WW', match1to2, match2);

    addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
        week[token.substr(0, 1)] = toInt(input);
    });

    // HELPERS

    // LOCALES

    function localeWeek (mom) {
        return weekOfYear(mom, this._week.dow, this._week.doy).week;
    }

    var defaultLocaleWeek = {
        dow : 0, // Sunday is the first day of the week.
        doy : 6  // The week that contains Jan 1st is the first week of the year.
    };

    function localeFirstDayOfWeek () {
        return this._week.dow;
    }

    function localeFirstDayOfYear () {
        return this._week.doy;
    }

    // MOMENTS

    function getSetWeek (input) {
        var week = this.localeData().week(this);
        return input == null ? week : this.add((input - week) * 7, 'd');
    }

    function getSetISOWeek (input) {
        var week = weekOfYear(this, 1, 4).week;
        return input == null ? week : this.add((input - week) * 7, 'd');
    }

    // FORMATTING

    addFormatToken('d', 0, 'do', 'day');

    addFormatToken('dd', 0, 0, function (format) {
        return this.localeData().weekdaysMin(this, format);
    });

    addFormatToken('ddd', 0, 0, function (format) {
        return this.localeData().weekdaysShort(this, format);
    });

    addFormatToken('dddd', 0, 0, function (format) {
        return this.localeData().weekdays(this, format);
    });

    addFormatToken('e', 0, 0, 'weekday');
    addFormatToken('E', 0, 0, 'isoWeekday');

    // ALIASES

    addUnitAlias('day', 'd');
    addUnitAlias('weekday', 'e');
    addUnitAlias('isoWeekday', 'E');

    // PRIORITY
    addUnitPriority('day', 11);
    addUnitPriority('weekday', 11);
    addUnitPriority('isoWeekday', 11);

    // PARSING

    addRegexToken('d',    match1to2);
    addRegexToken('e',    match1to2);
    addRegexToken('E',    match1to2);
    addRegexToken('dd',   function (isStrict, locale) {
        return locale.weekdaysMinRegex(isStrict);
    });
    addRegexToken('ddd',   function (isStrict, locale) {
        return locale.weekdaysShortRegex(isStrict);
    });
    addRegexToken('dddd',   function (isStrict, locale) {
        return locale.weekdaysRegex(isStrict);
    });

    addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
        var weekday = config._locale.weekdaysParse(input, token, config._strict);
        // if we didn't get a weekday name, mark the date as invalid
        if (weekday != null) {
            week.d = weekday;
        } else {
            getParsingFlags(config).invalidWeekday = input;
        }
    });

    addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
        week[token] = toInt(input);
    });

    // HELPERS

    function parseWeekday(input, locale) {
        if (typeof input !== 'string') {
            return input;
        }

        if (!isNaN(input)) {
            return parseInt(input, 10);
        }

        input = locale.weekdaysParse(input);
        if (typeof input === 'number') {
            return input;
        }

        return null;
    }

    function parseIsoWeekday(input, locale) {
        if (typeof input === 'string') {
            return locale.weekdaysParse(input) % 7 || 7;
        }
        return isNaN(input) ? null : input;
    }

    // LOCALES

    var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
    function localeWeekdays (m, format) {
        if (!m) {
            return this._weekdays;
        }
        return isArray(this._weekdays) ? this._weekdays[m.day()] :
            this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()];
    }

    var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
    function localeWeekdaysShort (m) {
        return (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;
    }

    var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
    function localeWeekdaysMin (m) {
        return (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;
    }

    function handleStrictParse$1(weekdayName, format, strict) {
        var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
        if (!this._weekdaysParse) {
            this._weekdaysParse = [];
            this._shortWeekdaysParse = [];
            this._minWeekdaysParse = [];

            for (i = 0; i < 7; ++i) {
                mom = createUTC([2000, 1]).day(i);
                this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();
                this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();
                this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
            }
        }

        if (strict) {
            if (format === 'dddd') {
                ii = indexOf$1.call(this._weekdaysParse, llc);
                return ii !== -1 ? ii : null;
            } else if (format === 'ddd') {
                ii = indexOf$1.call(this._shortWeekdaysParse, llc);
                return ii !== -1 ? ii : null;
            } else {
                ii = indexOf$1.call(this._minWeekdaysParse, llc);
                return ii !== -1 ? ii : null;
            }
        } else {
            if (format === 'dddd') {
                ii = indexOf$1.call(this._weekdaysParse, llc);
                if (ii !== -1) {
                    return ii;
                }
                ii = indexOf$1.call(this._shortWeekdaysParse, llc);
                if (ii !== -1) {
                    return ii;
                }
                ii = indexOf$1.call(this._minWeekdaysParse, llc);
                return ii !== -1 ? ii : null;
            } else if (format === 'ddd') {
                ii = indexOf$1.call(this._shortWeekdaysParse, llc);
                if (ii !== -1) {
                    return ii;
                }
                ii = indexOf$1.call(this._weekdaysParse, llc);
                if (ii !== -1) {
                    return ii;
                }
                ii = indexOf$1.call(this._minWeekdaysParse, llc);
                return ii !== -1 ? ii : null;
            } else {
                ii = indexOf$1.call(this._minWeekdaysParse, llc);
                if (ii !== -1) {
                    return ii;
                }
                ii = indexOf$1.call(this._weekdaysParse, llc);
                if (ii !== -1) {
                    return ii;
                }
                ii = indexOf$1.call(this._shortWeekdaysParse, llc);
                return ii !== -1 ? ii : null;
            }
        }
    }

    function localeWeekdaysParse (weekdayName, format, strict) {
        var i, mom, regex;

        if (this._weekdaysParseExact) {
            return handleStrictParse$1.call(this, weekdayName, format, strict);
        }

        if (!this._weekdaysParse) {
            this._weekdaysParse = [];
            this._minWeekdaysParse = [];
            this._shortWeekdaysParse = [];
            this._fullWeekdaysParse = [];
        }

        for (i = 0; i < 7; i++) {
            // make the regex if we don't have it already

            mom = createUTC([2000, 1]).day(i);
            if (strict && !this._fullWeekdaysParse[i]) {
                this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\.?') + '$', 'i');
                this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\.?') + '$', 'i');
                this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\.?') + '$', 'i');
            }
            if (!this._weekdaysParse[i]) {
                regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
                this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
            }
            // test the regex
            if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {
                return i;
            } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {
                return i;
            } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {
                return i;
            } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
                return i;
            }
        }
    }

    // MOMENTS

    function getSetDayOfWeek (input) {
        if (!this.isValid()) {
            return input != null ? this : NaN;
        }
        var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
        if (input != null) {
            input = parseWeekday(input, this.localeData());
            return this.add(input - day, 'd');
        } else {
            return day;
        }
    }

    function getSetLocaleDayOfWeek (input) {
        if (!this.isValid()) {
            return input != null ? this : NaN;
        }
        var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
        return input == null ? weekday : this.add(input - weekday, 'd');
    }

    function getSetISODayOfWeek (input) {
        if (!this.isValid()) {
            return input != null ? this : NaN;
        }

        // behaves the same as moment#day except
        // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
        // as a setter, sunday should belong to the previous week.

        if (input != null) {
            var weekday = parseIsoWeekday(input, this.localeData());
            return this.day(this.day() % 7 ? weekday : weekday - 7);
        } else {
            return this.day() || 7;
        }
    }

    var defaultWeekdaysRegex = matchWord;
    function weekdaysRegex (isStrict) {
        if (this._weekdaysParseExact) {
            if (!hasOwnProp(this, '_weekdaysRegex')) {
                computeWeekdaysParse.call(this);
            }
            if (isStrict) {
                return this._weekdaysStrictRegex;
            } else {
                return this._weekdaysRegex;
            }
        } else {
            if (!hasOwnProp(this, '_weekdaysRegex')) {
                this._weekdaysRegex = defaultWeekdaysRegex;
            }
            return this._weekdaysStrictRegex && isStrict ?
                this._weekdaysStrictRegex : this._weekdaysRegex;
        }
    }

    var defaultWeekdaysShortRegex = matchWord;
    function weekdaysShortRegex (isStrict) {
        if (this._weekdaysParseExact) {
            if (!hasOwnProp(this, '_weekdaysRegex')) {
                computeWeekdaysParse.call(this);
            }
            if (isStrict) {
                return this._weekdaysShortStrictRegex;
            } else {
                return this._weekdaysShortRegex;
            }
        } else {
            if (!hasOwnProp(this, '_weekdaysShortRegex')) {
                this._weekdaysShortRegex = defaultWeekdaysShortRegex;
            }
            return this._weekdaysShortStrictRegex && isStrict ?
                this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
        }
    }

    var defaultWeekdaysMinRegex = matchWord;
    function weekdaysMinRegex (isStrict) {
        if (this._weekdaysParseExact) {
            if (!hasOwnProp(this, '_weekdaysRegex')) {
                computeWeekdaysParse.call(this);
            }
            if (isStrict) {
                return this._weekdaysMinStrictRegex;
            } else {
                return this._weekdaysMinRegex;
            }
        } else {
            if (!hasOwnProp(this, '_weekdaysMinRegex')) {
                this._weekdaysMinRegex = defaultWeekdaysMinRegex;
            }
            return this._weekdaysMinStrictRegex && isStrict ?
                this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
        }
    }

    function computeWeekdaysParse () {
        function cmpLenRev(a, b) {
            return b.length - a.length;
        }

        var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [],
            i, mom, minp, shortp, longp;
        for (i = 0; i < 7; i++) {
            // make the regex if we don't have it already
            mom = createUTC([2000, 1]).day(i);
            minp = this.weekdaysMin(mom, '');
            shortp = this.weekdaysShort(mom, '');
            longp = this.weekdays(mom, '');
            minPieces.push(minp);
            shortPieces.push(shortp);
            longPieces.push(longp);
            mixedPieces.push(minp);
            mixedPieces.push(shortp);
            mixedPieces.push(longp);
        }
        // Sorting makes sure if one weekday (or abbr) is a prefix of another it
        // will match the longer piece.
        minPieces.sort(cmpLenRev);
        shortPieces.sort(cmpLenRev);
        longPieces.sort(cmpLenRev);
        mixedPieces.sort(cmpLenRev);
        for (i = 0; i < 7; i++) {
            shortPieces[i] = regexEscape(shortPieces[i]);
            longPieces[i] = regexEscape(longPieces[i]);
            mixedPieces[i] = regexEscape(mixedPieces[i]);
        }

        this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
        this._weekdaysShortRegex = this._weekdaysRegex;
        this._weekdaysMinRegex = this._weekdaysRegex;

        this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
        this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
        this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');
    }

    // FORMATTING

    function hFormat() {
        return this.hours() % 12 || 12;
    }

    function kFormat() {
        return this.hours() || 24;
    }

    addFormatToken('H', ['HH', 2], 0, 'hour');
    addFormatToken('h', ['hh', 2], 0, hFormat);
    addFormatToken('k', ['kk', 2], 0, kFormat);

    addFormatToken('hmm', 0, 0, function () {
        return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
    });

    addFormatToken('hmmss', 0, 0, function () {
        return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +
            zeroFill(this.seconds(), 2);
    });

    addFormatToken('Hmm', 0, 0, function () {
        return '' + this.hours() + zeroFill(this.minutes(), 2);
    });

    addFormatToken('Hmmss', 0, 0, function () {
        return '' + this.hours() + zeroFill(this.minutes(), 2) +
            zeroFill(this.seconds(), 2);
    });

    function meridiem (token, lowercase) {
        addFormatToken(token, 0, 0, function () {
            return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
        });
    }

    meridiem('a', true);
    meridiem('A', false);

    // ALIASES

    addUnitAlias('hour', 'h');

    // PRIORITY
    addUnitPriority('hour', 13);

    // PARSING

    function matchMeridiem (isStrict, locale) {
        return locale._meridiemParse;
    }

    addRegexToken('a',  matchMeridiem);
    addRegexToken('A',  matchMeridiem);
    addRegexToken('H',  match1to2);
    addRegexToken('h',  match1to2);
    addRegexToken('HH', match1to2, match2);
    addRegexToken('hh', match1to2, match2);

    addRegexToken('hmm', match3to4);
    addRegexToken('hmmss', match5to6);
    addRegexToken('Hmm', match3to4);
    addRegexToken('Hmmss', match5to6);

    addParseToken(['H', 'HH'], HOUR);
    addParseToken(['a', 'A'], function (input, array, config) {
        config._isPm = config._locale.isPM(input);
        config._meridiem = input;
    });
    addParseToken(['h', 'hh'], function (input, array, config) {
        array[HOUR] = toInt(input);
        getParsingFlags(config).bigHour = true;
    });
    addParseToken('hmm', function (input, array, config) {
        var pos = input.length - 2;
        array[HOUR] = toInt(input.substr(0, pos));
        array[MINUTE] = toInt(input.substr(pos));
        getParsingFlags(config).bigHour = true;
    });
    addParseToken('hmmss', function (input, array, config) {
        var pos1 = input.length - 4;
        var pos2 = input.length - 2;
        array[HOUR] = toInt(input.substr(0, pos1));
        array[MINUTE] = toInt(input.substr(pos1, 2));
        array[SECOND] = toInt(input.substr(pos2));
        getParsingFlags(config).bigHour = true;
    });
    addParseToken('Hmm', function (input, array, config) {
        var pos = input.length - 2;
        array[HOUR] = toInt(input.substr(0, pos));
        array[MINUTE] = toInt(input.substr(pos));
    });
    addParseToken('Hmmss', function (input, array, config) {
        var pos1 = input.length - 4;
        var pos2 = input.length - 2;
        array[HOUR] = toInt(input.substr(0, pos1));
        array[MINUTE] = toInt(input.substr(pos1, 2));
        array[SECOND] = toInt(input.substr(pos2));
    });

    // LOCALES

    function localeIsPM (input) {
        // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
        // Using charAt should be more compatible.
        return ((input + '').toLowerCase().charAt(0) === 'p');
    }

    var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
    function localeMeridiem (hours, minutes, isLower) {
        if (hours > 11) {
            return isLower ? 'pm' : 'PM';
        } else {
            return isLower ? 'am' : 'AM';
        }
    }

    // MOMENTS

    // Setting the hour should keep the time, because the user explicitly
    // specified which hour he wants. So trying to maintain the same hour (in
    // a new timezone) makes sense. Adding/subtracting hours does not follow
    // this rule.
    var getSetHour = makeGetSet('Hours', true);

    // months
    // week
    // weekdays
    // meridiem
    var baseConfig = {
        calendar: defaultCalendar,
        longDateFormat: defaultLongDateFormat,
        invalidDate: defaultInvalidDate,
        ordinal: defaultOrdinal,
        ordinalParse: defaultOrdinalParse,
        relativeTime: defaultRelativeTime,

        months: defaultLocaleMonths,
        monthsShort: defaultLocaleMonthsShort,

        week: defaultLocaleWeek,

        weekdays: defaultLocaleWeekdays,
        weekdaysMin: defaultLocaleWeekdaysMin,
        weekdaysShort: defaultLocaleWeekdaysShort,

        meridiemParse: defaultLocaleMeridiemParse
    };

    // internal storage for locale config files
    var locales = {};
    var localeFamilies = {};
    var globalLocale;

    function normalizeLocale(key) {
        return key ? key.toLowerCase().replace('_', '-') : key;
    }

    // pick the locale from the array
    // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
    // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
    function chooseLocale(names) {
        var i = 0, j, next, locale, split;

        while (i < names.length) {
            split = normalizeLocale(names[i]).split('-');
            j = split.length;
            next = normalizeLocale(names[i + 1]);
            next = next ? next.split('-') : null;
            while (j > 0) {
                locale = loadLocale(split.slice(0, j).join('-'));
                if (locale) {
                    return locale;
                }
                if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
                    //the next array item is better than a shallower substring of this one
                    break;
                }
                j--;
            }
            i++;
        }
        return null;
    }

    function loadLocale(name) {
        var oldLocale = null;
        // TODO: Find a better way to register and load all the locales in Node
        if (!locales[name] && (typeof module !== 'undefined') &&
                module && module.exports) {
            try {
                oldLocale = globalLocale._abbr;
                require('./locale/' + name);
                // because defineLocale currently also sets the global locale, we
                // want to undo that for lazy loaded locales
                getSetGlobalLocale(oldLocale);
            } catch (e) { }
        }
        return locales[name];
    }

    // This function will load locale and then set the global locale.  If
    // no arguments are passed in, it will simply return the current global
    // locale key.
    function getSetGlobalLocale (key, values) {
        var data;
        if (key) {
            if (isUndefined(values)) {
                data = getLocale(key);
            }
            else {
                data = defineLocale(key, values);
            }

            if (data) {
                // moment.duration._locale = moment._locale = data;
                globalLocale = data;
            }
        }

        return globalLocale._abbr;
    }

    function defineLocale (name, config) {
        if (config !== null) {
            var parentConfig = baseConfig;
            config.abbr = name;
            if (locales[name] != null) {
                deprecateSimple('defineLocaleOverride',
                        'use moment.updateLocale(localeName, config) to change ' +
                        'an existing locale. moment.defineLocale(localeName, ' +
                        'config) should only be used for creating a new locale ' +
                        'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');
                parentConfig = locales[name]._config;
            } else if (config.parentLocale != null) {
                if (locales[config.parentLocale] != null) {
                    parentConfig = locales[config.parentLocale]._config;
                } else {
                    if (!localeFamilies[config.parentLocale]) {
                        localeFamilies[config.parentLocale] = [];
                    }
                    localeFamilies[config.parentLocale].push({
                        name: name,
                        config: config
                    });
                    return null;
                }
            }
            locales[name] = new Locale(mergeConfigs(parentConfig, config));

            if (localeFamilies[name]) {
                localeFamilies[name].forEach(function (x) {
                    defineLocale(x.name, x.config);
                });
            }

            // backwards compat for now: also set the locale
            // make sure we set the locale AFTER all child locales have been
            // created, so we won't end up with the child locale set.
            getSetGlobalLocale(name);

            return locales[name];
        } else {
            // useful for testing
            delete locales[name];
            return null;
        }
    }

    function updateLocale(name, config) {
        if (config != null) {
            var locale, parentConfig = baseConfig;
            // MERGE
            if (locales[name] != null) {
                parentConfig = locales[name]._config;
            }
            config = mergeConfigs(parentConfig, config);
            locale = new Locale(config);
            locale.parentLocale = locales[name];
            locales[name] = locale;

            // backwards compat for now: also set the locale
            getSetGlobalLocale(name);
        } else {
            // pass null for config to unupdate, useful for tests
            if (locales[name] != null) {
                if (locales[name].parentLocale != null) {
                    locales[name] = locales[name].parentLocale;
                } else if (locales[name] != null) {
                    delete locales[name];
                }
            }
        }
        return locales[name];
    }

    // returns locale data
    function getLocale (key) {
        var locale;

        if (key && key._locale && key._locale._abbr) {
            key = key._locale._abbr;
        }

        if (!key) {
            return globalLocale;
        }

        if (!isArray(key)) {
            //short-circuit everything else
            locale = loadLocale(key);
            if (locale) {
                return locale;
            }
            key = [key];
        }

        return chooseLocale(key);
    }

    function listLocales() {
        return keys$1(locales);
    }

    function checkOverflow (m) {
        var overflow;
        var a = m._a;

        if (a && getParsingFlags(m).overflow === -2) {
            overflow =
                a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :
                a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
                a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
                a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :
                a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :
                a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
                -1;

            if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
                overflow = DATE;
            }
            if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
                overflow = WEEK;
            }
            if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
                overflow = WEEKDAY;
            }

            getParsingFlags(m).overflow = overflow;
        }

        return m;
    }

    // iso 8601 regex
    // 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)
    var extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
    var basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;

    var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/;

    var isoDates = [
        ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
        ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
        ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
        ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
        ['YYYY-DDD', /\d{4}-\d{3}/],
        ['YYYY-MM', /\d{4}-\d\d/, false],
        ['YYYYYYMMDD', /[+-]\d{10}/],
        ['YYYYMMDD', /\d{8}/],
        // YYYYMM is NOT allowed by the standard
        ['GGGG[W]WWE', /\d{4}W\d{3}/],
        ['GGGG[W]WW', /\d{4}W\d{2}/, false],
        ['YYYYDDD', /\d{7}/]
    ];

    // iso time formats and regexes
    var isoTimes = [
        ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
        ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
        ['HH:mm:ss', /\d\d:\d\d:\d\d/],
        ['HH:mm', /\d\d:\d\d/],
        ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
        ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
        ['HHmmss', /\d\d\d\d\d\d/],
        ['HHmm', /\d\d\d\d/],
        ['HH', /\d\d/]
    ];

    var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;

    // date from iso format
    function configFromISO(config) {
        var i, l,
            string = config._i,
            match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
            allowTime, dateFormat, timeFormat, tzFormat;

        if (match) {
            getParsingFlags(config).iso = true;

            for (i = 0, l = isoDates.length; i < l; i++) {
                if (isoDates[i][1].exec(match[1])) {
                    dateFormat = isoDates[i][0];
                    allowTime = isoDates[i][2] !== false;
                    break;
                }
            }
            if (dateFormat == null) {
                config._isValid = false;
                return;
            }
            if (match[3]) {
                for (i = 0, l = isoTimes.length; i < l; i++) {
                    if (isoTimes[i][1].exec(match[3])) {
                        // match[2] should be 'T' or space
                        timeFormat = (match[2] || ' ') + isoTimes[i][0];
                        break;
                    }
                }
                if (timeFormat == null) {
                    config._isValid = false;
                    return;
                }
            }
            if (!allowTime && timeFormat != null) {
                config._isValid = false;
                return;
            }
            if (match[4]) {
                if (tzRegex.exec(match[4])) {
                    tzFormat = 'Z';
                } else {
                    config._isValid = false;
                    return;
                }
            }
            config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
            configFromStringAndFormat(config);
        } else {
            config._isValid = false;
        }
    }

    // date from iso format or fallback
    function configFromString(config) {
        var matched = aspNetJsonRegex.exec(config._i);

        if (matched !== null) {
            config._d = new Date(+matched[1]);
            return;
        }

        configFromISO(config);
        if (config._isValid === false) {
            delete config._isValid;
            hooks.createFromInputFallback(config);
        }
    }

    hooks.createFromInputFallback = deprecate(
        'value provided is not in a recognized ISO format. moment construction falls back to js Date(), ' +
        'which is not reliable across all browsers and versions. Non ISO date formats are ' +
        'discouraged and will be removed in an upcoming major release. Please refer to ' +
        'http://momentjs.com/guides/#/warnings/js-date/ for more info.',
        function (config) {
            config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
        }
    );

    // Pick the first defined of two or three arguments.
    function defaults(a, b, c) {
        if (a != null) {
            return a;
        }
        if (b != null) {
            return b;
        }
        return c;
    }

    function currentDateArray(config) {
        // hooks is actually the exported moment object
        var nowValue = new Date(hooks.now());
        if (config._useUTC) {
            return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
        }
        return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
    }

    // convert an array to a date.
    // the array should mirror the parameters below
    // note: all values past the year are optional and will default to the lowest possible value.
    // [year, month, day , hour, minute, second, millisecond]
    function configFromArray (config) {
        var i, date, input = [], currentDate, yearToUse;

        if (config._d) {
            return;
        }

        currentDate = currentDateArray(config);

        //compute day of the year from weeks and weekdays
        if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
            dayOfYearFromWeekInfo(config);
        }

        //if the day of the year is set, figure out what it is
        if (config._dayOfYear) {
            yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);

            if (config._dayOfYear > daysInYear(yearToUse)) {
                getParsingFlags(config)._overflowDayOfYear = true;
            }

            date = createUTCDate(yearToUse, 0, config._dayOfYear);
            config._a[MONTH] = date.getUTCMonth();
            config._a[DATE] = date.getUTCDate();
        }

        // Default to current date.
        // * if no year, month, day of month are given, default to today
        // * if day of month is given, default month and year
        // * if month is given, default only year
        // * if year is given, don't default anything
        for (i = 0; i < 3 && config._a[i] == null; ++i) {
            config._a[i] = input[i] = currentDate[i];
        }

        // Zero out whatever was not defaulted, including time
        for (; i < 7; i++) {
            config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
        }

        // Check for 24:00:00.000
        if (config._a[HOUR] === 24 &&
                config._a[MINUTE] === 0 &&
                config._a[SECOND] === 0 &&
                config._a[MILLISECOND] === 0) {
            config._nextDay = true;
            config._a[HOUR] = 0;
        }

        config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
        // Apply timezone offset from input. The actual utcOffset can be changed
        // with parseZone.
        if (config._tzm != null) {
            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
        }

        if (config._nextDay) {
            config._a[HOUR] = 24;
        }
    }

    function dayOfYearFromWeekInfo(config) {
        var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;

        w = config._w;
        if (w.GG != null || w.W != null || w.E != null) {
            dow = 1;
            doy = 4;

            // TODO: We need to take the current isoWeekYear, but that depends on
            // how we interpret now (local, utc, fixed offset). So create
            // a now version of current config (take local/utc/offset flags, and
            // create now).
            weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);
            week = defaults(w.W, 1);
            weekday = defaults(w.E, 1);
            if (weekday < 1 || weekday > 7) {
                weekdayOverflow = true;
            }
        } else {
            dow = config._locale._week.dow;
            doy = config._locale._week.doy;

            var curWeek = weekOfYear(createLocal(), dow, doy);

            weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);

            // Default to current week.
            week = defaults(w.w, curWeek.week);

            if (w.d != null) {
                // weekday -- low day numbers are considered next week
                weekday = w.d;
                if (weekday < 0 || weekday > 6) {
                    weekdayOverflow = true;
                }
            } else if (w.e != null) {
                // local weekday -- counting starts from begining of week
                weekday = w.e + dow;
                if (w.e < 0 || w.e > 6) {
                    weekdayOverflow = true;
                }
            } else {
                // default to begining of week
                weekday = dow;
            }
        }
        if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
            getParsingFlags(config)._overflowWeeks = true;
        } else if (weekdayOverflow != null) {
            getParsingFlags(config)._overflowWeekday = true;
        } else {
            temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
            config._a[YEAR] = temp.year;
            config._dayOfYear = temp.dayOfYear;
        }
    }

    // constant that refers to the ISO standard
    hooks.ISO_8601 = function () {};

    // date from string and format string
    function configFromStringAndFormat(config) {
        // TODO: Move this to another part of the creation flow to prevent circular deps
        if (config._f === hooks.ISO_8601) {
            configFromISO(config);
            return;
        }

        config._a = [];
        getParsingFlags(config).empty = true;

        // This array is used to make a Date, either with `new Date` or `Date.UTC`
        var string = '' + config._i,
            i, parsedInput, tokens, token, skipped,
            stringLength = string.length,
            totalParsedInputLength = 0;

        tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];

        for (i = 0; i < tokens.length; i++) {
            token = tokens[i];
            parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
            // console.log('token', token, 'parsedInput', parsedInput,
            //         'regex', getParseRegexForToken(token, config));
            if (parsedInput) {
                skipped = string.substr(0, string.indexOf(parsedInput));
                if (skipped.length > 0) {
                    getParsingFlags(config).unusedInput.push(skipped);
                }
                string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
                totalParsedInputLength += parsedInput.length;
            }
            // don't parse if it's not a known token
            if (formatTokenFunctions[token]) {
                if (parsedInput) {
                    getParsingFlags(config).empty = false;
                }
                else {
                    getParsingFlags(config).unusedTokens.push(token);
                }
                addTimeToArrayFromToken(token, parsedInput, config);
            }
            else if (config._strict && !parsedInput) {
                getParsingFlags(config).unusedTokens.push(token);
            }
        }

        // add remaining unparsed input length to the string
        getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
        if (string.length > 0) {
            getParsingFlags(config).unusedInput.push(string);
        }

        // clear _12h flag if hour is <= 12
        if (config._a[HOUR] <= 12 &&
            getParsingFlags(config).bigHour === true &&
            config._a[HOUR] > 0) {
            getParsingFlags(config).bigHour = undefined;
        }

        getParsingFlags(config).parsedDateParts = config._a.slice(0);
        getParsingFlags(config).meridiem = config._meridiem;
        // handle meridiem
        config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);

        configFromArray(config);
        checkOverflow(config);
    }

    function meridiemFixWrap (locale, hour, meridiem) {
        var isPm;

        if (meridiem == null) {
            // nothing to do
            return hour;
        }
        if (locale.meridiemHour != null) {
            return locale.meridiemHour(hour, meridiem);
        } else if (locale.isPM != null) {
            // Fallback
            isPm = locale.isPM(meridiem);
            if (isPm && hour < 12) {
                hour += 12;
            }
            if (!isPm && hour === 12) {
                hour = 0;
            }
            return hour;
        } else {
            // this is not supposed to happen
            return hour;
        }
    }

    // date from string and array of format strings
    function configFromStringAndArray(config) {
        var tempConfig,
            bestMoment,

            scoreToBeat,
            i,
            currentScore;

        if (config._f.length === 0) {
            getParsingFlags(config).invalidFormat = true;
            config._d = new Date(NaN);
            return;
        }

        for (i = 0; i < config._f.length; i++) {
            currentScore = 0;
            tempConfig = copyConfig({}, config);
            if (config._useUTC != null) {
                tempConfig._useUTC = config._useUTC;
            }
            tempConfig._f = config._f[i];
            configFromStringAndFormat(tempConfig);

            if (!isValid(tempConfig)) {
                continue;
            }

            // if there is any input that was not parsed add a penalty for that format
            currentScore += getParsingFlags(tempConfig).charsLeftOver;

            //or tokens
            currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;

            getParsingFlags(tempConfig).score = currentScore;

            if (scoreToBeat == null || currentScore < scoreToBeat) {
                scoreToBeat = currentScore;
                bestMoment = tempConfig;
            }
        }

        extend(config, bestMoment || tempConfig);
    }

    function configFromObject(config) {
        if (config._d) {
            return;
        }

        var i = normalizeObjectUnits(config._i);
        config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {
            return obj && parseInt(obj, 10);
        });

        configFromArray(config);
    }

    function createFromConfig (config) {
        var res = new Moment(checkOverflow(prepareConfig(config)));
        if (res._nextDay) {
            // Adding is smart enough around DST
            res.add(1, 'd');
            res._nextDay = undefined;
        }

        return res;
    }

    function prepareConfig (config) {
        var input = config._i,
            format = config._f;

        config._locale = config._locale || getLocale(config._l);

        if (input === null || (format === undefined && input === '')) {
            return createInvalid({nullInput: true});
        }

        if (typeof input === 'string') {
            config._i = input = config._locale.preparse(input);
        }

        if (isMoment(input)) {
            return new Moment(checkOverflow(input));
        } else if (isDate(input)) {
            config._d = input;
        } else if (isArray(format)) {
            configFromStringAndArray(config);
        } else if (format) {
            configFromStringAndFormat(config);
        }  else {
            configFromInput(config);
        }

        if (!isValid(config)) {
            config._d = null;
        }

        return config;
    }

    function configFromInput(config) {
        var input = config._i;
        if (input === undefined) {
            config._d = new Date(hooks.now());
        } else if (isDate(input)) {
            config._d = new Date(input.valueOf());
        } else if (typeof input === 'string') {
            configFromString(config);
        } else if (isArray(input)) {
            config._a = map(input.slice(0), function (obj) {
                return parseInt(obj, 10);
            });
            configFromArray(config);
        } else if (typeof(input) === 'object') {
            configFromObject(config);
        } else if (isNumber(input)) {
            // from milliseconds
            config._d = new Date(input);
        } else {
            hooks.createFromInputFallback(config);
        }
    }

    function createLocalOrUTC (input, format, locale, strict, isUTC) {
        var c = {};

        if (locale === true || locale === false) {
            strict = locale;
            locale = undefined;
        }

        if ((isObject(input) && isObjectEmpty(input)) ||
                (isArray(input) && input.length === 0)) {
            input = undefined;
        }
        // object construction must be done this way.
        // https://github.com/moment/moment/issues/1423
        c._isAMomentObject = true;
        c._useUTC = c._isUTC = isUTC;
        c._l = locale;
        c._i = input;
        c._f = format;
        c._strict = strict;

        return createFromConfig(c);
    }

    function createLocal (input, format, locale, strict) {
        return createLocalOrUTC(input, format, locale, strict, false);
    }

    var prototypeMin = deprecate(
        'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
        function () {
            var other = createLocal.apply(null, arguments);
            if (this.isValid() && other.isValid()) {
                return other < this ? this : other;
            } else {
                return createInvalid();
            }
        }
    );

    var prototypeMax = deprecate(
        'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
        function () {
            var other = createLocal.apply(null, arguments);
            if (this.isValid() && other.isValid()) {
                return other > this ? this : other;
            } else {
                return createInvalid();
            }
        }
    );

    // Pick a moment m from moments so that m[fn](other) is true for all
    // other. This relies on the function fn to be transitive.
    //
    // moments should either be an array of moment objects or an array, whose
    // first element is an array of moment objects.
    function pickBy(fn, moments) {
        var res, i;
        if (moments.length === 1 && isArray(moments[0])) {
            moments = moments[0];
        }
        if (!moments.length) {
            return createLocal();
        }
        res = moments[0];
        for (i = 1; i < moments.length; ++i) {
            if (!moments[i].isValid() || moments[i][fn](res)) {
                res = moments[i];
            }
        }
        return res;
    }

    // TODO: Use [].sort instead?
    function min () {
        var args = [].slice.call(arguments, 0);

        return pickBy('isBefore', args);
    }

    function max () {
        var args = [].slice.call(arguments, 0);

        return pickBy('isAfter', args);
    }

    var now = function () {
        return Date.now ? Date.now() : +(new Date());
    };

    function Duration (duration) {
        var normalizedInput = normalizeObjectUnits(duration),
            years = normalizedInput.year || 0,
            quarters = normalizedInput.quarter || 0,
            months = normalizedInput.month || 0,
            weeks = normalizedInput.week || 0,
            days = normalizedInput.day || 0,
            hours = normalizedInput.hour || 0,
            minutes = normalizedInput.minute || 0,
            seconds = normalizedInput.second || 0,
            milliseconds = normalizedInput.millisecond || 0;

        // representation for dateAddRemove
        this._milliseconds = +milliseconds +
            seconds * 1e3 + // 1000
            minutes * 6e4 + // 1000 * 60
            hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
        // Because of dateAddRemove treats 24 hours as different from a
        // day when working around DST, we need to store them separately
        this._days = +days +
            weeks * 7;
        // It is impossible translate months into days without knowing
        // which months you are are talking about, so we have to store
        // it separately.
        this._months = +months +
            quarters * 3 +
            years * 12;

        this._data = {};

        this._locale = getLocale();

        this._bubble();
    }

    function isDuration (obj) {
        return obj instanceof Duration;
    }

    function absRound (number) {
        if (number < 0) {
            return Math.round(-1 * number) * -1;
        } else {
            return Math.round(number);
        }
    }

    // FORMATTING

    function offset (token, separator) {
        addFormatToken(token, 0, 0, function () {
            var offset = this.utcOffset();
            var sign = '+';
            if (offset < 0) {
                offset = -offset;
                sign = '-';
            }
            return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
        });
    }

    offset('Z', ':');
    offset('ZZ', '');

    // PARSING

    addRegexToken('Z',  matchShortOffset);
    addRegexToken('ZZ', matchShortOffset);
    addParseToken(['Z', 'ZZ'], function (input, array, config) {
        config._useUTC = true;
        config._tzm = offsetFromString(matchShortOffset, input);
    });

    // HELPERS

    // timezone chunker
    // '+10:00' > ['10',  '00']
    // '-1530'  > ['-15', '30']
    var chunkOffset = /([\+\-]|\d\d)/gi;

    function offsetFromString(matcher, string) {
        var matches = (string || '').match(matcher);

        if (matches === null) {
            return null;
        }

        var chunk   = matches[matches.length - 1] || [];
        var parts   = (chunk + '').match(chunkOffset) || ['-', 0, 0];
        var minutes = +(parts[1] * 60) + toInt(parts[2]);

        return minutes === 0 ?
          0 :
          parts[0] === '+' ? minutes : -minutes;
    }

    // Return a moment from input, that is local/utc/zone equivalent to model.
    function cloneWithOffset(input, model) {
        var res, diff;
        if (model._isUTC) {
            res = model.clone();
            diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();
            // Use low-level api, because this fn is low-level api.
            res._d.setTime(res._d.valueOf() + diff);
            hooks.updateOffset(res, false);
            return res;
        } else {
            return createLocal(input).local();
        }
    }

    function getDateOffset (m) {
        // On Firefox.24 Date#getTimezoneOffset returns a floating point.
        // https://github.com/moment/moment/pull/1871
        return -Math.round(m._d.getTimezoneOffset() / 15) * 15;
    }

    // HOOKS

    // This function will be called whenever a moment is mutated.
    // It is intended to keep the offset in sync with the timezone.
    hooks.updateOffset = function () {};

    // MOMENTS

    // keepLocalTime = true means only change the timezone, without
    // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
    // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
    // +0200, so we adjust the time as needed, to be valid.
    //
    // Keeping the time actually adds/subtracts (one hour)
    // from the actual represented time. That is why we call updateOffset
    // a second time. In case it wants us to change the offset again
    // _changeInProgress == true case, then we have to adjust, because
    // there is no such time in the given timezone.
    function getSetOffset (input, keepLocalTime) {
        var offset = this._offset || 0,
            localAdjust;
        if (!this.isValid()) {
            return input != null ? this : NaN;
        }
        if (input != null) {
            if (typeof input === 'string') {
                input = offsetFromString(matchShortOffset, input);
                if (input === null) {
                    return this;
                }
            } else if (Math.abs(input) < 16) {
                input = input * 60;
            }
            if (!this._isUTC && keepLocalTime) {
                localAdjust = getDateOffset(this);
            }
            this._offset = input;
            this._isUTC = true;
            if (localAdjust != null) {
                this.add(localAdjust, 'm');
            }
            if (offset !== input) {
                if (!keepLocalTime || this._changeInProgress) {
                    addSubtract(this, createDuration(input - offset, 'm'), 1, false);
                } else if (!this._changeInProgress) {
                    this._changeInProgress = true;
                    hooks.updateOffset(this, true);
                    this._changeInProgress = null;
                }
            }
            return this;
        } else {
            return this._isUTC ? offset : getDateOffset(this);
        }
    }

    function getSetZone (input, keepLocalTime) {
        if (input != null) {
            if (typeof input !== 'string') {
                input = -input;
            }

            this.utcOffset(input, keepLocalTime);

            return this;
        } else {
            return -this.utcOffset();
        }
    }

    function setOffsetToUTC (keepLocalTime) {
        return this.utcOffset(0, keepLocalTime);
    }

    function setOffsetToLocal (keepLocalTime) {
        if (this._isUTC) {
            this.utcOffset(0, keepLocalTime);
            this._isUTC = false;

            if (keepLocalTime) {
                this.subtract(getDateOffset(this), 'm');
            }
        }
        return this;
    }

    function setOffsetToParsedOffset () {
        if (this._tzm != null) {
            this.utcOffset(this._tzm);
        } else if (typeof this._i === 'string') {
            var tZone = offsetFromString(matchOffset, this._i);
            if (tZone != null) {
                this.utcOffset(tZone);
            }
            else {
                this.utcOffset(0, true);
            }
        }
        return this;
    }

    function hasAlignedHourOffset (input) {
        if (!this.isValid()) {
            return false;
        }
        input = input ? createLocal(input).utcOffset() : 0;

        return (this.utcOffset() - input) % 60 === 0;
    }

    function isDaylightSavingTime () {
        return (
            this.utcOffset() > this.clone().month(0).utcOffset() ||
            this.utcOffset() > this.clone().month(5).utcOffset()
        );
    }

    function isDaylightSavingTimeShifted () {
        if (!isUndefined(this._isDSTShifted)) {
            return this._isDSTShifted;
        }

        var c = {};

        copyConfig(c, this);
        c = prepareConfig(c);

        if (c._a) {
            var other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
            this._isDSTShifted = this.isValid() &&
                compareArrays(c._a, other.toArray()) > 0;
        } else {
            this._isDSTShifted = false;
        }

        return this._isDSTShifted;
    }

    function isLocal () {
        return this.isValid() ? !this._isUTC : false;
    }

    function isUtcOffset () {
        return this.isValid() ? this._isUTC : false;
    }

    function isUtc () {
        return this.isValid() ? this._isUTC && this._offset === 0 : false;
    }

    // ASP.NET json date format regex
    var aspNetRegex = /^(\-)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/;

    // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
    // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
    // and further modified to allow for strings containing both week and day
    var isoRegex = /^(-)?P(?:(-?[0-9,.]*)Y)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)W)?(?:(-?[0-9,.]*)D)?(?:T(?:(-?[0-9,.]*)H)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)S)?)?$/;

    function createDuration (input, key) {
        var duration = input,
            // matching against regexp is expensive, do it on demand
            match = null,
            sign,
            ret,
            diffRes;

        if (isDuration(input)) {
            duration = {
                ms : input._milliseconds,
                d  : input._days,
                M  : input._months
            };
        } else if (isNumber(input)) {
            duration = {};
            if (key) {
                duration[key] = input;
            } else {
                duration.milliseconds = input;
            }
        } else if (!!(match = aspNetRegex.exec(input))) {
            sign = (match[1] === '-') ? -1 : 1;
            duration = {
                y  : 0,
                d  : toInt(match[DATE])                         * sign,
                h  : toInt(match[HOUR])                         * sign,
                m  : toInt(match[MINUTE])                       * sign,
                s  : toInt(match[SECOND])                       * sign,
                ms : toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match
            };
        } else if (!!(match = isoRegex.exec(input))) {
            sign = (match[1] === '-') ? -1 : 1;
            duration = {
                y : parseIso(match[2], sign),
                M : parseIso(match[3], sign),
                w : parseIso(match[4], sign),
                d : parseIso(match[5], sign),
                h : parseIso(match[6], sign),
                m : parseIso(match[7], sign),
                s : parseIso(match[8], sign)
            };
        } else if (duration == null) {// checks for null or undefined
            duration = {};
        } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
            diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to));

            duration = {};
            duration.ms = diffRes.milliseconds;
            duration.M = diffRes.months;
        }

        ret = new Duration(duration);

        if (isDuration(input) && hasOwnProp(input, '_locale')) {
            ret._locale = input._locale;
        }

        return ret;
    }

    createDuration.fn = Duration.prototype;

    function parseIso (inp, sign) {
        // We'd normally use ~~inp for this, but unfortunately it also
        // converts floats to ints.
        // inp may be undefined, so careful calling replace on it.
        var res = inp && parseFloat(inp.replace(',', '.'));
        // apply sign while we're at it
        return (isNaN(res) ? 0 : res) * sign;
    }

    function positiveMomentsDifference(base, other) {
        var res = {milliseconds: 0, months: 0};

        res.months = other.month() - base.month() +
            (other.year() - base.year()) * 12;
        if (base.clone().add(res.months, 'M').isAfter(other)) {
            --res.months;
        }

        res.milliseconds = +other - +(base.clone().add(res.months, 'M'));

        return res;
    }

    function momentsDifference(base, other) {
        var res;
        if (!(base.isValid() && other.isValid())) {
            return {milliseconds: 0, months: 0};
        }

        other = cloneWithOffset(other, base);
        if (base.isBefore(other)) {
            res = positiveMomentsDifference(base, other);
        } else {
            res = positiveMomentsDifference(other, base);
            res.milliseconds = -res.milliseconds;
            res.months = -res.months;
        }

        return res;
    }

    // TODO: remove 'name' arg after deprecation is removed
    function createAdder(direction, name) {
        return function (val, period) {
            var dur, tmp;
            //invert the arguments, but complain about it
            if (period !== null && !isNaN(+period)) {
                deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' +
                'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');
                tmp = val; val = period; period = tmp;
            }

            val = typeof val === 'string' ? +val : val;
            dur = createDuration(val, period);
            addSubtract(this, dur, direction);
            return this;
        };
    }

    function addSubtract (mom, duration, isAdding, updateOffset) {
        var milliseconds = duration._milliseconds,
            days = absRound(duration._days),
            months = absRound(duration._months);

        if (!mom.isValid()) {
            // No op
            return;
        }

        updateOffset = updateOffset == null ? true : updateOffset;

        if (milliseconds) {
            mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
        }
        if (days) {
            set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);
        }
        if (months) {
            setMonth(mom, get(mom, 'Month') + months * isAdding);
        }
        if (updateOffset) {
            hooks.updateOffset(mom, days || months);
        }
    }

    var add      = createAdder(1, 'add');
    var subtract = createAdder(-1, 'subtract');

    function getCalendarFormat(myMoment, now) {
        var diff = myMoment.diff(now, 'days', true);
        return diff < -6 ? 'sameElse' :
                diff < -1 ? 'lastWeek' :
                diff < 0 ? 'lastDay' :
                diff < 1 ? 'sameDay' :
                diff < 2 ? 'nextDay' :
                diff < 7 ? 'nextWeek' : 'sameElse';
    }

    function calendar$1 (time, formats) {
        // We want to compare the start of today, vs this.
        // Getting start-of-today depends on whether we're local/utc/offset or not.
        var now = time || createLocal(),
            sod = cloneWithOffset(now, this).startOf('day'),
            format = hooks.calendarFormat(this, sod) || 'sameElse';

        var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]);

        return this.format(output || this.localeData().calendar(format, this, createLocal(now)));
    }

    function clone () {
        return new Moment(this);
    }

    function isAfter (input, units) {
        var localInput = isMoment(input) ? input : createLocal(input);
        if (!(this.isValid() && localInput.isValid())) {
            return false;
        }
        units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
        if (units === 'millisecond') {
            return this.valueOf() > localInput.valueOf();
        } else {
            return localInput.valueOf() < this.clone().startOf(units).valueOf();
        }
    }

    function isBefore (input, units) {
        var localInput = isMoment(input) ? input : createLocal(input);
        if (!(this.isValid() && localInput.isValid())) {
            return false;
        }
        units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
        if (units === 'millisecond') {
            return this.valueOf() < localInput.valueOf();
        } else {
            return this.clone().endOf(units).valueOf() < localInput.valueOf();
        }
    }

    function isBetween (from, to, units, inclusivity) {
        inclusivity = inclusivity || '()';
        return (inclusivity[0] === '(' ? this.isAfter(from, units) : !this.isBefore(from, units)) &&
            (inclusivity[1] === ')' ? this.isBefore(to, units) : !this.isAfter(to, units));
    }

    function isSame (input, units) {
        var localInput = isMoment(input) ? input : createLocal(input),
            inputMs;
        if (!(this.isValid() && localInput.isValid())) {
            return false;
        }
        units = normalizeUnits(units || 'millisecond');
        if (units === 'millisecond') {
            return this.valueOf() === localInput.valueOf();
        } else {
            inputMs = localInput.valueOf();
            return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();
        }
    }

    function isSameOrAfter (input, units) {
        return this.isSame(input, units) || this.isAfter(input,units);
    }

    function isSameOrBefore (input, units) {
        return this.isSame(input, units) || this.isBefore(input,units);
    }

    function diff (input, units, asFloat) {
        var that,
            zoneDelta,
            delta, output;

        if (!this.isValid()) {
            return NaN;
        }

        that = cloneWithOffset(input, this);

        if (!that.isValid()) {
            return NaN;
        }

        zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;

        units = normalizeUnits(units);

        if (units === 'year' || units === 'month' || units === 'quarter') {
            output = monthDiff(this, that);
            if (units === 'quarter') {
                output = output / 3;
            } else if (units === 'year') {
                output = output / 12;
            }
        } else {
            delta = this - that;
            output = units === 'second' ? delta / 1e3 : // 1000
                units === 'minute' ? delta / 6e4 : // 1000 * 60
                units === 'hour' ? delta / 36e5 : // 1000 * 60 * 60
                units === 'day' ? (delta - zoneDelta) / 864e5 : // 1000 * 60 * 60 * 24, negate dst
                units === 'week' ? (delta - zoneDelta) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst
                delta;
        }
        return asFloat ? output : absFloor(output);
    }

    function monthDiff (a, b) {
        // difference in months
        var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
            // b is in (anchor - 1 month, anchor + 1 month)
            anchor = a.clone().add(wholeMonthDiff, 'months'),
            anchor2, adjust;

        if (b - anchor < 0) {
            anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
            // linear across the month
            adjust = (b - anchor) / (anchor - anchor2);
        } else {
            anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
            // linear across the month
            adjust = (b - anchor) / (anchor2 - anchor);
        }

        //check for negative zero, return zero if negative zero
        return -(wholeMonthDiff + adjust) || 0;
    }

    hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
    hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';

    function toString () {
        return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
    }

    function toISOString () {
        var m = this.clone().utc();
        if (0 < m.year() && m.year() <= 9999) {
            if (isFunction(Date.prototype.toISOString)) {
                // native implementation is ~50x faster, use it when we can
                return this.toDate().toISOString();
            } else {
                return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
            }
        } else {
            return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
        }
    }

    /**
     * Return a human readable representation of a moment that can
     * also be evaluated to get a new moment which is the same
     *
     * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects
     */
    function inspect () {
        if (!this.isValid()) {
            return 'moment.invalid(/* ' + this._i + ' */)';
        }
        var func = 'moment';
        var zone = '';
        if (!this.isLocal()) {
            func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';
            zone = 'Z';
        }
        var prefix = '[' + func + '("]';
        var year = (0 < this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY';
        var datetime = '-MM-DD[T]HH:mm:ss.SSS';
        var suffix = zone + '[")]';

        return this.format(prefix + year + datetime + suffix);
    }

    function format (inputString) {
        if (!inputString) {
            inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;
        }
        var output = formatMoment(this, inputString);
        return this.localeData().postformat(output);
    }

    function from (time, withoutSuffix) {
        if (this.isValid() &&
                ((isMoment(time) && time.isValid()) ||
                 createLocal(time).isValid())) {
            return createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
        } else {
            return this.localeData().invalidDate();
        }
    }

    function fromNow (withoutSuffix) {
        return this.from(createLocal(), withoutSuffix);
    }

    function to (time, withoutSuffix) {
        if (this.isValid() &&
                ((isMoment(time) && time.isValid()) ||
                 createLocal(time).isValid())) {
            return createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);
        } else {
            return this.localeData().invalidDate();
        }
    }

    function toNow (withoutSuffix) {
        return this.to(createLocal(), withoutSuffix);
    }

    // If passed a locale key, it will set the locale for this
    // instance.  Otherwise, it will return the locale configuration
    // variables for this instance.
    function locale (key) {
        var newLocaleData;

        if (key === undefined) {
            return this._locale._abbr;
        } else {
            newLocaleData = getLocale(key);
            if (newLocaleData != null) {
                this._locale = newLocaleData;
            }
            return this;
        }
    }

    var lang = deprecate(
        'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
        function (key) {
            if (key === undefined) {
                return this.localeData();
            } else {
                return this.locale(key);
            }
        }
    );

    function localeData () {
        return this._locale;
    }

    function startOf (units) {
        units = normalizeUnits(units);
        // the following switch intentionally omits break keywords
        // to utilize falling through the cases.
        switch (units) {
            case 'year':
                this.month(0);
                /* falls through */
            case 'quarter':
            case 'month':
                this.date(1);
                /* falls through */
            case 'week':
            case 'isoWeek':
            case 'day':
            case 'date':
                this.hours(0);
                /* falls through */
            case 'hour':
                this.minutes(0);
                /* falls through */
            case 'minute':
                this.seconds(0);
                /* falls through */
            case 'second':
                this.milliseconds(0);
        }

        // weeks are a special case
        if (units === 'week') {
            this.weekday(0);
        }
        if (units === 'isoWeek') {
            this.isoWeekday(1);
        }

        // quarters are also special
        if (units === 'quarter') {
            this.month(Math.floor(this.month() / 3) * 3);
        }

        return this;
    }

    function endOf (units) {
        units = normalizeUnits(units);
        if (units === undefined || units === 'millisecond') {
            return this;
        }

        // 'date' is an alias for 'day', so it should be considered as such.
        if (units === 'date') {
            units = 'day';
        }

        return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');
    }

    function valueOf () {
        return this._d.valueOf() - ((this._offset || 0) * 60000);
    }

    function unix () {
        return Math.floor(this.valueOf() / 1000);
    }

    function toDate () {
        return new Date(this.valueOf());
    }

    function toArray () {
        var m = this;
        return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];
    }

    function toObject () {
        var m = this;
        return {
            years: m.year(),
            months: m.month(),
            date: m.date(),
            hours: m.hours(),
            minutes: m.minutes(),
            seconds: m.seconds(),
            milliseconds: m.milliseconds()
        };
    }

    function toJSON () {
        // new Date(NaN).toJSON() === null
        return this.isValid() ? this.toISOString() : null;
    }

    function isValid$1 () {
        return isValid(this);
    }

    function parsingFlags () {
        return extend({}, getParsingFlags(this));
    }

    function invalidAt () {
        return getParsingFlags(this).overflow;
    }

    function creationData() {
        return {
            input: this._i,
            format: this._f,
            locale: this._locale,
            isUTC: this._isUTC,
            strict: this._strict
        };
    }

    // FORMATTING

    addFormatToken(0, ['gg', 2], 0, function () {
        return this.weekYear() % 100;
    });

    addFormatToken(0, ['GG', 2], 0, function () {
        return this.isoWeekYear() % 100;
    });

    function addWeekYearFormatToken (token, getter) {
        addFormatToken(0, [token, token.length], 0, getter);
    }

    addWeekYearFormatToken('gggg',     'weekYear');
    addWeekYearFormatToken('ggggg',    'weekYear');
    addWeekYearFormatToken('GGGG',  'isoWeekYear');
    addWeekYearFormatToken('GGGGG', 'isoWeekYear');

    // ALIASES

    addUnitAlias('weekYear', 'gg');
    addUnitAlias('isoWeekYear', 'GG');

    // PRIORITY

    addUnitPriority('weekYear', 1);
    addUnitPriority('isoWeekYear', 1);

    // PARSING

    addRegexToken('G',      matchSigned);
    addRegexToken('g',      matchSigned);
    addRegexToken('GG',     match1to2, match2);
    addRegexToken('gg',     match1to2, match2);
    addRegexToken('GGGG',   match1to4, match4);
    addRegexToken('gggg',   match1to4, match4);
    addRegexToken('GGGGG',  match1to6, match6);
    addRegexToken('ggggg',  match1to6, match6);

    addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
        week[token.substr(0, 2)] = toInt(input);
    });

    addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
        week[token] = hooks.parseTwoDigitYear(input);
    });

    // MOMENTS

    function getSetWeekYear (input) {
        return getSetWeekYearHelper.call(this,
                input,
                this.week(),
                this.weekday(),
                this.localeData()._week.dow,
                this.localeData()._week.doy);
    }

    function getSetISOWeekYear (input) {
        return getSetWeekYearHelper.call(this,
                input, this.isoWeek(), this.isoWeekday(), 1, 4);
    }

    function getISOWeeksInYear () {
        return weeksInYear(this.year(), 1, 4);
    }

    function getWeeksInYear () {
        var weekInfo = this.localeData()._week;
        return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
    }

    function getSetWeekYearHelper(input, week, weekday, dow, doy) {
        var weeksTarget;
        if (input == null) {
            return weekOfYear(this, dow, doy).year;
        } else {
            weeksTarget = weeksInYear(input, dow, doy);
            if (week > weeksTarget) {
                week = weeksTarget;
            }
            return setWeekAll.call(this, input, week, weekday, dow, doy);
        }
    }

    function setWeekAll(weekYear, week, weekday, dow, doy) {
        var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
            date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);

        this.year(date.getUTCFullYear());
        this.month(date.getUTCMonth());
        this.date(date.getUTCDate());
        return this;
    }

    // FORMATTING

    addFormatToken('Q', 0, 'Qo', 'quarter');

    // ALIASES

    addUnitAlias('quarter', 'Q');

    // PRIORITY

    addUnitPriority('quarter', 7);

    // PARSING

    addRegexToken('Q', match1);
    addParseToken('Q', function (input, array) {
        array[MONTH] = (toInt(input) - 1) * 3;
    });

    // MOMENTS

    function getSetQuarter (input) {
        return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
    }

    // FORMATTING

    addFormatToken('D', ['DD', 2], 'Do', 'date');

    // ALIASES

    addUnitAlias('date', 'D');

    // PRIOROITY
    addUnitPriority('date', 9);

    // PARSING

    addRegexToken('D',  match1to2);
    addRegexToken('DD', match1to2, match2);
    addRegexToken('Do', function (isStrict, locale) {
        return isStrict ? locale._ordinalParse : locale._ordinalParseLenient;
    });

    addParseToken(['D', 'DD'], DATE);
    addParseToken('Do', function (input, array) {
        array[DATE] = toInt(input.match(match1to2)[0], 10);
    });

    // MOMENTS

    var getSetDayOfMonth = makeGetSet('Date', true);

    // FORMATTING

    addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');

    // ALIASES

    addUnitAlias('dayOfYear', 'DDD');

    // PRIORITY
    addUnitPriority('dayOfYear', 4);

    // PARSING

    addRegexToken('DDD',  match1to3);
    addRegexToken('DDDD', match3);
    addParseToken(['DDD', 'DDDD'], function (input, array, config) {
        config._dayOfYear = toInt(input);
    });

    // HELPERS

    // MOMENTS

    function getSetDayOfYear (input) {
        var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;
        return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');
    }

    // FORMATTING

    addFormatToken('m', ['mm', 2], 0, 'minute');

    // ALIASES

    addUnitAlias('minute', 'm');

    // PRIORITY

    addUnitPriority('minute', 14);

    // PARSING

    addRegexToken('m',  match1to2);
    addRegexToken('mm', match1to2, match2);
    addParseToken(['m', 'mm'], MINUTE);

    // MOMENTS

    var getSetMinute = makeGetSet('Minutes', false);

    // FORMATTING

    addFormatToken('s', ['ss', 2], 0, 'second');

    // ALIASES

    addUnitAlias('second', 's');

    // PRIORITY

    addUnitPriority('second', 15);

    // PARSING

    addRegexToken('s',  match1to2);
    addRegexToken('ss', match1to2, match2);
    addParseToken(['s', 'ss'], SECOND);

    // MOMENTS

    var getSetSecond = makeGetSet('Seconds', false);

    // FORMATTING

    addFormatToken('S', 0, 0, function () {
        return ~~(this.millisecond() / 100);
    });

    addFormatToken(0, ['SS', 2], 0, function () {
        return ~~(this.millisecond() / 10);
    });

    addFormatToken(0, ['SSS', 3], 0, 'millisecond');
    addFormatToken(0, ['SSSS', 4], 0, function () {
        return this.millisecond() * 10;
    });
    addFormatToken(0, ['SSSSS', 5], 0, function () {
        return this.millisecond() * 100;
    });
    addFormatToken(0, ['SSSSSS', 6], 0, function () {
        return this.millisecond() * 1000;
    });
    addFormatToken(0, ['SSSSSSS', 7], 0, function () {
        return this.millisecond() * 10000;
    });
    addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
        return this.millisecond() * 100000;
    });
    addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
        return this.millisecond() * 1000000;
    });

    // ALIASES

    addUnitAlias('millisecond', 'ms');

    // PRIORITY

    addUnitPriority('millisecond', 16);

    // PARSING

    addRegexToken('S',    match1to3, match1);
    addRegexToken('SS',   match1to3, match2);
    addRegexToken('SSS',  match1to3, match3);

    var token;
    for (token = 'SSSS'; token.length <= 9; token += 'S') {
        addRegexToken(token, matchUnsigned);
    }

    function parseMs(input, array) {
        array[MILLISECOND] = toInt(('0.' + input) * 1000);
    }

    for (token = 'S'; token.length <= 9; token += 'S') {
        addParseToken(token, parseMs);
    }
    // MOMENTS

    var getSetMillisecond = makeGetSet('Milliseconds', false);

    // FORMATTING

    addFormatToken('z',  0, 0, 'zoneAbbr');
    addFormatToken('zz', 0, 0, 'zoneName');

    // MOMENTS

    function getZoneAbbr () {
        return this._isUTC ? 'UTC' : '';
    }

    function getZoneName () {
        return this._isUTC ? 'Coordinated Universal Time' : '';
    }

    var proto = Moment.prototype;

    proto.add               = add;
    proto.calendar          = calendar$1;
    proto.clone             = clone;
    proto.diff              = diff;
    proto.endOf             = endOf;
    proto.format            = format;
    proto.from              = from;
    proto.fromNow           = fromNow;
    proto.to                = to;
    proto.toNow             = toNow;
    proto.get               = stringGet;
    proto.invalidAt         = invalidAt;
    proto.isAfter           = isAfter;
    proto.isBefore          = isBefore;
    proto.isBetween         = isBetween;
    proto.isSame            = isSame;
    proto.isSameOrAfter     = isSameOrAfter;
    proto.isSameOrBefore    = isSameOrBefore;
    proto.isValid           = isValid$1;
    proto.lang              = lang;
    proto.locale            = locale;
    proto.localeData        = localeData;
    proto.max               = prototypeMax;
    proto.min               = prototypeMin;
    proto.parsingFlags      = parsingFlags;
    proto.set               = stringSet;
    proto.startOf           = startOf;
    proto.subtract          = subtract;
    proto.toArray           = toArray;
    proto.toObject          = toObject;
    proto.toDate            = toDate;
    proto.toISOString       = toISOString;
    proto.inspect           = inspect;
    proto.toJSON            = toJSON;
    proto.toString          = toString;
    proto.unix              = unix;
    proto.valueOf           = valueOf;
    proto.creationData      = creationData;

    // Year
    proto.year       = getSetYear;
    proto.isLeapYear = getIsLeapYear;

    // Week Year
    proto.weekYear    = getSetWeekYear;
    proto.isoWeekYear = getSetISOWeekYear;

    // Quarter
    proto.quarter = proto.quarters = getSetQuarter;

    // Month
    proto.month       = getSetMonth;
    proto.daysInMonth = getDaysInMonth;

    // Week
    proto.week           = proto.weeks        = getSetWeek;
    proto.isoWeek        = proto.isoWeeks     = getSetISOWeek;
    proto.weeksInYear    = getWeeksInYear;
    proto.isoWeeksInYear = getISOWeeksInYear;

    // Day
    proto.date       = getSetDayOfMonth;
    proto.day        = proto.days             = getSetDayOfWeek;
    proto.weekday    = getSetLocaleDayOfWeek;
    proto.isoWeekday = getSetISODayOfWeek;
    proto.dayOfYear  = getSetDayOfYear;

    // Hour
    proto.hour = proto.hours = getSetHour;

    // Minute
    proto.minute = proto.minutes = getSetMinute;

    // Second
    proto.second = proto.seconds = getSetSecond;

    // Millisecond
    proto.millisecond = proto.milliseconds = getSetMillisecond;

    // Offset
    proto.utcOffset            = getSetOffset;
    proto.utc                  = setOffsetToUTC;
    proto.local                = setOffsetToLocal;
    proto.parseZone            = setOffsetToParsedOffset;
    proto.hasAlignedHourOffset = hasAlignedHourOffset;
    proto.isDST                = isDaylightSavingTime;
    proto.isLocal              = isLocal;
    proto.isUtcOffset          = isUtcOffset;
    proto.isUtc                = isUtc;
    proto.isUTC                = isUtc;

    // Timezone
    proto.zoneAbbr = getZoneAbbr;
    proto.zoneName = getZoneName;

    // Deprecations
    proto.dates  = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
    proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
    proto.years  = deprecate('years accessor is deprecated. Use year instead', getSetYear);
    proto.zone   = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone);
    proto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted);

    function createUnix (input) {
        return createLocal(input * 1000);
    }

    function createInZone () {
        return createLocal.apply(null, arguments).parseZone();
    }

    function preParsePostFormat (string) {
        return string;
    }

    var proto$1 = Locale.prototype;

    proto$1.calendar        = calendar;
    proto$1.longDateFormat  = longDateFormat;
    proto$1.invalidDate     = invalidDate;
    proto$1.ordinal         = ordinal;
    proto$1.preparse        = preParsePostFormat;
    proto$1.postformat      = preParsePostFormat;
    proto$1.relativeTime    = relativeTime;
    proto$1.pastFuture      = pastFuture;
    proto$1.set             = set;

    // Month
    proto$1.months            =        localeMonths;
    proto$1.monthsShort       =        localeMonthsShort;
    proto$1.monthsParse       =        localeMonthsParse;
    proto$1.monthsRegex       = monthsRegex;
    proto$1.monthsShortRegex  = monthsShortRegex;

    // Week
    proto$1.week = localeWeek;
    proto$1.firstDayOfYear = localeFirstDayOfYear;
    proto$1.firstDayOfWeek = localeFirstDayOfWeek;

    // Day of Week
    proto$1.weekdays       =        localeWeekdays;
    proto$1.weekdaysMin    =        localeWeekdaysMin;
    proto$1.weekdaysShort  =        localeWeekdaysShort;
    proto$1.weekdaysParse  =        localeWeekdaysParse;

    proto$1.weekdaysRegex       =        weekdaysRegex;
    proto$1.weekdaysShortRegex  =        weekdaysShortRegex;
    proto$1.weekdaysMinRegex    =        weekdaysMinRegex;

    // Hours
    proto$1.isPM = localeIsPM;
    proto$1.meridiem = localeMeridiem;

    function get$1 (format, index, field, setter) {
        var locale = getLocale();
        var utc = createUTC().set(setter, index);
        return locale[field](utc, format);
    }

    function listMonthsImpl (format, index, field) {
        if (isNumber(format)) {
            index = format;
            format = undefined;
        }

        format = format || '';

        if (index != null) {
            return get$1(format, index, field, 'month');
        }

        var i;
        var out = [];
        for (i = 0; i < 12; i++) {
            out[i] = get$1(format, i, field, 'month');
        }
        return out;
    }

    // ()
    // (5)
    // (fmt, 5)
    // (fmt)
    // (true)
    // (true, 5)
    // (true, fmt, 5)
    // (true, fmt)
    function listWeekdaysImpl (localeSorted, format, index, field) {
        if (typeof localeSorted === 'boolean') {
            if (isNumber(format)) {
                index = format;
                format = undefined;
            }

            format = format || '';
        } else {
            format = localeSorted;
            index = format;
            localeSorted = false;

            if (isNumber(format)) {
                index = format;
                format = undefined;
            }

            format = format || '';
        }

        var locale = getLocale(),
            shift = localeSorted ? locale._week.dow : 0;

        if (index != null) {
            return get$1(format, (index + shift) % 7, field, 'day');
        }

        var i;
        var out = [];
        for (i = 0; i < 7; i++) {
            out[i] = get$1(format, (i + shift) % 7, field, 'day');
        }
        return out;
    }

    function listMonths (format, index) {
        return listMonthsImpl(format, index, 'months');
    }

    function listMonthsShort (format, index) {
        return listMonthsImpl(format, index, 'monthsShort');
    }

    function listWeekdays (localeSorted, format, index) {
        return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
    }

    function listWeekdaysShort (localeSorted, format, index) {
        return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
    }

    function listWeekdaysMin (localeSorted, format, index) {
        return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');
    }

    getSetGlobalLocale('en', {
        ordinalParse: /\d{1,2}(th|st|nd|rd)/,
        ordinal : function (number) {
            var b = number % 10,
                output = (toInt(number % 100 / 10) === 1) ? 'th' :
                (b === 1) ? 'st' :
                (b === 2) ? 'nd' :
                (b === 3) ? 'rd' : 'th';
            return number + output;
        }
    });

    // Side effect imports
    hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale);
    hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale);

    var mathAbs = Math.abs;

    function abs () {
        var data           = this._data;

        this._milliseconds = mathAbs(this._milliseconds);
        this._days         = mathAbs(this._days);
        this._months       = mathAbs(this._months);

        data.milliseconds  = mathAbs(data.milliseconds);
        data.seconds       = mathAbs(data.seconds);
        data.minutes       = mathAbs(data.minutes);
        data.hours         = mathAbs(data.hours);
        data.months        = mathAbs(data.months);
        data.years         = mathAbs(data.years);

        return this;
    }

    function addSubtract$1 (duration, input, value, direction) {
        var other = createDuration(input, value);

        duration._milliseconds += direction * other._milliseconds;
        duration._days         += direction * other._days;
        duration._months       += direction * other._months;

        return duration._bubble();
    }

    // supports only 2.0-style add(1, 's') or add(duration)
    function add$1 (input, value) {
        return addSubtract$1(this, input, value, 1);
    }

    // supports only 2.0-style subtract(1, 's') or subtract(duration)
    function subtract$1 (input, value) {
        return addSubtract$1(this, input, value, -1);
    }

    function absCeil (number) {
        if (number < 0) {
            return Math.floor(number);
        } else {
            return Math.ceil(number);
        }
    }

    function bubble () {
        var milliseconds = this._milliseconds;
        var days         = this._days;
        var months       = this._months;
        var data         = this._data;
        var seconds, minutes, hours, years, monthsFromDays;

        // if we have a mix of positive and negative values, bubble down first
        // check: https://github.com/moment/moment/issues/2166
        if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||
                (milliseconds <= 0 && days <= 0 && months <= 0))) {
            milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
            days = 0;
            months = 0;
        }

        // The following code bubbles up values, see the tests for
        // examples of what that means.
        data.milliseconds = milliseconds % 1000;

        seconds           = absFloor(milliseconds / 1000);
        data.seconds      = seconds % 60;

        minutes           = absFloor(seconds / 60);
        data.minutes      = minutes % 60;

        hours             = absFloor(minutes / 60);
        data.hours        = hours % 24;

        days += absFloor(hours / 24);

        // convert days to months
        monthsFromDays = absFloor(daysToMonths(days));
        months += monthsFromDays;
        days -= absCeil(monthsToDays(monthsFromDays));

        // 12 months -> 1 year
        years = absFloor(months / 12);
        months %= 12;

        data.days   = days;
        data.months = months;
        data.years  = years;

        return this;
    }

    function daysToMonths (days) {
        // 400 years have 146097 days (taking into account leap year rules)
        // 400 years have 12 months === 4800
        return days * 4800 / 146097;
    }

    function monthsToDays (months) {
        // the reverse of daysToMonths
        return months * 146097 / 4800;
    }

    function as (units) {
        var days;
        var months;
        var milliseconds = this._milliseconds;

        units = normalizeUnits(units);

        if (units === 'month' || units === 'year') {
            days   = this._days   + milliseconds / 864e5;
            months = this._months + daysToMonths(days);
            return units === 'month' ? months : months / 12;
        } else {
            // handle milliseconds separately because of floating point math errors (issue #1867)
            days = this._days + Math.round(monthsToDays(this._months));
            switch (units) {
                case 'week'   : return days / 7     + milliseconds / 6048e5;
                case 'day'    : return days         + milliseconds / 864e5;
                case 'hour'   : return days * 24    + milliseconds / 36e5;
                case 'minute' : return days * 1440  + milliseconds / 6e4;
                case 'second' : return days * 86400 + milliseconds / 1000;
                // Math.floor prevents floating point math errors here
                case 'millisecond': return Math.floor(days * 864e5) + milliseconds;
                default: throw new Error('Unknown unit ' + units);
            }
        }
    }

    // TODO: Use this.as('ms')?
    function valueOf$1 () {
        return (
            this._milliseconds +
            this._days * 864e5 +
            (this._months % 12) * 2592e6 +
            toInt(this._months / 12) * 31536e6
        );
    }

    function makeAs (alias) {
        return function () {
            return this.as(alias);
        };
    }

    var asMilliseconds = makeAs('ms');
    var asSeconds      = makeAs('s');
    var asMinutes      = makeAs('m');
    var asHours        = makeAs('h');
    var asDays         = makeAs('d');
    var asWeeks        = makeAs('w');
    var asMonths       = makeAs('M');
    var asYears        = makeAs('y');

    function get$2 (units) {
        units = normalizeUnits(units);
        return this[units + 's']();
    }

    function makeGetter(name) {
        return function () {
            return this._data[name];
        };
    }

    var milliseconds = makeGetter('milliseconds');
    var seconds      = makeGetter('seconds');
    var minutes      = makeGetter('minutes');
    var hours        = makeGetter('hours');
    var days         = makeGetter('days');
    var months       = makeGetter('months');
    var years        = makeGetter('years');

    function weeks () {
        return absFloor(this.days() / 7);
    }

    var round = Math.round;
    var thresholds = {
        s: 45,  // seconds to minute
        m: 45,  // minutes to hour
        h: 22,  // hours to day
        d: 26,  // days to month
        M: 11   // months to year
    };

    // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
    function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
        return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
    }

    function relativeTime$1 (posNegDuration, withoutSuffix, locale) {
        var duration = createDuration(posNegDuration).abs();
        var seconds  = round(duration.as('s'));
        var minutes  = round(duration.as('m'));
        var hours    = round(duration.as('h'));
        var days     = round(duration.as('d'));
        var months   = round(duration.as('M'));
        var years    = round(duration.as('y'));

        var a = seconds < thresholds.s && ['s', seconds]  ||
                minutes <= 1           && ['m']           ||
                minutes < thresholds.m && ['mm', minutes] ||
                hours   <= 1           && ['h']           ||
                hours   < thresholds.h && ['hh', hours]   ||
                days    <= 1           && ['d']           ||
                days    < thresholds.d && ['dd', days]    ||
                months  <= 1           && ['M']           ||
                months  < thresholds.M && ['MM', months]  ||
                years   <= 1           && ['y']           || ['yy', years];

        a[2] = withoutSuffix;
        a[3] = +posNegDuration > 0;
        a[4] = locale;
        return substituteTimeAgo.apply(null, a);
    }

    // This function allows you to set the rounding function for relative time strings
    function getSetRelativeTimeRounding (roundingFunction) {
        if (roundingFunction === undefined) {
            return round;
        }
        if (typeof(roundingFunction) === 'function') {
            round = roundingFunction;
            return true;
        }
        return false;
    }

    // This function allows you to set a threshold for relative time strings
    function getSetRelativeTimeThreshold (threshold, limit) {
        if (thresholds[threshold] === undefined) {
            return false;
        }
        if (limit === undefined) {
            return thresholds[threshold];
        }
        thresholds[threshold] = limit;
        return true;
    }

    function humanize (withSuffix) {
        var locale = this.localeData();
        var output = relativeTime$1(this, !withSuffix, locale);

        if (withSuffix) {
            output = locale.pastFuture(+this, output);
        }

        return locale.postformat(output);
    }

    var abs$1 = Math.abs;

    function toISOString$1() {
        // for ISO strings we do not use the normal bubbling rules:
        //  * milliseconds bubble up until they become hours
        //  * days do not bubble at all
        //  * months bubble up until they become years
        // This is because there is no context-free conversion between hours and days
        // (think of clock changes)
        // and also not between days and months (28-31 days per month)
        var seconds = abs$1(this._milliseconds) / 1000;
        var days         = abs$1(this._days);
        var months       = abs$1(this._months);
        var minutes, hours, years;

        // 3600 seconds -> 60 minutes -> 1 hour
        minutes           = absFloor(seconds / 60);
        hours             = absFloor(minutes / 60);
        seconds %= 60;
        minutes %= 60;

        // 12 months -> 1 year
        years  = absFloor(months / 12);
        months %= 12;

        // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
        var Y = years;
        var M = months;
        var D = days;
        var h = hours;
        var m = minutes;
        var s = seconds;
        var total = this.asSeconds();

        if (!total) {
            // this is the same as C#'s (Noda) and python (isodate)...
            // but not other JS (goog.date)
            return 'P0D';
        }

        return (total < 0 ? '-' : '') +
            'P' +
            (Y ? Y + 'Y' : '') +
            (M ? M + 'M' : '') +
            (D ? D + 'D' : '') +
            ((h || m || s) ? 'T' : '') +
            (h ? h + 'H' : '') +
            (m ? m + 'M' : '') +
            (s ? s + 'S' : '');
    }

    var proto$2 = Duration.prototype;

    proto$2.abs            = abs;
    proto$2.add            = add$1;
    proto$2.subtract       = subtract$1;
    proto$2.as             = as;
    proto$2.asMilliseconds = asMilliseconds;
    proto$2.asSeconds      = asSeconds;
    proto$2.asMinutes      = asMinutes;
    proto$2.asHours        = asHours;
    proto$2.asDays         = asDays;
    proto$2.asWeeks        = asWeeks;
    proto$2.asMonths       = asMonths;
    proto$2.asYears        = asYears;
    proto$2.valueOf        = valueOf$1;
    proto$2._bubble        = bubble;
    proto$2.get            = get$2;
    proto$2.milliseconds   = milliseconds;
    proto$2.seconds        = seconds;
    proto$2.minutes        = minutes;
    proto$2.hours          = hours;
    proto$2.days           = days;
    proto$2.weeks          = weeks;
    proto$2.months         = months;
    proto$2.years          = years;
    proto$2.humanize       = humanize;
    proto$2.toISOString    = toISOString$1;
    proto$2.toString       = toISOString$1;
    proto$2.toJSON         = toISOString$1;
    proto$2.locale         = locale;
    proto$2.localeData     = localeData;

    // Deprecations
    proto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1);
    proto$2.lang = lang;

    // Side effect imports

    // FORMATTING

    addFormatToken('X', 0, 0, 'unix');
    addFormatToken('x', 0, 0, 'valueOf');

    // PARSING

    addRegexToken('x', matchSigned);
    addRegexToken('X', matchTimestamp);
    addParseToken('X', function (input, array, config) {
        config._d = new Date(parseFloat(input, 10) * 1000);
    });
    addParseToken('x', function (input, array, config) {
        config._d = new Date(toInt(input));
    });

    // Side effect imports

    hooks.version = '2.17.1';

    setHookCallback(createLocal);

    hooks.fn                    = proto;
    hooks.min                   = min;
    hooks.max                   = max;
    hooks.now                   = now;
    hooks.utc                   = createUTC;
    hooks.unix                  = createUnix;
    hooks.months                = listMonths;
    hooks.isDate                = isDate;
    hooks.locale                = getSetGlobalLocale;
    hooks.invalid               = createInvalid;
    hooks.duration              = createDuration;
    hooks.isMoment              = isMoment;
    hooks.weekdays              = listWeekdays;
    hooks.parseZone             = createInZone;
    hooks.localeData            = getLocale;
    hooks.isDuration            = isDuration;
    hooks.monthsShort           = listMonthsShort;
    hooks.weekdaysMin           = listWeekdaysMin;
    hooks.defineLocale          = defineLocale;
    hooks.updateLocale          = updateLocale;
    hooks.locales               = listLocales;
    hooks.weekdaysShort         = listWeekdaysShort;
    hooks.normalizeUnits        = normalizeUnits;
    hooks.relativeTimeRounding = getSetRelativeTimeRounding;
    hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
    hooks.calendarFormat        = getCalendarFormat;
    hooks.prototype             = proto;

    return hooks;

    })));

    },{}],10:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _PanelGroup = require('./PanelGroup');

    var _PanelGroup2 = _interopRequireDefault(_PanelGroup);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var Accordion = function (_React$Component) {
      (0, _inherits3['default'])(Accordion, _React$Component);

      function Accordion() {
        (0, _classCallCheck3['default'])(this, Accordion);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Accordion.prototype.render = function render() {
        return _react2['default'].createElement(
          _PanelGroup2['default'],
          (0, _extends3['default'])({}, this.props, { accordion: true }),
          this.props.children
        );
      };

      return Accordion;
    }(_react2['default'].Component);

    exports['default'] = Accordion;
    module.exports = exports['default'];

    },{"./PanelGroup":78,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/possibleConstructorReturn":119,"react":618}],11:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _values = require('babel-runtime/core-js/object/values');

    var _values2 = _interopRequireDefault(_values);

    var _extends3 = require('babel-runtime/helpers/extends');

    var _extends4 = _interopRequireDefault(_extends3);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _StyleConfig = require('./utils/StyleConfig');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      onDismiss: _react2['default'].PropTypes.func,
      closeLabel: _react2['default'].PropTypes.string
    };

    var defaultProps = {
      closeLabel: 'Close alert'
    };

    var Alert = function (_React$Component) {
      (0, _inherits3['default'])(Alert, _React$Component);

      function Alert() {
        (0, _classCallCheck3['default'])(this, Alert);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Alert.prototype.renderDismissButton = function renderDismissButton(onDismiss) {
        return _react2['default'].createElement(
          'button',
          {
            type: 'button',
            className: 'close',
            onClick: onDismiss,
            'aria-hidden': 'true',
            tabIndex: '-1'
          },
          _react2['default'].createElement(
            'span',
            null,
            '\xD7'
          )
        );
      };

      Alert.prototype.renderSrOnlyDismissButton = function renderSrOnlyDismissButton(onDismiss, closeLabel) {
        return _react2['default'].createElement(
          'button',
          {
            type: 'button',
            className: 'close sr-only',
            onClick: onDismiss
          },
          closeLabel
        );
      };

      Alert.prototype.render = function render() {
        var _extends2;

        var _props = this.props,
            onDismiss = _props.onDismiss,
            closeLabel = _props.closeLabel,
            className = _props.className,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['onDismiss', 'closeLabel', 'className', 'children']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var dismissable = !!onDismiss;
        var classes = (0, _extends4['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), (_extends2 = {}, _extends2[(0, _bootstrapUtils.prefix)(bsProps, 'dismissable')] = dismissable, _extends2));

        return _react2['default'].createElement(
          'div',
          (0, _extends4['default'])({}, elementProps, {
            role: 'alert',
            className: (0, _classnames2['default'])(className, classes)
          }),
          dismissable && this.renderDismissButton(onDismiss),
          children,
          dismissable && this.renderSrOnlyDismissButton(onDismiss, closeLabel)
        );
      };

      return Alert;
    }(_react2['default'].Component);

    Alert.propTypes = propTypes;
    Alert.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsStyles)((0, _values2['default'])(_StyleConfig.State), _StyleConfig.State.INFO, (0, _bootstrapUtils.bsClass)('alert', Alert));
    module.exports = exports['default'];

    },{"./utils/StyleConfig":98,"./utils/bootstrapUtils":101,"babel-runtime/core-js/object/values":112,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],12:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    // TODO: `pullRight` doesn't belong here. There's no special handling here.

    var propTypes = {
      pullRight: _react2['default'].PropTypes.bool
    };

    var defaultProps = {
      pullRight: false
    };

    var Badge = function (_React$Component) {
      (0, _inherits3['default'])(Badge, _React$Component);

      function Badge() {
        (0, _classCallCheck3['default'])(this, Badge);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Badge.prototype.hasContent = function hasContent(children) {
        var result = false;

        _react2['default'].Children.forEach(children, function (child) {
          if (result) {
            return;
          }

          if (child || child === 0) {
            result = true;
          }
        });

        return result;
      };

      Badge.prototype.render = function render() {
        var _props = this.props,
            pullRight = _props.pullRight,
            className = _props.className,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['pullRight', 'className', 'children']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _extends3['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), {
          'pull-right': pullRight,

          // Hack for collapsing on IE8.
          hidden: !this.hasContent(children)
        });

        return _react2['default'].createElement(
          'span',
          (0, _extends3['default'])({}, elementProps, {
            className: (0, _classnames2['default'])(className, classes)
          }),
          children
        );
      };

      return Badge;
    }(_react2['default'].Component);

    Badge.propTypes = propTypes;
    Badge.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('badge', Badge);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],13:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _BreadcrumbItem = require('./BreadcrumbItem');

    var _BreadcrumbItem2 = _interopRequireDefault(_BreadcrumbItem);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var Breadcrumb = function (_React$Component) {
      (0, _inherits3['default'])(Breadcrumb, _React$Component);

      function Breadcrumb() {
        (0, _classCallCheck3['default'])(this, Breadcrumb);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Breadcrumb.prototype.render = function render() {
        var _props = this.props,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement('ol', (0, _extends3['default'])({}, elementProps, {
          role: 'navigation',
          'aria-label': 'breadcrumbs',
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return Breadcrumb;
    }(_react2['default'].Component);

    Breadcrumb.Item = _BreadcrumbItem2['default'];

    exports['default'] = (0, _bootstrapUtils.bsClass)('breadcrumb', Breadcrumb);
    module.exports = exports['default'];

    },{"./BreadcrumbItem":14,"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],14:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _SafeAnchor = require('./SafeAnchor');

    var _SafeAnchor2 = _interopRequireDefault(_SafeAnchor);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      /**
       * If set to true, renders `span` instead of `a`
       */
      active: _react2['default'].PropTypes.bool,
      /**
       * `href` attribute for the inner `a` element
       */
      href: _react2['default'].PropTypes.string,
      /**
       * `title` attribute for the inner `a` element
       */
      title: _react2['default'].PropTypes.node,
      /**
       * `target` attribute for the inner `a` element
       */
      target: _react2['default'].PropTypes.string
    };

    var defaultProps = {
      active: false
    };

    var BreadcrumbItem = function (_React$Component) {
      (0, _inherits3['default'])(BreadcrumbItem, _React$Component);

      function BreadcrumbItem() {
        (0, _classCallCheck3['default'])(this, BreadcrumbItem);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      BreadcrumbItem.prototype.render = function render() {
        var _props = this.props,
            active = _props.active,
            href = _props.href,
            title = _props.title,
            target = _props.target,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['active', 'href', 'title', 'target', 'className']);

        // Don't try to render these props on non-active <span>.

        var linkProps = { href: href, title: title, target: target };

        return _react2['default'].createElement(
          'li',
          { className: (0, _classnames2['default'])(className, { active: active }) },
          active ? _react2['default'].createElement('span', props) : _react2['default'].createElement(_SafeAnchor2['default'], (0, _extends3['default'])({}, props, linkProps))
        );
      };

      return BreadcrumbItem;
    }(_react2['default'].Component);

    BreadcrumbItem.propTypes = propTypes;
    BreadcrumbItem.defaultProps = defaultProps;

    exports['default'] = BreadcrumbItem;
    module.exports = exports['default'];

    },{"./SafeAnchor":84,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],15:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _values = require('babel-runtime/core-js/object/values');

    var _values2 = _interopRequireDefault(_values);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _extends3 = require('babel-runtime/helpers/extends');

    var _extends4 = _interopRequireDefault(_extends3);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _StyleConfig = require('./utils/StyleConfig');

    var _SafeAnchor = require('./SafeAnchor');

    var _SafeAnchor2 = _interopRequireDefault(_SafeAnchor);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      active: _react2['default'].PropTypes.bool,
      disabled: _react2['default'].PropTypes.bool,
      block: _react2['default'].PropTypes.bool,
      onClick: _react2['default'].PropTypes.func,
      componentClass: _elementType2['default'],
      href: _react2['default'].PropTypes.string,
      /**
       * Defines HTML button type attribute
       * @defaultValue 'button'
       */
      type: _react2['default'].PropTypes.oneOf(['button', 'reset', 'submit'])
    };

    var defaultProps = {
      active: false,
      block: false,
      disabled: false
    };

    var Button = function (_React$Component) {
      (0, _inherits3['default'])(Button, _React$Component);

      function Button() {
        (0, _classCallCheck3['default'])(this, Button);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Button.prototype.renderAnchor = function renderAnchor(elementProps, className) {
        return _react2['default'].createElement(_SafeAnchor2['default'], (0, _extends4['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, elementProps.disabled && 'disabled')
        }));
      };

      Button.prototype.renderButton = function renderButton(_ref, className) {
        var componentClass = _ref.componentClass,
            elementProps = (0, _objectWithoutProperties3['default'])(_ref, ['componentClass']);

        var Component = componentClass || 'button';

        return _react2['default'].createElement(Component, (0, _extends4['default'])({}, elementProps, {
          type: elementProps.type || 'button',
          className: className
        }));
      };

      Button.prototype.render = function render() {
        var _extends2;

        var _props = this.props,
            active = _props.active,
            block = _props.block,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['active', 'block', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _extends4['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), (_extends2 = {
          active: active
        }, _extends2[(0, _bootstrapUtils.prefix)(bsProps, 'block')] = block, _extends2));
        var fullClassName = (0, _classnames2['default'])(className, classes);

        if (elementProps.href) {
          return this.renderAnchor(elementProps, fullClassName);
        }

        return this.renderButton(elementProps, fullClassName);
      };

      return Button;
    }(_react2['default'].Component);

    Button.propTypes = propTypes;
    Button.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('btn', (0, _bootstrapUtils.bsSizes)([_StyleConfig.Size.LARGE, _StyleConfig.Size.SMALL, _StyleConfig.Size.XSMALL], (0, _bootstrapUtils.bsStyles)([].concat((0, _values2['default'])(_StyleConfig.State), [_StyleConfig.Style.DEFAULT, _StyleConfig.Style.PRIMARY, _StyleConfig.Style.LINK]), _StyleConfig.Style.DEFAULT, Button)));
    module.exports = exports['default'];

    },{"./SafeAnchor":84,"./utils/StyleConfig":98,"./utils/bootstrapUtils":101,"babel-runtime/core-js/object/values":112,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255}],16:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends3 = require('babel-runtime/helpers/extends');

    var _extends4 = _interopRequireDefault(_extends3);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _all = require('react-prop-types/lib/all');

    var _all2 = _interopRequireDefault(_all);

    var _Button = require('./Button');

    var _Button2 = _interopRequireDefault(_Button);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      vertical: _react2['default'].PropTypes.bool,
      justified: _react2['default'].PropTypes.bool,

      /**
       * Display block buttons; only useful when used with the "vertical" prop.
       * @type {bool}
       */
      block: (0, _all2['default'])(_react2['default'].PropTypes.bool, function (_ref) {
        var block = _ref.block,
            vertical = _ref.vertical;
        return block && !vertical ? new Error('`block` requires `vertical` to be set to have any effect') : null;
      })
    };

    var defaultProps = {
      block: false,
      justified: false,
      vertical: false
    };

    var ButtonGroup = function (_React$Component) {
      (0, _inherits3['default'])(ButtonGroup, _React$Component);

      function ButtonGroup() {
        (0, _classCallCheck3['default'])(this, ButtonGroup);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      ButtonGroup.prototype.render = function render() {
        var _extends2;

        var _props = this.props,
            block = _props.block,
            justified = _props.justified,
            vertical = _props.vertical,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['block', 'justified', 'vertical', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _extends4['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), (_extends2 = {}, _extends2[(0, _bootstrapUtils.prefix)(bsProps)] = !vertical, _extends2[(0, _bootstrapUtils.prefix)(bsProps, 'vertical')] = vertical, _extends2[(0, _bootstrapUtils.prefix)(bsProps, 'justified')] = justified, _extends2[(0, _bootstrapUtils.prefix)(_Button2['default'].defaultProps, 'block')] = block, _extends2));

        return _react2['default'].createElement('div', (0, _extends4['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return ButtonGroup;
    }(_react2['default'].Component);

    ButtonGroup.propTypes = propTypes;
    ButtonGroup.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('btn-group', ButtonGroup);
    module.exports = exports['default'];

    },{"./Button":15,"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/all":253}],17:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _Button = require('./Button');

    var _Button2 = _interopRequireDefault(_Button);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var ButtonToolbar = function (_React$Component) {
      (0, _inherits3['default'])(ButtonToolbar, _React$Component);

      function ButtonToolbar() {
        (0, _classCallCheck3['default'])(this, ButtonToolbar);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      ButtonToolbar.prototype.render = function render() {
        var _props = this.props,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement('div', (0, _extends3['default'])({}, elementProps, {
          role: 'toolbar',
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return ButtonToolbar;
    }(_react2['default'].Component);

    exports['default'] = (0, _bootstrapUtils.bsClass)('btn-toolbar', (0, _bootstrapUtils.bsSizes)(_Button2['default'].SIZES, ButtonToolbar));
    module.exports = exports['default'];

    },{"./Button":15,"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],18:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _CarouselCaption = require('./CarouselCaption');

    var _CarouselCaption2 = _interopRequireDefault(_CarouselCaption);

    var _CarouselItem = require('./CarouselItem');

    var _CarouselItem2 = _interopRequireDefault(_CarouselItem);

    var _Glyphicon = require('./Glyphicon');

    var _Glyphicon2 = _interopRequireDefault(_Glyphicon);

    var _SafeAnchor = require('./SafeAnchor');

    var _SafeAnchor2 = _interopRequireDefault(_SafeAnchor);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _ValidComponentChildren = require('./utils/ValidComponentChildren');

    var _ValidComponentChildren2 = _interopRequireDefault(_ValidComponentChildren);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    // TODO: `slide` should be `animate`.

    // TODO: Use uncontrollable.

    var propTypes = {
      slide: _react2['default'].PropTypes.bool,
      indicators: _react2['default'].PropTypes.bool,
      interval: _react2['default'].PropTypes.number,
      controls: _react2['default'].PropTypes.bool,
      pauseOnHover: _react2['default'].PropTypes.bool,
      wrap: _react2['default'].PropTypes.bool,
      /**
       * Callback fired when the active item changes.
       *
       * ```js
       * (eventKey: any) => any | (eventKey: any, event: Object) => any
       * ```
       *
       * If this callback takes two or more arguments, the second argument will
       * be a persisted event object with `direction` set to the direction of the
       * transition.
       */
      onSelect: _react2['default'].PropTypes.func,
      onSlideEnd: _react2['default'].PropTypes.func,
      activeIndex: _react2['default'].PropTypes.number,
      defaultActiveIndex: _react2['default'].PropTypes.number,
      direction: _react2['default'].PropTypes.oneOf(['prev', 'next']),
      prevIcon: _react2['default'].PropTypes.node,
      /**
       * Label shown to screen readers only, can be used to show the previous element
       * in the carousel.
       * Set to null to deactivate.
       */
      prevLabel: _react2['default'].PropTypes.string,
      nextIcon: _react2['default'].PropTypes.node,
      /**
       * Label shown to screen readers only, can be used to show the next element
       * in the carousel.
       * Set to null to deactivate.
       */
      nextLabel: _react2['default'].PropTypes.string
    };

    var defaultProps = {
      slide: true,
      interval: 5000,
      pauseOnHover: true,
      wrap: true,
      indicators: true,
      controls: true,
      prevIcon: _react2['default'].createElement(_Glyphicon2['default'], { glyph: 'chevron-left' }),
      prevLabel: 'Previous',
      nextIcon: _react2['default'].createElement(_Glyphicon2['default'], { glyph: 'chevron-right' }),
      nextLabel: 'Next'
    };

    var Carousel = function (_React$Component) {
      (0, _inherits3['default'])(Carousel, _React$Component);

      function Carousel(props, context) {
        (0, _classCallCheck3['default'])(this, Carousel);

        var _this = (0, _possibleConstructorReturn3['default'])(this, _React$Component.call(this, props, context));

        _this.handleMouseOver = _this.handleMouseOver.bind(_this);
        _this.handleMouseOut = _this.handleMouseOut.bind(_this);
        _this.handlePrev = _this.handlePrev.bind(_this);
        _this.handleNext = _this.handleNext.bind(_this);
        _this.handleItemAnimateOutEnd = _this.handleItemAnimateOutEnd.bind(_this);

        var defaultActiveIndex = props.defaultActiveIndex;

        _this.state = {
          activeIndex: defaultActiveIndex != null ? defaultActiveIndex : 0,
          previousActiveIndex: null,
          direction: null
        };

        _this.isUnmounted = false;
        return _this;
      }

      Carousel.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
        var activeIndex = this.getActiveIndex();

        if (nextProps.activeIndex != null && nextProps.activeIndex !== activeIndex) {
          clearTimeout(this.timeout);

          this.setState({
            previousActiveIndex: activeIndex,
            direction: nextProps.direction != null ? nextProps.direction : this.getDirection(activeIndex, nextProps.activeIndex)
          });
        }
      };

      Carousel.prototype.componentDidMount = function componentDidMount() {
        this.waitForNext();
      };

      Carousel.prototype.componentWillUnmount = function componentWillUnmount() {
        clearTimeout(this.timeout);
        this.isUnmounted = true;
      };

      Carousel.prototype.handleMouseOver = function handleMouseOver() {
        if (this.props.pauseOnHover) {
          this.pause();
        }
      };

      Carousel.prototype.handleMouseOut = function handleMouseOut() {
        if (this.isPaused) {
          this.play();
        }
      };

      Carousel.prototype.handlePrev = function handlePrev(e) {
        var index = this.getActiveIndex() - 1;

        if (index < 0) {
          if (!this.props.wrap) {
            return;
          }
          index = _ValidComponentChildren2['default'].count(this.props.children) - 1;
        }

        this.select(index, e, 'prev');
      };

      Carousel.prototype.handleNext = function handleNext(e) {
        var index = this.getActiveIndex() + 1;
        var count = _ValidComponentChildren2['default'].count(this.props.children);

        if (index > count - 1) {
          if (!this.props.wrap) {
            return;
          }
          index = 0;
        }

        this.select(index, e, 'next');
      };

      Carousel.prototype.handleItemAnimateOutEnd = function handleItemAnimateOutEnd() {
        var _this2 = this;

        this.setState({
          previousActiveIndex: null,
          direction: null
        }, function () {
          _this2.waitForNext();

          if (_this2.props.onSlideEnd) {
            _this2.props.onSlideEnd();
          }
        });
      };

      Carousel.prototype.getActiveIndex = function getActiveIndex() {
        var activeIndexProp = this.props.activeIndex;
        return activeIndexProp != null ? activeIndexProp : this.state.activeIndex;
      };

      Carousel.prototype.getDirection = function getDirection(prevIndex, index) {
        if (prevIndex === index) {
          return null;
        }

        return prevIndex > index ? 'prev' : 'next';
      };

      Carousel.prototype.select = function select(index, e, direction) {
        clearTimeout(this.timeout);

        // TODO: Is this necessary? Seems like the only risk is if the component
        // unmounts while handleItemAnimateOutEnd fires.
        if (this.isUnmounted) {
          return;
        }

        var previousActiveIndex = this.getActiveIndex();
        direction = direction || this.getDirection(previousActiveIndex, index);

        var onSelect = this.props.onSelect;

        if (onSelect) {
          if (onSelect.length > 1) {
            // React SyntheticEvents are pooled, so we need to remove this event
            // from the pool to add a custom property. To avoid unnecessarily
            // removing objects from the pool, only do this when the listener
            // actually wants the event.
            if (e) {
              e.persist();
              e.direction = direction;
            } else {
              e = { direction: direction };
            }

            onSelect(index, e);
          } else {
            onSelect(index);
          }
        }

        if (this.props.activeIndex == null && index !== previousActiveIndex) {
          if (this.state.previousActiveIndex != null) {
            // If currently animating don't activate the new index.
            // TODO: look into queueing this canceled call and
            // animating after the current animation has ended.
            return;
          }

          this.setState({
            activeIndex: index,
            previousActiveIndex: previousActiveIndex,
            direction: direction
          });
        }
      };

      Carousel.prototype.waitForNext = function waitForNext() {
        var _props = this.props,
            slide = _props.slide,
            interval = _props.interval,
            activeIndexProp = _props.activeIndex;

        if (!this.isPaused && slide && interval && activeIndexProp == null) {
          this.timeout = setTimeout(this.handleNext, interval);
        }
      };

      // This might be a public API.

      Carousel.prototype.pause = function pause() {
        this.isPaused = true;
        clearTimeout(this.timeout);
      };

      // This might be a public API.

      Carousel.prototype.play = function play() {
        this.isPaused = false;
        this.waitForNext();
      };

      Carousel.prototype.renderIndicators = function renderIndicators(children, activeIndex, bsProps) {
        var _this3 = this;

        var indicators = [];

        _ValidComponentChildren2['default'].forEach(children, function (child, index) {
          indicators.push(_react2['default'].createElement('li', {
            key: index,
            className: index === activeIndex ? 'active' : null,
            onClick: function onClick(e) {
              return _this3.select(index, e);
            }
          }),

          // Force whitespace between indicator elements. Bootstrap requires
          // this for correct spacing of elements.
          ' ');
        });

        return _react2['default'].createElement(
          'ol',
          { className: (0, _bootstrapUtils.prefix)(bsProps, 'indicators') },
          indicators
        );
      };

      Carousel.prototype.renderControls = function renderControls(properties) {
        var wrap = properties.wrap,
            children = properties.children,
            activeIndex = properties.activeIndex,
            prevIcon = properties.prevIcon,
            nextIcon = properties.nextIcon,
            bsProps = properties.bsProps,
            prevLabel = properties.prevLabel,
            nextLabel = properties.nextLabel;

        var controlClassName = (0, _bootstrapUtils.prefix)(bsProps, 'control');
        var count = _ValidComponentChildren2['default'].count(children);

        return [(wrap || activeIndex !== 0) && _react2['default'].createElement(
          _SafeAnchor2['default'],
          {
            key: 'prev',
            className: (0, _classnames2['default'])(controlClassName, 'left'),
            onClick: this.handlePrev
          },
          prevIcon,
          prevLabel && _react2['default'].createElement(
            'span',
            { className: 'sr-only' },
            prevLabel
          )
        ), (wrap || activeIndex !== count - 1) && _react2['default'].createElement(
          _SafeAnchor2['default'],
          {
            key: 'next',
            className: (0, _classnames2['default'])(controlClassName, 'right'),
            onClick: this.handleNext
          },
          nextIcon,
          nextLabel && _react2['default'].createElement(
            'span',
            { className: 'sr-only' },
            nextLabel
          )
        )];
      };

      Carousel.prototype.render = function render() {
        var _this4 = this;

        var _props2 = this.props,
            slide = _props2.slide,
            indicators = _props2.indicators,
            controls = _props2.controls,
            wrap = _props2.wrap,
            prevIcon = _props2.prevIcon,
            prevLabel = _props2.prevLabel,
            nextIcon = _props2.nextIcon,
            nextLabel = _props2.nextLabel,
            className = _props2.className,
            children = _props2.children,
            props = (0, _objectWithoutProperties3['default'])(_props2, ['slide', 'indicators', 'controls', 'wrap', 'prevIcon', 'prevLabel', 'nextIcon', 'nextLabel', 'className', 'children']);
        var _state = this.state,
            previousActiveIndex = _state.previousActiveIndex,
            direction = _state.direction;

        var _splitBsPropsAndOmit = (0, _bootstrapUtils.splitBsPropsAndOmit)(props, ['interval', 'pauseOnHover', 'onSelect', 'onSlideEnd', 'activeIndex', // Accessed via this.getActiveIndex().
        'defaultActiveIndex', 'direction']),
            bsProps = _splitBsPropsAndOmit[0],
            elementProps = _splitBsPropsAndOmit[1];

        var activeIndex = this.getActiveIndex();

        var classes = (0, _extends3['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), {
          slide: slide
        });

        return _react2['default'].createElement(
          'div',
          (0, _extends3['default'])({}, elementProps, {
            className: (0, _classnames2['default'])(className, classes),
            onMouseOver: this.handleMouseOver,
            onMouseOut: this.handleMouseOut
          }),
          indicators && this.renderIndicators(children, activeIndex, bsProps),
          _react2['default'].createElement(
            'div',
            { className: (0, _bootstrapUtils.prefix)(bsProps, 'inner') },
            _ValidComponentChildren2['default'].map(children, function (child, index) {
              var active = index === activeIndex;
              var previousActive = slide && index === previousActiveIndex;

              return (0, _react.cloneElement)(child, {
                active: active,
                index: index,
                animateOut: previousActive,
                animateIn: active && previousActiveIndex != null && slide,
                direction: direction,
                onAnimateOutEnd: previousActive ? _this4.handleItemAnimateOutEnd : null
              });
            })
          ),
          controls && this.renderControls({
            wrap: wrap,
            children: children,
            activeIndex: activeIndex,
            prevIcon: prevIcon,
            prevLabel: prevLabel,
            nextIcon: nextIcon,
            nextLabel: nextLabel,
            bsProps: bsProps
          })
        );
      };

      return Carousel;
    }(_react2['default'].Component);

    Carousel.propTypes = propTypes;
    Carousel.defaultProps = defaultProps;

    Carousel.Caption = _CarouselCaption2['default'];
    Carousel.Item = _CarouselItem2['default'];

    exports['default'] = (0, _bootstrapUtils.bsClass)('carousel', Carousel);
    module.exports = exports['default'];

    },{"./CarouselCaption":19,"./CarouselItem":20,"./Glyphicon":36,"./SafeAnchor":84,"./utils/ValidComponentChildren":100,"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],19:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      componentClass: _elementType2['default']
    };

    var defaultProps = {
      componentClass: 'div'
    };

    var CarouselCaption = function (_React$Component) {
      (0, _inherits3['default'])(CarouselCaption, _React$Component);

      function CarouselCaption() {
        (0, _classCallCheck3['default'])(this, CarouselCaption);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      CarouselCaption.prototype.render = function render() {
        var _props = this.props,
            Component = _props.componentClass,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['componentClass', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement(Component, (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return CarouselCaption;
    }(_react2['default'].Component);

    CarouselCaption.propTypes = propTypes;
    CarouselCaption.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('carousel-caption', CarouselCaption);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255}],20:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _reactDom = require('react-dom');

    var _reactDom2 = _interopRequireDefault(_reactDom);

    var _TransitionEvents = require('./utils/TransitionEvents');

    var _TransitionEvents2 = _interopRequireDefault(_TransitionEvents);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    // TODO: This should use a timeout instead of TransitionEvents, or else just
    // not wait until transition end to trigger continuing animations.

    var propTypes = {
      direction: _react2['default'].PropTypes.oneOf(['prev', 'next']),
      onAnimateOutEnd: _react2['default'].PropTypes.func,
      active: _react2['default'].PropTypes.bool,
      animateIn: _react2['default'].PropTypes.bool,
      animateOut: _react2['default'].PropTypes.bool,
      index: _react2['default'].PropTypes.number
    };

    var defaultProps = {
      active: false,
      animateIn: false,
      animateOut: false
    };

    var CarouselItem = function (_React$Component) {
      (0, _inherits3['default'])(CarouselItem, _React$Component);

      function CarouselItem(props, context) {
        (0, _classCallCheck3['default'])(this, CarouselItem);

        var _this = (0, _possibleConstructorReturn3['default'])(this, _React$Component.call(this, props, context));

        _this.handleAnimateOutEnd = _this.handleAnimateOutEnd.bind(_this);

        _this.state = {
          direction: null
        };

        _this.isUnmounted = false;
        return _this;
      }

      CarouselItem.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
        if (this.props.active !== nextProps.active) {
          this.setState({ direction: null });
        }
      };

      CarouselItem.prototype.componentDidUpdate = function componentDidUpdate(prevProps) {
        var _this2 = this;

        var active = this.props.active;

        var prevActive = prevProps.active;

        if (!active && prevActive) {
          _TransitionEvents2['default'].addEndEventListener(_reactDom2['default'].findDOMNode(this), this.handleAnimateOutEnd);
        }

        if (active !== prevActive) {
          setTimeout(function () {
            return _this2.startAnimation();
          }, 20);
        }
      };

      CarouselItem.prototype.componentWillUnmount = function componentWillUnmount() {
        this.isUnmounted = true;
      };

      CarouselItem.prototype.handleAnimateOutEnd = function handleAnimateOutEnd() {
        if (this.isUnmounted) {
          return;
        }

        if (this.props.onAnimateOutEnd) {
          this.props.onAnimateOutEnd(this.props.index);
        }
      };

      CarouselItem.prototype.startAnimation = function startAnimation() {
        if (this.isUnmounted) {
          return;
        }

        this.setState({
          direction: this.props.direction === 'prev' ? 'right' : 'left'
        });
      };

      CarouselItem.prototype.render = function render() {
        var _props = this.props,
            direction = _props.direction,
            active = _props.active,
            animateIn = _props.animateIn,
            animateOut = _props.animateOut,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['direction', 'active', 'animateIn', 'animateOut', 'className']);

        delete props.onAnimateOutEnd;
        delete props.index;

        var classes = {
          item: true,
          active: active && !animateIn || animateOut
        };
        if (direction && active && animateIn) {
          classes[direction] = true;
        }
        if (this.state.direction && (animateIn || animateOut)) {
          classes[this.state.direction] = true;
        }

        return _react2['default'].createElement('div', (0, _extends3['default'])({}, props, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return CarouselItem;
    }(_react2['default'].Component);

    CarouselItem.propTypes = propTypes;
    CarouselItem.defaultProps = defaultProps;

    exports['default'] = CarouselItem;
    module.exports = exports['default'];

    },{"./utils/TransitionEvents":99,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-dom":262}],21:[function(require,module,exports){
    (function (process){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _warning = require('warning');

    var _warning2 = _interopRequireDefault(_warning);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      inline: _react2['default'].PropTypes.bool,
      disabled: _react2['default'].PropTypes.bool,
      /**
       * Only valid if `inline` is not set.
       */
      validationState: _react2['default'].PropTypes.oneOf(['success', 'warning', 'error', null]),
      /**
       * Attaches a ref to the `<input>` element. Only functions can be used here.
       *
       * ```js
       * <Checkbox inputRef={ref => { this.input = ref; }} />
       * ```
       */
      inputRef: _react2['default'].PropTypes.func
    };

    var defaultProps = {
      inline: false,
      disabled: false
    };

    var Checkbox = function (_React$Component) {
      (0, _inherits3['default'])(Checkbox, _React$Component);

      function Checkbox() {
        (0, _classCallCheck3['default'])(this, Checkbox);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Checkbox.prototype.render = function render() {
        var _props = this.props,
            inline = _props.inline,
            disabled = _props.disabled,
            validationState = _props.validationState,
            inputRef = _props.inputRef,
            className = _props.className,
            style = _props.style,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['inline', 'disabled', 'validationState', 'inputRef', 'className', 'style', 'children']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var input = _react2['default'].createElement('input', (0, _extends3['default'])({}, elementProps, {
          ref: inputRef,
          type: 'checkbox',
          disabled: disabled
        }));

        if (inline) {
          var _classes2;

          var _classes = (_classes2 = {}, _classes2[(0, _bootstrapUtils.prefix)(bsProps, 'inline')] = true, _classes2.disabled = disabled, _classes2);

          // Use a warning here instead of in propTypes to get better-looking
          // generated documentation.
          process.env.NODE_ENV !== 'production' ? (0, _warning2['default'])(!validationState, '`validationState` is ignored on `<Checkbox inline>`. To display ' + 'validation state on an inline checkbox, set `validationState` on a ' + 'parent `<FormGroup>` or other element instead.') : void 0;

          return _react2['default'].createElement(
            'label',
            { className: (0, _classnames2['default'])(className, _classes), style: style },
            input,
            children
          );
        }

        var classes = (0, _extends3['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), {
          disabled: disabled
        });
        if (validationState) {
          classes['has-' + validationState] = true;
        }

        return _react2['default'].createElement(
          'div',
          { className: (0, _classnames2['default'])(className, classes), style: style },
          _react2['default'].createElement(
            'label',
            null,
            input,
            children
          )
        );
      };

      return Checkbox;
    }(_react2['default'].Component);

    Checkbox.propTypes = propTypes;
    Checkbox.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('checkbox', Checkbox);
    module.exports = exports['default'];

    }).call(this,require('_process'))
    },{"./utils/bootstrapUtils":101,"_process":728,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"warning":261}],22:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _capitalize = require('./utils/capitalize');

    var _capitalize2 = _interopRequireDefault(_capitalize);

    var _StyleConfig = require('./utils/StyleConfig');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      componentClass: _elementType2['default'],

      /**
       * Apply clearfix
       *
       * on Extra small devices Phones
       *
       * adds class `visible-xs-block`
       */
      visibleXsBlock: _react2['default'].PropTypes.bool,
      /**
       * Apply clearfix
       *
       * on Small devices Tablets
       *
       * adds class `visible-sm-block`
       */
      visibleSmBlock: _react2['default'].PropTypes.bool,
      /**
       * Apply clearfix
       *
       * on Medium devices Desktops
       *
       * adds class `visible-md-block`
       */
      visibleMdBlock: _react2['default'].PropTypes.bool,
      /**
       * Apply clearfix
       *
       * on Large devices Desktops
       *
       * adds class `visible-lg-block`
       */
      visibleLgBlock: _react2['default'].PropTypes.bool
    };

    var defaultProps = {
      componentClass: 'div'
    };

    var Clearfix = function (_React$Component) {
      (0, _inherits3['default'])(Clearfix, _React$Component);

      function Clearfix() {
        (0, _classCallCheck3['default'])(this, Clearfix);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Clearfix.prototype.render = function render() {
        var _props = this.props,
            Component = _props.componentClass,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['componentClass', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        _StyleConfig.DEVICE_SIZES.forEach(function (size) {
          var propName = 'visible' + (0, _capitalize2['default'])(size) + 'Block';
          if (elementProps[propName]) {
            classes['visible-' + size + '-block'] = true;
          }

          delete elementProps[propName];
        });

        return _react2['default'].createElement(Component, (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return Clearfix;
    }(_react2['default'].Component);

    Clearfix.propTypes = propTypes;
    Clearfix.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('clearfix', Clearfix);
    module.exports = exports['default'];

    },{"./utils/StyleConfig":98,"./utils/bootstrapUtils":101,"./utils/capitalize":102,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255}],23:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _StyleConfig = require('./utils/StyleConfig');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      componentClass: _elementType2['default'],

      /**
       * The number of columns you wish to span
       *
       * for Extra small devices Phones (<768px)
       *
       * class-prefix `col-xs-`
       */
      xs: _react2['default'].PropTypes.number,
      /**
       * The number of columns you wish to span
       *
       * for Small devices Tablets (≥768px)
       *
       * class-prefix `col-sm-`
       */
      sm: _react2['default'].PropTypes.number,
      /**
       * The number of columns you wish to span
       *
       * for Medium devices Desktops (≥992px)
       *
       * class-prefix `col-md-`
       */
      md: _react2['default'].PropTypes.number,
      /**
       * The number of columns you wish to span
       *
       * for Large devices Desktops (≥1200px)
       *
       * class-prefix `col-lg-`
       */
      lg: _react2['default'].PropTypes.number,
      /**
       * Hide column
       *
       * on Extra small devices Phones
       *
       * adds class `hidden-xs`
       */
      xsHidden: _react2['default'].PropTypes.bool,
      /**
       * Hide column
       *
       * on Small devices Tablets
       *
       * adds class `hidden-sm`
       */
      smHidden: _react2['default'].PropTypes.bool,
      /**
       * Hide column
       *
       * on Medium devices Desktops
       *
       * adds class `hidden-md`
       */
      mdHidden: _react2['default'].PropTypes.bool,
      /**
       * Hide column
       *
       * on Large devices Desktops
       *
       * adds class `hidden-lg`
       */
      lgHidden: _react2['default'].PropTypes.bool,
      /**
       * Move columns to the right
       *
       * for Extra small devices Phones
       *
       * class-prefix `col-xs-offset-`
       */
      xsOffset: _react2['default'].PropTypes.number,
      /**
       * Move columns to the right
       *
       * for Small devices Tablets
       *
       * class-prefix `col-sm-offset-`
       */
      smOffset: _react2['default'].PropTypes.number,
      /**
       * Move columns to the right
       *
       * for Medium devices Desktops
       *
       * class-prefix `col-md-offset-`
       */
      mdOffset: _react2['default'].PropTypes.number,
      /**
       * Move columns to the right
       *
       * for Large devices Desktops
       *
       * class-prefix `col-lg-offset-`
       */
      lgOffset: _react2['default'].PropTypes.number,
      /**
       * Change the order of grid columns to the right
       *
       * for Extra small devices Phones
       *
       * class-prefix `col-xs-push-`
       */
      xsPush: _react2['default'].PropTypes.number,
      /**
       * Change the order of grid columns to the right
       *
       * for Small devices Tablets
       *
       * class-prefix `col-sm-push-`
       */
      smPush: _react2['default'].PropTypes.number,
      /**
       * Change the order of grid columns to the right
       *
       * for Medium devices Desktops
       *
       * class-prefix `col-md-push-`
       */
      mdPush: _react2['default'].PropTypes.number,
      /**
       * Change the order of grid columns to the right
       *
       * for Large devices Desktops
       *
       * class-prefix `col-lg-push-`
       */
      lgPush: _react2['default'].PropTypes.number,
      /**
       * Change the order of grid columns to the left
       *
       * for Extra small devices Phones
       *
       * class-prefix `col-xs-pull-`
       */
      xsPull: _react2['default'].PropTypes.number,
      /**
       * Change the order of grid columns to the left
       *
       * for Small devices Tablets
       *
       * class-prefix `col-sm-pull-`
       */
      smPull: _react2['default'].PropTypes.number,
      /**
       * Change the order of grid columns to the left
       *
       * for Medium devices Desktops
       *
       * class-prefix `col-md-pull-`
       */
      mdPull: _react2['default'].PropTypes.number,
      /**
       * Change the order of grid columns to the left
       *
       * for Large devices Desktops
       *
       * class-prefix `col-lg-pull-`
       */
      lgPull: _react2['default'].PropTypes.number
    };

    var defaultProps = {
      componentClass: 'div'
    };

    var Col = function (_React$Component) {
      (0, _inherits3['default'])(Col, _React$Component);

      function Col() {
        (0, _classCallCheck3['default'])(this, Col);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Col.prototype.render = function render() {
        var _props = this.props,
            Component = _props.componentClass,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['componentClass', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = [];

        _StyleConfig.DEVICE_SIZES.forEach(function (size) {
          function popProp(propSuffix, modifier) {
            var propName = '' + size + propSuffix;
            var propValue = elementProps[propName];

            if (propValue != null) {
              classes.push((0, _bootstrapUtils.prefix)(bsProps, '' + size + modifier + '-' + propValue));
            }

            delete elementProps[propName];
          }

          popProp('', '');
          popProp('Offset', '-offset');
          popProp('Push', '-push');
          popProp('Pull', '-pull');

          var hiddenPropName = size + 'Hidden';
          if (elementProps[hiddenPropName]) {
            classes.push('hidden-' + size);
          }
          delete elementProps[hiddenPropName];
        });

        return _react2['default'].createElement(Component, (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return Col;
    }(_react2['default'].Component);

    Col.propTypes = propTypes;
    Col.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('col', Col);
    module.exports = exports['default'];

    },{"./utils/StyleConfig":98,"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255}],24:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _style = require('dom-helpers/style');

    var _style2 = _interopRequireDefault(_style);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _Transition = require('react-overlays/lib/Transition');

    var _Transition2 = _interopRequireDefault(_Transition);

    var _capitalize = require('./utils/capitalize');

    var _capitalize2 = _interopRequireDefault(_capitalize);

    var _createChainedFunction = require('./utils/createChainedFunction');

    var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var MARGINS = {
      height: ['marginTop', 'marginBottom'],
      width: ['marginLeft', 'marginRight']
    };

    // reading a dimension prop will cause the browser to recalculate,
    // which will let our animations work
    function triggerBrowserReflow(node) {
      node.offsetHeight; // eslint-disable-line no-unused-expressions
    }

    function getDimensionValue(dimension, elem) {
      var value = elem['offset' + (0, _capitalize2['default'])(dimension)];
      var margins = MARGINS[dimension];

      return value + parseInt((0, _style2['default'])(elem, margins[0]), 10) + parseInt((0, _style2['default'])(elem, margins[1]), 10);
    }

    var propTypes = {
      /**
       * Show the component; triggers the expand or collapse animation
       */
      'in': _react2['default'].PropTypes.bool,

      /**
       * Unmount the component (remove it from the DOM) when it is collapsed
       */
      unmountOnExit: _react2['default'].PropTypes.bool,

      /**
       * Run the expand animation when the component mounts, if it is initially
       * shown
       */
      transitionAppear: _react2['default'].PropTypes.bool,

      /**
       * Duration of the collapse animation in milliseconds, to ensure that
       * finishing callbacks are fired even if the original browser transition end
       * events are canceled
       */
      timeout: _react2['default'].PropTypes.number,

      /**
       * Callback fired before the component expands
       */
      onEnter: _react2['default'].PropTypes.func,
      /**
       * Callback fired after the component starts to expand
       */
      onEntering: _react2['default'].PropTypes.func,
      /**
       * Callback fired after the component has expanded
       */
      onEntered: _react2['default'].PropTypes.func,
      /**
       * Callback fired before the component collapses
       */
      onExit: _react2['default'].PropTypes.func,
      /**
       * Callback fired after the component starts to collapse
       */
      onExiting: _react2['default'].PropTypes.func,
      /**
       * Callback fired after the component has collapsed
       */
      onExited: _react2['default'].PropTypes.func,

      /**
       * The dimension used when collapsing, or a function that returns the
       * dimension
       *
       * _Note: Bootstrap only partially supports 'width'!
       * You will need to supply your own CSS animation for the `.width` CSS class._
       */
      dimension: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.oneOf(['height', 'width']), _react2['default'].PropTypes.func]),

      /**
       * Function that returns the height or width of the animating DOM node
       *
       * Allows for providing some custom logic for how much the Collapse component
       * should animate in its specified dimension. Called with the current
       * dimension prop value and the DOM node.
       */
      getDimensionValue: _react2['default'].PropTypes.func,

      /**
       * ARIA role of collapsible element
       */
      role: _react2['default'].PropTypes.string
    };

    var defaultProps = {
      'in': false,
      timeout: 300,
      unmountOnExit: false,
      transitionAppear: false,

      dimension: 'height',
      getDimensionValue: getDimensionValue
    };

    var Collapse = function (_React$Component) {
      (0, _inherits3['default'])(Collapse, _React$Component);

      function Collapse(props, context) {
        (0, _classCallCheck3['default'])(this, Collapse);

        var _this = (0, _possibleConstructorReturn3['default'])(this, _React$Component.call(this, props, context));

        _this.handleEnter = _this.handleEnter.bind(_this);
        _this.handleEntering = _this.handleEntering.bind(_this);
        _this.handleEntered = _this.handleEntered.bind(_this);
        _this.handleExit = _this.handleExit.bind(_this);
        _this.handleExiting = _this.handleExiting.bind(_this);
        return _this;
      }

      /* -- Expanding -- */

      Collapse.prototype.handleEnter = function handleEnter(elem) {
        var dimension = this._dimension();
        elem.style[dimension] = '0';
      };

      Collapse.prototype.handleEntering = function handleEntering(elem) {
        var dimension = this._dimension();
        elem.style[dimension] = this._getScrollDimensionValue(elem, dimension);
      };

      Collapse.prototype.handleEntered = function handleEntered(elem) {
        var dimension = this._dimension();
        elem.style[dimension] = null;
      };

      /* -- Collapsing -- */

      Collapse.prototype.handleExit = function handleExit(elem) {
        var dimension = this._dimension();
        elem.style[dimension] = this.props.getDimensionValue(dimension, elem) + 'px';
        triggerBrowserReflow(elem);
      };

      Collapse.prototype.handleExiting = function handleExiting(elem) {
        var dimension = this._dimension();
        elem.style[dimension] = '0';
      };

      Collapse.prototype._dimension = function _dimension() {
        return typeof this.props.dimension === 'function' ? this.props.dimension() : this.props.dimension;
      };

      // for testing

      Collapse.prototype._getScrollDimensionValue = function _getScrollDimensionValue(elem, dimension) {
        return elem['scroll' + (0, _capitalize2['default'])(dimension)] + 'px';
      };

      Collapse.prototype.render = function render() {
        var _props = this.props,
            onEnter = _props.onEnter,
            onEntering = _props.onEntering,
            onEntered = _props.onEntered,
            onExit = _props.onExit,
            onExiting = _props.onExiting,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['onEnter', 'onEntering', 'onEntered', 'onExit', 'onExiting', 'className']);

        delete props.dimension;
        delete props.getDimensionValue;

        var handleEnter = (0, _createChainedFunction2['default'])(this.handleEnter, onEnter);
        var handleEntering = (0, _createChainedFunction2['default'])(this.handleEntering, onEntering);
        var handleEntered = (0, _createChainedFunction2['default'])(this.handleEntered, onEntered);
        var handleExit = (0, _createChainedFunction2['default'])(this.handleExit, onExit);
        var handleExiting = (0, _createChainedFunction2['default'])(this.handleExiting, onExiting);

        var classes = {
          width: this._dimension() === 'width'
        };

        return _react2['default'].createElement(_Transition2['default'], (0, _extends3['default'])({}, props, {
          'aria-expanded': props.role ? props['in'] : null,
          className: (0, _classnames2['default'])(className, classes),
          exitedClassName: 'collapse',
          exitingClassName: 'collapsing',
          enteredClassName: 'collapse in',
          enteringClassName: 'collapsing',
          onEnter: handleEnter,
          onEntering: handleEntering,
          onEntered: handleEntered,
          onExit: handleExit,
          onExiting: handleExiting
        }));
      };

      return Collapse;
    }(_react2['default'].Component);

    Collapse.propTypes = propTypes;
    Collapse.defaultProps = defaultProps;

    exports['default'] = Collapse;
    module.exports = exports['default'];

    },{"./utils/capitalize":102,"./utils/createChainedFunction":103,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"dom-helpers/style":227,"react":618,"react-overlays/lib/Transition":245}],25:[function(require,module,exports){
    (function (process){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _warning = require('warning');

    var _warning2 = _interopRequireDefault(_warning);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      /**
       * Uses `controlId` from `<FormGroup>` if not explicitly specified.
       */
      htmlFor: _react2['default'].PropTypes.string,
      srOnly: _react2['default'].PropTypes.bool
    };

    var defaultProps = {
      srOnly: false
    };

    var contextTypes = {
      $bs_formGroup: _react2['default'].PropTypes.object
    };

    var ControlLabel = function (_React$Component) {
      (0, _inherits3['default'])(ControlLabel, _React$Component);

      function ControlLabel() {
        (0, _classCallCheck3['default'])(this, ControlLabel);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      ControlLabel.prototype.render = function render() {
        var formGroup = this.context.$bs_formGroup;
        var controlId = formGroup && formGroup.controlId;

        var _props = this.props,
            _props$htmlFor = _props.htmlFor,
            htmlFor = _props$htmlFor === undefined ? controlId : _props$htmlFor,
            srOnly = _props.srOnly,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['htmlFor', 'srOnly', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        process.env.NODE_ENV !== 'production' ? (0, _warning2['default'])(controlId == null || htmlFor === controlId, '`controlId` is ignored on `<ControlLabel>` when `htmlFor` is specified.') : void 0;

        var classes = (0, _extends3['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), {
          'sr-only': srOnly
        });

        return _react2['default'].createElement('label', (0, _extends3['default'])({}, elementProps, {
          htmlFor: htmlFor,
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return ControlLabel;
    }(_react2['default'].Component);

    ControlLabel.propTypes = propTypes;
    ControlLabel.defaultProps = defaultProps;
    ControlLabel.contextTypes = contextTypes;

    exports['default'] = (0, _bootstrapUtils.bsClass)('control-label', ControlLabel);
    module.exports = exports['default'];

    }).call(this,require('_process'))
    },{"./utils/bootstrapUtils":101,"_process":728,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"warning":261}],26:[function(require,module,exports){
    (function (process){
    'use strict';

    exports.__esModule = true;

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _activeElement = require('dom-helpers/activeElement');

    var _activeElement2 = _interopRequireDefault(_activeElement);

    var _contains = require('dom-helpers/query/contains');

    var _contains2 = _interopRequireDefault(_contains);

    var _keycode = require('keycode');

    var _keycode2 = _interopRequireDefault(_keycode);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _reactDom = require('react-dom');

    var _reactDom2 = _interopRequireDefault(_reactDom);

    var _all = require('react-prop-types/lib/all');

    var _all2 = _interopRequireDefault(_all);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _isRequiredForA11y = require('react-prop-types/lib/isRequiredForA11y');

    var _isRequiredForA11y2 = _interopRequireDefault(_isRequiredForA11y);

    var _uncontrollable = require('uncontrollable');

    var _uncontrollable2 = _interopRequireDefault(_uncontrollable);

    var _warning = require('warning');

    var _warning2 = _interopRequireDefault(_warning);

    var _ButtonGroup = require('./ButtonGroup');

    var _ButtonGroup2 = _interopRequireDefault(_ButtonGroup);

    var _DropdownMenu = require('./DropdownMenu');

    var _DropdownMenu2 = _interopRequireDefault(_DropdownMenu);

    var _DropdownToggle = require('./DropdownToggle');

    var _DropdownToggle2 = _interopRequireDefault(_DropdownToggle);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _createChainedFunction = require('./utils/createChainedFunction');

    var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);

    var _PropTypes = require('./utils/PropTypes');

    var _ValidComponentChildren = require('./utils/ValidComponentChildren');

    var _ValidComponentChildren2 = _interopRequireDefault(_ValidComponentChildren);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var TOGGLE_ROLE = _DropdownToggle2['default'].defaultProps.bsRole;
    var MENU_ROLE = _DropdownMenu2['default'].defaultProps.bsRole;

    var propTypes = {
      /**
       * The menu will open above the dropdown button, instead of below it.
       */
      dropup: _react2['default'].PropTypes.bool,

      /**
       * An html id attribute, necessary for assistive technologies, such as screen readers.
       * @type {string|number}
       * @required
       */
      id: (0, _isRequiredForA11y2['default'])(_react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number])),

      componentClass: _elementType2['default'],

      /**
       * The children of a Dropdown may be a `<Dropdown.Toggle>` or a `<Dropdown.Menu>`.
       * @type {node}
       */
      children: (0, _all2['default'])((0, _PropTypes.requiredRoles)(TOGGLE_ROLE, MENU_ROLE), (0, _PropTypes.exclusiveRoles)(MENU_ROLE)),

      /**
       * Whether or not component is disabled.
       */
      disabled: _react2['default'].PropTypes.bool,

      /**
       * Align the menu to the right side of the Dropdown toggle
       */
      pullRight: _react2['default'].PropTypes.bool,

      /**
       * Whether or not the Dropdown is visible.
       *
       * @controllable onToggle
       */
      open: _react2['default'].PropTypes.bool,

      /**
       * A callback fired when the Dropdown closes.
       */
      onClose: _react2['default'].PropTypes.func,

      /**
       * A callback fired when the Dropdown wishes to change visibility. Called with the requested
       * `open` value.
       *
       * ```js
       * function(Boolean isOpen) {}
       * ```
       * @controllable open
       */
      onToggle: _react2['default'].PropTypes.func,

      /**
       * A callback fired when a menu item is selected.
       *
       * ```js
       * (eventKey: any, event: Object) => any
       * ```
       */
      onSelect: _react2['default'].PropTypes.func,

      /**
       * If `'menuitem'`, causes the dropdown to behave like a menu item rather than
       * a menu button.
       */
      role: _react2['default'].PropTypes.string,

      /**
       * Which event when fired outside the component will cause it to be closed
       */
      rootCloseEvent: _react2['default'].PropTypes.oneOf(['click', 'mousedown']),

      /**
       * @private
       */
      onMouseEnter: _react2['default'].PropTypes.func,
      /**
       * @private
       */
      onMouseLeave: _react2['default'].PropTypes.func
    };

    var defaultProps = {
      componentClass: _ButtonGroup2['default']
    };

    var Dropdown = function (_React$Component) {
      (0, _inherits3['default'])(Dropdown, _React$Component);

      function Dropdown(props, context) {
        (0, _classCallCheck3['default'])(this, Dropdown);

        var _this = (0, _possibleConstructorReturn3['default'])(this, _React$Component.call(this, props, context));

        _this.handleClick = _this.handleClick.bind(_this);
        _this.handleKeyDown = _this.handleKeyDown.bind(_this);
        _this.handleClose = _this.handleClose.bind(_this);

        _this._focusInDropdown = false;
        _this.lastOpenEventType = null;
        return _this;
      }

      Dropdown.prototype.componentDidMount = function componentDidMount() {
        this.focusNextOnOpen();
      };

      Dropdown.prototype.componentWillUpdate = function componentWillUpdate(nextProps) {
        if (!nextProps.open && this.props.open) {
          this._focusInDropdown = (0, _contains2['default'])(_reactDom2['default'].findDOMNode(this.menu), (0, _activeElement2['default'])(document));
        }
      };

      Dropdown.prototype.componentDidUpdate = function componentDidUpdate(prevProps) {
        var open = this.props.open;

        var prevOpen = prevProps.open;

        if (open && !prevOpen) {
          this.focusNextOnOpen();
        }

        if (!open && prevOpen) {
          // if focus hasn't already moved from the menu lets return it
          // to the toggle
          if (this._focusInDropdown) {
            this._focusInDropdown = false;
            this.focus();
          }
        }
      };

      Dropdown.prototype.handleClick = function handleClick() {
        if (this.props.disabled) {
          return;
        }

        this.toggleOpen('click');
      };

      Dropdown.prototype.handleKeyDown = function handleKeyDown(event) {
        if (this.props.disabled) {
          return;
        }

        switch (event.keyCode) {
          case _keycode2['default'].codes.down:
            if (!this.props.open) {
              this.toggleOpen('keydown');
            } else if (this.menu.focusNext) {
              this.menu.focusNext();
            }
            event.preventDefault();
            break;
          case _keycode2['default'].codes.esc:
          case _keycode2['default'].codes.tab:
            this.handleClose(event);
            break;
          default:
        }
      };

      Dropdown.prototype.toggleOpen = function toggleOpen(eventType) {
        var open = !this.props.open;

        if (open) {
          this.lastOpenEventType = eventType;
        }

        if (this.props.onToggle) {
          this.props.onToggle(open);
        }
      };

      Dropdown.prototype.handleClose = function handleClose() {
        if (!this.props.open) {
          return;
        }

        this.toggleOpen(null);
      };

      Dropdown.prototype.focusNextOnOpen = function focusNextOnOpen() {
        var menu = this.menu;

        if (!menu.focusNext) {
          return;
        }

        if (this.lastOpenEventType === 'keydown' || this.props.role === 'menuitem') {
          menu.focusNext();
        }
      };

      Dropdown.prototype.focus = function focus() {
        var toggle = _reactDom2['default'].findDOMNode(this.toggle);

        if (toggle && toggle.focus) {
          toggle.focus();
        }
      };

      Dropdown.prototype.renderToggle = function renderToggle(child, props) {
        var _this2 = this;

        var ref = function ref(c) {
          _this2.toggle = c;
        };

        if (typeof child.ref === 'string') {
          process.env.NODE_ENV !== 'production' ? (0, _warning2['default'])(false, 'String refs are not supported on `<Dropdown.Toggle>` components. ' + 'To apply a ref to the component use the callback signature:\n\n ' + 'https://facebook.github.io/react/docs/more-about-refs.html#the-ref-callback-attribute') : void 0;
        } else {
          ref = (0, _createChainedFunction2['default'])(child.ref, ref);
        }

        return (0, _react.cloneElement)(child, (0, _extends3['default'])({}, props, {
          ref: ref,
          bsClass: (0, _bootstrapUtils.prefix)(props, 'toggle'),
          onClick: (0, _createChainedFunction2['default'])(child.props.onClick, this.handleClick),
          onKeyDown: (0, _createChainedFunction2['default'])(child.props.onKeyDown, this.handleKeyDown)
        }));
      };

      Dropdown.prototype.renderMenu = function renderMenu(child, _ref) {
        var _this3 = this;

        var id = _ref.id,
            onClose = _ref.onClose,
            onSelect = _ref.onSelect,
            rootCloseEvent = _ref.rootCloseEvent,
            props = (0, _objectWithoutProperties3['default'])(_ref, ['id', 'onClose', 'onSelect', 'rootCloseEvent']);

        var ref = function ref(c) {
          _this3.menu = c;
        };

        if (typeof child.ref === 'string') {
          process.env.NODE_ENV !== 'production' ? (0, _warning2['default'])(false, 'String refs are not supported on `<Dropdown.Menu>` components. ' + 'To apply a ref to the component use the callback signature:\n\n ' + 'https://facebook.github.io/react/docs/more-about-refs.html#the-ref-callback-attribute') : void 0;
        } else {
          ref = (0, _createChainedFunction2['default'])(child.ref, ref);
        }

        return (0, _react.cloneElement)(child, (0, _extends3['default'])({}, props, {
          ref: ref,
          labelledBy: id,
          bsClass: (0, _bootstrapUtils.prefix)(props, 'menu'),
          onClose: (0, _createChainedFunction2['default'])(child.props.onClose, onClose, this.handleClose),
          onSelect: (0, _createChainedFunction2['default'])(child.props.onSelect, onSelect, this.handleClose),
          rootCloseEvent: rootCloseEvent
        }));
      };

      Dropdown.prototype.render = function render() {
        var _classes,
            _this4 = this;

        var _props = this.props,
            Component = _props.componentClass,
            id = _props.id,
            dropup = _props.dropup,
            disabled = _props.disabled,
            pullRight = _props.pullRight,
            open = _props.open,
            onClose = _props.onClose,
            onSelect = _props.onSelect,
            role = _props.role,
            bsClass = _props.bsClass,
            className = _props.className,
            rootCloseEvent = _props.rootCloseEvent,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['componentClass', 'id', 'dropup', 'disabled', 'pullRight', 'open', 'onClose', 'onSelect', 'role', 'bsClass', 'className', 'rootCloseEvent', 'children']);

        delete props.onToggle;

        var classes = (_classes = {}, _classes[bsClass] = true, _classes.open = open, _classes.disabled = disabled, _classes);

        if (dropup) {
          classes[bsClass] = false;
          classes.dropup = true;
        }

        // This intentionally forwards bsSize and bsStyle (if set) to the
        // underlying component, to allow it to render size and style variants.

        return _react2['default'].createElement(
          Component,
          (0, _extends3['default'])({}, props, {
            className: (0, _classnames2['default'])(className, classes)
          }),
          _ValidComponentChildren2['default'].map(children, function (child) {
            switch (child.props.bsRole) {
              case TOGGLE_ROLE:
                return _this4.renderToggle(child, {
                  id: id, disabled: disabled, open: open, role: role, bsClass: bsClass
                });
              case MENU_ROLE:
                return _this4.renderMenu(child, {
                  id: id, open: open, pullRight: pullRight, bsClass: bsClass, onClose: onClose, onSelect: onSelect, rootCloseEvent: rootCloseEvent
                });
              default:
                return child;
            }
          })
        );
      };

      return Dropdown;
    }(_react2['default'].Component);

    Dropdown.propTypes = propTypes;
    Dropdown.defaultProps = defaultProps;

    (0, _bootstrapUtils.bsClass)('dropdown', Dropdown);

    var UncontrolledDropdown = (0, _uncontrollable2['default'])(Dropdown, { open: 'onToggle' });

    UncontrolledDropdown.Toggle = _DropdownToggle2['default'];
    UncontrolledDropdown.Menu = _DropdownMenu2['default'];

    exports['default'] = UncontrolledDropdown;
    module.exports = exports['default'];

    }).call(this,require('_process'))
    },{"./ButtonGroup":16,"./DropdownMenu":28,"./DropdownToggle":29,"./utils/PropTypes":97,"./utils/ValidComponentChildren":100,"./utils/bootstrapUtils":101,"./utils/createChainedFunction":103,"_process":728,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"dom-helpers/activeElement":208,"dom-helpers/query/contains":218,"keycode":238,"react":618,"react-dom":262,"react-prop-types/lib/all":253,"react-prop-types/lib/elementType":255,"react-prop-types/lib/isRequiredForA11y":256,"uncontrollable":259,"warning":261}],27:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _Dropdown = require('./Dropdown');

    var _Dropdown2 = _interopRequireDefault(_Dropdown);

    var _splitComponentProps2 = require('./utils/splitComponentProps');

    var _splitComponentProps3 = _interopRequireDefault(_splitComponentProps2);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = (0, _extends3['default'])({}, _Dropdown2['default'].propTypes, {

      // Toggle props.
      bsStyle: _react2['default'].PropTypes.string,
      bsSize: _react2['default'].PropTypes.string,
      title: _react2['default'].PropTypes.node.isRequired,
      noCaret: _react2['default'].PropTypes.bool,

      // Override generated docs from <Dropdown>.
      /**
       * @private
       */
      children: _react2['default'].PropTypes.node
    });

    var DropdownButton = function (_React$Component) {
      (0, _inherits3['default'])(DropdownButton, _React$Component);

      function DropdownButton() {
        (0, _classCallCheck3['default'])(this, DropdownButton);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      DropdownButton.prototype.render = function render() {
        var _props = this.props,
            bsSize = _props.bsSize,
            bsStyle = _props.bsStyle,
            title = _props.title,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['bsSize', 'bsStyle', 'title', 'children']);

        var _splitComponentProps = (0, _splitComponentProps3['default'])(props, _Dropdown2['default'].ControlledComponent),
            dropdownProps = _splitComponentProps[0],
            toggleProps = _splitComponentProps[1];

        return _react2['default'].createElement(
          _Dropdown2['default'],
          (0, _extends3['default'])({}, dropdownProps, {
            bsSize: bsSize,
            bsStyle: bsStyle
          }),
          _react2['default'].createElement(
            _Dropdown2['default'].Toggle,
            (0, _extends3['default'])({}, toggleProps, {
              bsSize: bsSize,
              bsStyle: bsStyle
            }),
            title
          ),
          _react2['default'].createElement(
            _Dropdown2['default'].Menu,
            null,
            children
          )
        );
      };

      return DropdownButton;
    }(_react2['default'].Component);

    DropdownButton.propTypes = propTypes;

    exports['default'] = DropdownButton;
    module.exports = exports['default'];

    },{"./Dropdown":26,"./utils/splitComponentProps":106,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"react":618}],28:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends3 = require('babel-runtime/helpers/extends');

    var _extends4 = _interopRequireDefault(_extends3);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _from = require('babel-runtime/core-js/array/from');

    var _from2 = _interopRequireDefault(_from);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _keycode = require('keycode');

    var _keycode2 = _interopRequireDefault(_keycode);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _reactDom = require('react-dom');

    var _reactDom2 = _interopRequireDefault(_reactDom);

    var _RootCloseWrapper = require('react-overlays/lib/RootCloseWrapper');

    var _RootCloseWrapper2 = _interopRequireDefault(_RootCloseWrapper);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _createChainedFunction = require('./utils/createChainedFunction');

    var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);

    var _ValidComponentChildren = require('./utils/ValidComponentChildren');

    var _ValidComponentChildren2 = _interopRequireDefault(_ValidComponentChildren);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      open: _react2['default'].PropTypes.bool,
      pullRight: _react2['default'].PropTypes.bool,
      onClose: _react2['default'].PropTypes.func,
      labelledBy: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number]),
      onSelect: _react2['default'].PropTypes.func,
      rootCloseEvent: _react2['default'].PropTypes.oneOf(['click', 'mousedown'])
    };

    var defaultProps = {
      bsRole: 'menu',
      pullRight: false
    };

    var DropdownMenu = function (_React$Component) {
      (0, _inherits3['default'])(DropdownMenu, _React$Component);

      function DropdownMenu(props) {
        (0, _classCallCheck3['default'])(this, DropdownMenu);

        var _this = (0, _possibleConstructorReturn3['default'])(this, _React$Component.call(this, props));

        _this.handleKeyDown = _this.handleKeyDown.bind(_this);
        return _this;
      }

      DropdownMenu.prototype.handleKeyDown = function handleKeyDown(event) {
        switch (event.keyCode) {
          case _keycode2['default'].codes.down:
            this.focusNext();
            event.preventDefault();
            break;
          case _keycode2['default'].codes.up:
            this.focusPrevious();
            event.preventDefault();
            break;
          case _keycode2['default'].codes.esc:
          case _keycode2['default'].codes.tab:
            this.props.onClose(event);
            break;
          default:
        }
      };

      DropdownMenu.prototype.getItemsAndActiveIndex = function getItemsAndActiveIndex() {
        var items = this.getFocusableMenuItems();
        var activeIndex = items.indexOf(document.activeElement);

        return { items: items, activeIndex: activeIndex };
      };

      DropdownMenu.prototype.getFocusableMenuItems = function getFocusableMenuItems() {
        var node = _reactDom2['default'].findDOMNode(this);
        if (!node) {
          return [];
        }

        return (0, _from2['default'])(node.querySelectorAll('[tabIndex="-1"]'));
      };

      DropdownMenu.prototype.focusNext = function focusNext() {
        var _getItemsAndActiveInd = this.getItemsAndActiveIndex(),
            items = _getItemsAndActiveInd.items,
            activeIndex = _getItemsAndActiveInd.activeIndex;

        if (items.length === 0) {
          return;
        }

        var nextIndex = activeIndex === items.length - 1 ? 0 : activeIndex + 1;
        items[nextIndex].focus();
      };

      DropdownMenu.prototype.focusPrevious = function focusPrevious() {
        var _getItemsAndActiveInd2 = this.getItemsAndActiveIndex(),
            items = _getItemsAndActiveInd2.items,
            activeIndex = _getItemsAndActiveInd2.activeIndex;

        if (items.length === 0) {
          return;
        }

        var prevIndex = activeIndex === 0 ? items.length - 1 : activeIndex - 1;
        items[prevIndex].focus();
      };

      DropdownMenu.prototype.render = function render() {
        var _extends2,
            _this2 = this;

        var _props = this.props,
            open = _props.open,
            pullRight = _props.pullRight,
            onClose = _props.onClose,
            labelledBy = _props.labelledBy,
            onSelect = _props.onSelect,
            className = _props.className,
            rootCloseEvent = _props.rootCloseEvent,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['open', 'pullRight', 'onClose', 'labelledBy', 'onSelect', 'className', 'rootCloseEvent', 'children']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _extends4['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), (_extends2 = {}, _extends2[(0, _bootstrapUtils.prefix)(bsProps, 'right')] = pullRight, _extends2));

        return _react2['default'].createElement(
          _RootCloseWrapper2['default'],
          {
            disabled: !open,
            onRootClose: onClose,
            event: rootCloseEvent
          },
          _react2['default'].createElement(
            'ul',
            (0, _extends4['default'])({}, elementProps, {
              role: 'menu',
              className: (0, _classnames2['default'])(className, classes),
              'aria-labelledby': labelledBy
            }),
            _ValidComponentChildren2['default'].map(children, function (child) {
              return _react2['default'].cloneElement(child, {
                onKeyDown: (0, _createChainedFunction2['default'])(child.props.onKeyDown, _this2.handleKeyDown),
                onSelect: (0, _createChainedFunction2['default'])(child.props.onSelect, onSelect)
              });
            })
          )
        );
      };

      return DropdownMenu;
    }(_react2['default'].Component);

    DropdownMenu.propTypes = propTypes;
    DropdownMenu.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('dropdown-menu', DropdownMenu);
    module.exports = exports['default'];

    },{"./utils/ValidComponentChildren":100,"./utils/bootstrapUtils":101,"./utils/createChainedFunction":103,"babel-runtime/core-js/array/from":107,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"keycode":238,"react":618,"react-dom":262,"react-overlays/lib/RootCloseWrapper":244}],29:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _Button = require('./Button');

    var _Button2 = _interopRequireDefault(_Button);

    var _SafeAnchor = require('./SafeAnchor');

    var _SafeAnchor2 = _interopRequireDefault(_SafeAnchor);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      noCaret: _react2['default'].PropTypes.bool,
      open: _react2['default'].PropTypes.bool,
      title: _react2['default'].PropTypes.string,
      useAnchor: _react2['default'].PropTypes.bool
    };

    var defaultProps = {
      open: false,
      useAnchor: false,
      bsRole: 'toggle'
    };

    var DropdownToggle = function (_React$Component) {
      (0, _inherits3['default'])(DropdownToggle, _React$Component);

      function DropdownToggle() {
        (0, _classCallCheck3['default'])(this, DropdownToggle);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      DropdownToggle.prototype.render = function render() {
        var _props = this.props,
            noCaret = _props.noCaret,
            open = _props.open,
            useAnchor = _props.useAnchor,
            bsClass = _props.bsClass,
            className = _props.className,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['noCaret', 'open', 'useAnchor', 'bsClass', 'className', 'children']);

        delete props.bsRole;

        var Component = useAnchor ? _SafeAnchor2['default'] : _Button2['default'];
        var useCaret = !noCaret;

        // This intentionally forwards bsSize and bsStyle (if set) to the
        // underlying component, to allow it to render size and style variants.

        // FIXME: Should this really fall back to `title` as children?

        return _react2['default'].createElement(
          Component,
          (0, _extends3['default'])({}, props, {
            role: 'button',
            className: (0, _classnames2['default'])(className, bsClass),
            'aria-haspopup': true,
            'aria-expanded': open
          }),
          children || props.title,
          useCaret && ' ',
          useCaret && _react2['default'].createElement('span', { className: 'caret' })
        );
      };

      return DropdownToggle;
    }(_react2['default'].Component);

    DropdownToggle.propTypes = propTypes;
    DropdownToggle.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('dropdown-toggle', DropdownToggle);
    module.exports = exports['default'];

    },{"./Button":15,"./SafeAnchor":84,"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],30:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _Transition = require('react-overlays/lib/Transition');

    var _Transition2 = _interopRequireDefault(_Transition);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      /**
       * Show the component; triggers the fade in or fade out animation
       */
      'in': _react2['default'].PropTypes.bool,

      /**
       * Unmount the component (remove it from the DOM) when it is faded out
       */
      unmountOnExit: _react2['default'].PropTypes.bool,

      /**
       * Run the fade in animation when the component mounts, if it is initially
       * shown
       */
      transitionAppear: _react2['default'].PropTypes.bool,

      /**
       * Duration of the fade animation in milliseconds, to ensure that finishing
       * callbacks are fired even if the original browser transition end events are
       * canceled
       */
      timeout: _react2['default'].PropTypes.number,

      /**
       * Callback fired before the component fades in
       */
      onEnter: _react2['default'].PropTypes.func,
      /**
       * Callback fired after the component starts to fade in
       */
      onEntering: _react2['default'].PropTypes.func,
      /**
       * Callback fired after the has component faded in
       */
      onEntered: _react2['default'].PropTypes.func,
      /**
       * Callback fired before the component fades out
       */
      onExit: _react2['default'].PropTypes.func,
      /**
       * Callback fired after the component starts to fade out
       */
      onExiting: _react2['default'].PropTypes.func,
      /**
       * Callback fired after the component has faded out
       */
      onExited: _react2['default'].PropTypes.func
    };

    var defaultProps = {
      'in': false,
      timeout: 300,
      unmountOnExit: false,
      transitionAppear: false
    };

    var Fade = function (_React$Component) {
      (0, _inherits3['default'])(Fade, _React$Component);

      function Fade() {
        (0, _classCallCheck3['default'])(this, Fade);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Fade.prototype.render = function render() {
        return _react2['default'].createElement(_Transition2['default'], (0, _extends3['default'])({}, this.props, {
          className: (0, _classnames2['default'])(this.props.className, 'fade'),
          enteredClassName: 'in',
          enteringClassName: 'in'
        }));
      };

      return Fade;
    }(_react2['default'].Component);

    Fade.propTypes = propTypes;
    Fade.defaultProps = defaultProps;

    exports['default'] = Fade;
    module.exports = exports['default'];

    },{"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-overlays/lib/Transition":245}],31:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      horizontal: _react2['default'].PropTypes.bool,
      inline: _react2['default'].PropTypes.bool,
      componentClass: _elementType2['default']
    };

    var defaultProps = {
      horizontal: false,
      inline: false,
      componentClass: 'form'
    };

    var Form = function (_React$Component) {
      (0, _inherits3['default'])(Form, _React$Component);

      function Form() {
        (0, _classCallCheck3['default'])(this, Form);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Form.prototype.render = function render() {
        var _props = this.props,
            horizontal = _props.horizontal,
            inline = _props.inline,
            Component = _props.componentClass,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['horizontal', 'inline', 'componentClass', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = [];
        if (horizontal) {
          classes.push((0, _bootstrapUtils.prefix)(bsProps, 'horizontal'));
        }
        if (inline) {
          classes.push((0, _bootstrapUtils.prefix)(bsProps, 'inline'));
        }

        return _react2['default'].createElement(Component, (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return Form;
    }(_react2['default'].Component);

    Form.propTypes = propTypes;
    Form.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('form', Form);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255}],32:[function(require,module,exports){
    (function (process){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _warning = require('warning');

    var _warning2 = _interopRequireDefault(_warning);

    var _FormControlFeedback = require('./FormControlFeedback');

    var _FormControlFeedback2 = _interopRequireDefault(_FormControlFeedback);

    var _FormControlStatic = require('./FormControlStatic');

    var _FormControlStatic2 = _interopRequireDefault(_FormControlStatic);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      componentClass: _elementType2['default'],
      /**
       * Only relevant if `componentClass` is `'input'`.
       */
      type: _react2['default'].PropTypes.string,
      /**
       * Uses `controlId` from `<FormGroup>` if not explicitly specified.
       */
      id: _react2['default'].PropTypes.string,
      /**
       * Attaches a ref to the `<input>` element. Only functions can be used here.
       *
       * ```js
       * <FormControl inputRef={ref => { this.input = ref; }} />
       * ```
       */
      inputRef: _react2['default'].PropTypes.func
    };

    var defaultProps = {
      componentClass: 'input'
    };

    var contextTypes = {
      $bs_formGroup: _react2['default'].PropTypes.object
    };

    var FormControl = function (_React$Component) {
      (0, _inherits3['default'])(FormControl, _React$Component);

      function FormControl() {
        (0, _classCallCheck3['default'])(this, FormControl);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      FormControl.prototype.render = function render() {
        var formGroup = this.context.$bs_formGroup;
        var controlId = formGroup && formGroup.controlId;

        var _props = this.props,
            Component = _props.componentClass,
            type = _props.type,
            _props$id = _props.id,
            id = _props$id === undefined ? controlId : _props$id,
            inputRef = _props.inputRef,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['componentClass', 'type', 'id', 'inputRef', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        process.env.NODE_ENV !== 'production' ? (0, _warning2['default'])(controlId == null || id === controlId, '`controlId` is ignored on `<FormControl>` when `id` is specified.') : void 0;

        // input[type="file"] should not have .form-control.
        var classes = void 0;
        if (type !== 'file') {
          classes = (0, _bootstrapUtils.getClassSet)(bsProps);
        }

        return _react2['default'].createElement(Component, (0, _extends3['default'])({}, elementProps, {
          type: type,
          id: id,
          ref: inputRef,
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return FormControl;
    }(_react2['default'].Component);

    FormControl.propTypes = propTypes;
    FormControl.defaultProps = defaultProps;
    FormControl.contextTypes = contextTypes;

    FormControl.Feedback = _FormControlFeedback2['default'];
    FormControl.Static = _FormControlStatic2['default'];

    exports['default'] = (0, _bootstrapUtils.bsClass)('form-control', FormControl);
    module.exports = exports['default'];

    }).call(this,require('_process'))
    },{"./FormControlFeedback":33,"./FormControlStatic":34,"./utils/bootstrapUtils":101,"_process":728,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255,"warning":261}],33:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _Glyphicon = require('./Glyphicon');

    var _Glyphicon2 = _interopRequireDefault(_Glyphicon);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var defaultProps = {
      bsRole: 'feedback'
    };

    var contextTypes = {
      $bs_formGroup: _react2['default'].PropTypes.object
    };

    var FormControlFeedback = function (_React$Component) {
      (0, _inherits3['default'])(FormControlFeedback, _React$Component);

      function FormControlFeedback() {
        (0, _classCallCheck3['default'])(this, FormControlFeedback);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      FormControlFeedback.prototype.getGlyph = function getGlyph(validationState) {
        switch (validationState) {
          case 'success':
            return 'ok';
          case 'warning':
            return 'warning-sign';
          case 'error':
            return 'remove';
          default:
            return null;
        }
      };

      FormControlFeedback.prototype.renderDefaultFeedback = function renderDefaultFeedback(formGroup, className, classes, elementProps) {
        var glyph = this.getGlyph(formGroup && formGroup.validationState);
        if (!glyph) {
          return null;
        }

        return _react2['default'].createElement(_Glyphicon2['default'], (0, _extends3['default'])({}, elementProps, {
          glyph: glyph,
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      FormControlFeedback.prototype.render = function render() {
        var _props = this.props,
            className = _props.className,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['className', 'children']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        if (!children) {
          return this.renderDefaultFeedback(this.context.$bs_formGroup, className, classes, elementProps);
        }

        var child = _react2['default'].Children.only(children);
        return _react2['default'].cloneElement(child, (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(child.props.className, className, classes)
        }));
      };

      return FormControlFeedback;
    }(_react2['default'].Component);

    FormControlFeedback.defaultProps = defaultProps;
    FormControlFeedback.contextTypes = contextTypes;

    exports['default'] = (0, _bootstrapUtils.bsClass)('form-control-feedback', FormControlFeedback);
    module.exports = exports['default'];

    },{"./Glyphicon":36,"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],34:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      componentClass: _elementType2['default']
    };

    var defaultProps = {
      componentClass: 'p'
    };

    var FormControlStatic = function (_React$Component) {
      (0, _inherits3['default'])(FormControlStatic, _React$Component);

      function FormControlStatic() {
        (0, _classCallCheck3['default'])(this, FormControlStatic);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      FormControlStatic.prototype.render = function render() {
        var _props = this.props,
            Component = _props.componentClass,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['componentClass', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement(Component, (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return FormControlStatic;
    }(_react2['default'].Component);

    FormControlStatic.propTypes = propTypes;
    FormControlStatic.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('form-control-static', FormControlStatic);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255}],35:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _StyleConfig = require('./utils/StyleConfig');

    var _ValidComponentChildren = require('./utils/ValidComponentChildren');

    var _ValidComponentChildren2 = _interopRequireDefault(_ValidComponentChildren);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      /**
       * Sets `id` on `<FormControl>` and `htmlFor` on `<FormGroup.Label>`.
       */
      controlId: _react2['default'].PropTypes.string,
      validationState: _react2['default'].PropTypes.oneOf(['success', 'warning', 'error', null])
    };

    var childContextTypes = {
      $bs_formGroup: _react2['default'].PropTypes.object.isRequired
    };

    var FormGroup = function (_React$Component) {
      (0, _inherits3['default'])(FormGroup, _React$Component);

      function FormGroup() {
        (0, _classCallCheck3['default'])(this, FormGroup);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      FormGroup.prototype.getChildContext = function getChildContext() {
        var _props = this.props,
            controlId = _props.controlId,
            validationState = _props.validationState;

        return {
          $bs_formGroup: {
            controlId: controlId,
            validationState: validationState
          }
        };
      };

      FormGroup.prototype.hasFeedback = function hasFeedback(children) {
        var _this2 = this;

        return _ValidComponentChildren2['default'].some(children, function (child) {
          return child.props.bsRole === 'feedback' || child.props.children && _this2.hasFeedback(child.props.children);
        });
      };

      FormGroup.prototype.render = function render() {
        var _props2 = this.props,
            validationState = _props2.validationState,
            className = _props2.className,
            children = _props2.children,
            props = (0, _objectWithoutProperties3['default'])(_props2, ['validationState', 'className', 'children']);

        var _splitBsPropsAndOmit = (0, _bootstrapUtils.splitBsPropsAndOmit)(props, ['controlId']),
            bsProps = _splitBsPropsAndOmit[0],
            elementProps = _splitBsPropsAndOmit[1];

        var classes = (0, _extends3['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), {
          'has-feedback': this.hasFeedback(children)
        });
        if (validationState) {
          classes['has-' + validationState] = true;
        }

        return _react2['default'].createElement(
          'div',
          (0, _extends3['default'])({}, elementProps, {
            className: (0, _classnames2['default'])(className, classes)
          }),
          children
        );
      };

      return FormGroup;
    }(_react2['default'].Component);

    FormGroup.propTypes = propTypes;
    FormGroup.childContextTypes = childContextTypes;

    exports['default'] = (0, _bootstrapUtils.bsClass)('form-group', (0, _bootstrapUtils.bsSizes)([_StyleConfig.Size.LARGE, _StyleConfig.Size.SMALL], FormGroup));
    module.exports = exports['default'];

    },{"./utils/StyleConfig":98,"./utils/ValidComponentChildren":100,"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],36:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends3 = require('babel-runtime/helpers/extends');

    var _extends4 = _interopRequireDefault(_extends3);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      /**
       * An icon name. See e.g. http://getbootstrap.com/components/#glyphicons
       */
      glyph: _react2['default'].PropTypes.string.isRequired
    };

    var Glyphicon = function (_React$Component) {
      (0, _inherits3['default'])(Glyphicon, _React$Component);

      function Glyphicon() {
        (0, _classCallCheck3['default'])(this, Glyphicon);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Glyphicon.prototype.render = function render() {
        var _extends2;

        var _props = this.props,
            glyph = _props.glyph,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['glyph', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _extends4['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), (_extends2 = {}, _extends2[(0, _bootstrapUtils.prefix)(bsProps, glyph)] = true, _extends2));

        return _react2['default'].createElement('span', (0, _extends4['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return Glyphicon;
    }(_react2['default'].Component);

    Glyphicon.propTypes = propTypes;

    exports['default'] = (0, _bootstrapUtils.bsClass)('glyphicon', Glyphicon);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],37:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      /**
       * Turn any fixed-width grid layout into a full-width layout by this property.
       *
       * Adds `container-fluid` class.
       */
      fluid: _react2['default'].PropTypes.bool,
      /**
       * You can use a custom element for this component
       */
      componentClass: _elementType2['default']
    };

    var defaultProps = {
      componentClass: 'div',
      fluid: false
    };

    var Grid = function (_React$Component) {
      (0, _inherits3['default'])(Grid, _React$Component);

      function Grid() {
        (0, _classCallCheck3['default'])(this, Grid);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Grid.prototype.render = function render() {
        var _props = this.props,
            fluid = _props.fluid,
            Component = _props.componentClass,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['fluid', 'componentClass', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.prefix)(bsProps, fluid && 'fluid');

        return _react2['default'].createElement(Component, (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return Grid;
    }(_react2['default'].Component);

    Grid.propTypes = propTypes;
    Grid.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('container', Grid);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255}],38:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var HelpBlock = function (_React$Component) {
      (0, _inherits3['default'])(HelpBlock, _React$Component);

      function HelpBlock() {
        (0, _classCallCheck3['default'])(this, HelpBlock);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      HelpBlock.prototype.render = function render() {
        var _props = this.props,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement('span', (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return HelpBlock;
    }(_react2['default'].Component);

    exports['default'] = (0, _bootstrapUtils.bsClass)('help-block', HelpBlock);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],39:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      /**
       * Sets image as responsive image
       */
      responsive: _react2['default'].PropTypes.bool,

      /**
       * Sets image shape as rounded
       */
      rounded: _react2['default'].PropTypes.bool,

      /**
       * Sets image shape as circle
       */
      circle: _react2['default'].PropTypes.bool,

      /**
       * Sets image shape as thumbnail
       */
      thumbnail: _react2['default'].PropTypes.bool
    };

    var defaultProps = {
      responsive: false,
      rounded: false,
      circle: false,
      thumbnail: false
    };

    var Image = function (_React$Component) {
      (0, _inherits3['default'])(Image, _React$Component);

      function Image() {
        (0, _classCallCheck3['default'])(this, Image);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Image.prototype.render = function render() {
        var _classes;

        var _props = this.props,
            responsive = _props.responsive,
            rounded = _props.rounded,
            circle = _props.circle,
            thumbnail = _props.thumbnail,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['responsive', 'rounded', 'circle', 'thumbnail', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (_classes = {}, _classes[(0, _bootstrapUtils.prefix)(bsProps, 'responsive')] = responsive, _classes[(0, _bootstrapUtils.prefix)(bsProps, 'rounded')] = rounded, _classes[(0, _bootstrapUtils.prefix)(bsProps, 'circle')] = circle, _classes[(0, _bootstrapUtils.prefix)(bsProps, 'thumbnail')] = thumbnail, _classes);

        return _react2['default'].createElement('img', (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return Image;
    }(_react2['default'].Component);

    Image.propTypes = propTypes;
    Image.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('img', Image);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],40:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _InputGroupAddon = require('./InputGroupAddon');

    var _InputGroupAddon2 = _interopRequireDefault(_InputGroupAddon);

    var _InputGroupButton = require('./InputGroupButton');

    var _InputGroupButton2 = _interopRequireDefault(_InputGroupButton);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _StyleConfig = require('./utils/StyleConfig');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var InputGroup = function (_React$Component) {
      (0, _inherits3['default'])(InputGroup, _React$Component);

      function InputGroup() {
        (0, _classCallCheck3['default'])(this, InputGroup);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      InputGroup.prototype.render = function render() {
        var _props = this.props,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement('span', (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return InputGroup;
    }(_react2['default'].Component);

    InputGroup.Addon = _InputGroupAddon2['default'];
    InputGroup.Button = _InputGroupButton2['default'];

    exports['default'] = (0, _bootstrapUtils.bsClass)('input-group', (0, _bootstrapUtils.bsSizes)([_StyleConfig.Size.LARGE, _StyleConfig.Size.SMALL], InputGroup));
    module.exports = exports['default'];

    },{"./InputGroupAddon":41,"./InputGroupButton":42,"./utils/StyleConfig":98,"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],41:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var InputGroupAddon = function (_React$Component) {
      (0, _inherits3['default'])(InputGroupAddon, _React$Component);

      function InputGroupAddon() {
        (0, _classCallCheck3['default'])(this, InputGroupAddon);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      InputGroupAddon.prototype.render = function render() {
        var _props = this.props,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement('span', (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return InputGroupAddon;
    }(_react2['default'].Component);

    exports['default'] = (0, _bootstrapUtils.bsClass)('input-group-addon', InputGroupAddon);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],42:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var InputGroupButton = function (_React$Component) {
      (0, _inherits3['default'])(InputGroupButton, _React$Component);

      function InputGroupButton() {
        (0, _classCallCheck3['default'])(this, InputGroupButton);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      InputGroupButton.prototype.render = function render() {
        var _props = this.props,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement('span', (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return InputGroupButton;
    }(_react2['default'].Component);

    exports['default'] = (0, _bootstrapUtils.bsClass)('input-group-btn', InputGroupButton);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],43:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      componentClass: _elementType2['default']
    };

    var defaultProps = {
      componentClass: 'div'
    };

    var Jumbotron = function (_React$Component) {
      (0, _inherits3['default'])(Jumbotron, _React$Component);

      function Jumbotron() {
        (0, _classCallCheck3['default'])(this, Jumbotron);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Jumbotron.prototype.render = function render() {
        var _props = this.props,
            Component = _props.componentClass,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['componentClass', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement(Component, (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return Jumbotron;
    }(_react2['default'].Component);

    Jumbotron.propTypes = propTypes;
    Jumbotron.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('jumbotron', Jumbotron);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255}],44:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _values = require('babel-runtime/core-js/object/values');

    var _values2 = _interopRequireDefault(_values);

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _StyleConfig = require('./utils/StyleConfig');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var Label = function (_React$Component) {
      (0, _inherits3['default'])(Label, _React$Component);

      function Label() {
        (0, _classCallCheck3['default'])(this, Label);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Label.prototype.hasContent = function hasContent(children) {
        var result = false;

        _react2['default'].Children.forEach(children, function (child) {
          if (result) {
            return;
          }

          if (child || child === 0) {
            result = true;
          }
        });

        return result;
      };

      Label.prototype.render = function render() {
        var _props = this.props,
            className = _props.className,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['className', 'children']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _extends3['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), {

          // Hack for collapsing on IE8.
          hidden: !this.hasContent(children)
        });

        return _react2['default'].createElement(
          'span',
          (0, _extends3['default'])({}, elementProps, {
            className: (0, _classnames2['default'])(className, classes)
          }),
          children
        );
      };

      return Label;
    }(_react2['default'].Component);

    exports['default'] = (0, _bootstrapUtils.bsClass)('label', (0, _bootstrapUtils.bsStyles)([].concat((0, _values2['default'])(_StyleConfig.State), [_StyleConfig.Style.DEFAULT, _StyleConfig.Style.PRIMARY]), _StyleConfig.Style.DEFAULT, Label));
    module.exports = exports['default'];

    },{"./utils/StyleConfig":98,"./utils/bootstrapUtils":101,"babel-runtime/core-js/object/values":112,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],45:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _ListGroupItem = require('./ListGroupItem');

    var _ListGroupItem2 = _interopRequireDefault(_ListGroupItem);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _ValidComponentChildren = require('./utils/ValidComponentChildren');

    var _ValidComponentChildren2 = _interopRequireDefault(_ValidComponentChildren);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      /**
       * You can use a custom element type for this component.
       *
       * If not specified, it will be treated as `'li'` if every child is a
       * non-actionable `<ListGroupItem>`, and `'div'` otherwise.
       */
      componentClass: _elementType2['default']
    };

    function getDefaultComponent(children) {
      if (!children) {
        // FIXME: This is the old behavior. Is this right?
        return 'div';
      }

      if (_ValidComponentChildren2['default'].some(children, function (child) {
        return child.type !== _ListGroupItem2['default'] || child.props.href || child.props.onClick;
      })) {
        return 'div';
      }

      return 'ul';
    }

    var ListGroup = function (_React$Component) {
      (0, _inherits3['default'])(ListGroup, _React$Component);

      function ListGroup() {
        (0, _classCallCheck3['default'])(this, ListGroup);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      ListGroup.prototype.render = function render() {
        var _props = this.props,
            children = _props.children,
            _props$componentClass = _props.componentClass,
            Component = _props$componentClass === undefined ? getDefaultComponent(children) : _props$componentClass,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['children', 'componentClass', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        var useListItem = Component === 'ul' && _ValidComponentChildren2['default'].every(children, function (child) {
          return child.type === _ListGroupItem2['default'];
        });

        return _react2['default'].createElement(
          Component,
          (0, _extends3['default'])({}, elementProps, {
            className: (0, _classnames2['default'])(className, classes)
          }),
          useListItem ? _ValidComponentChildren2['default'].map(children, function (child) {
            return (0, _react.cloneElement)(child, { listItem: true });
          }) : children
        );
      };

      return ListGroup;
    }(_react2['default'].Component);

    ListGroup.propTypes = propTypes;

    exports['default'] = (0, _bootstrapUtils.bsClass)('list-group', ListGroup);
    module.exports = exports['default'];

    },{"./ListGroupItem":46,"./utils/ValidComponentChildren":100,"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255}],46:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _values = require('babel-runtime/core-js/object/values');

    var _values2 = _interopRequireDefault(_values);

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _StyleConfig = require('./utils/StyleConfig');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      active: _react2['default'].PropTypes.any,
      disabled: _react2['default'].PropTypes.any,
      header: _react2['default'].PropTypes.node,
      listItem: _react2['default'].PropTypes.bool,
      onClick: _react2['default'].PropTypes.func,
      href: _react2['default'].PropTypes.string,
      type: _react2['default'].PropTypes.string
    };

    var defaultProps = {
      listItem: false
    };

    var ListGroupItem = function (_React$Component) {
      (0, _inherits3['default'])(ListGroupItem, _React$Component);

      function ListGroupItem() {
        (0, _classCallCheck3['default'])(this, ListGroupItem);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      ListGroupItem.prototype.renderHeader = function renderHeader(header, headingClassName) {
        if (_react2['default'].isValidElement(header)) {
          return (0, _react.cloneElement)(header, {
            className: (0, _classnames2['default'])(header.props.className, headingClassName)
          });
        }

        return _react2['default'].createElement(
          'h4',
          { className: headingClassName },
          header
        );
      };

      ListGroupItem.prototype.render = function render() {
        var _props = this.props,
            active = _props.active,
            disabled = _props.disabled,
            className = _props.className,
            header = _props.header,
            listItem = _props.listItem,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['active', 'disabled', 'className', 'header', 'listItem', 'children']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _extends3['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), {
          active: active,
          disabled: disabled
        });

        var Component = void 0;

        if (elementProps.href) {
          Component = 'a';
        } else if (elementProps.onClick) {
          Component = 'button';
          elementProps.type = elementProps.type || 'button';
        } else if (listItem) {
          Component = 'li';
        } else {
          Component = 'span';
        }

        elementProps.className = (0, _classnames2['default'])(className, classes);

        // TODO: Deprecate `header` prop.
        if (header) {
          return _react2['default'].createElement(
            Component,
            elementProps,
            this.renderHeader(header, (0, _bootstrapUtils.prefix)(bsProps, 'heading')),
            _react2['default'].createElement(
              'p',
              { className: (0, _bootstrapUtils.prefix)(bsProps, 'text') },
              children
            )
          );
        }

        return _react2['default'].createElement(
          Component,
          elementProps,
          children
        );
      };

      return ListGroupItem;
    }(_react2['default'].Component);

    ListGroupItem.propTypes = propTypes;
    ListGroupItem.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('list-group-item', (0, _bootstrapUtils.bsStyles)((0, _values2['default'])(_StyleConfig.State), ListGroupItem));
    module.exports = exports['default'];

    },{"./utils/StyleConfig":98,"./utils/bootstrapUtils":101,"babel-runtime/core-js/object/values":112,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],47:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _MediaBody = require('./MediaBody');

    var _MediaBody2 = _interopRequireDefault(_MediaBody);

    var _MediaHeading = require('./MediaHeading');

    var _MediaHeading2 = _interopRequireDefault(_MediaHeading);

    var _MediaLeft = require('./MediaLeft');

    var _MediaLeft2 = _interopRequireDefault(_MediaLeft);

    var _MediaList = require('./MediaList');

    var _MediaList2 = _interopRequireDefault(_MediaList);

    var _MediaListItem = require('./MediaListItem');

    var _MediaListItem2 = _interopRequireDefault(_MediaListItem);

    var _MediaRight = require('./MediaRight');

    var _MediaRight2 = _interopRequireDefault(_MediaRight);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      componentClass: _elementType2['default']
    };

    var defaultProps = {
      componentClass: 'div'
    };

    var Media = function (_React$Component) {
      (0, _inherits3['default'])(Media, _React$Component);

      function Media() {
        (0, _classCallCheck3['default'])(this, Media);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Media.prototype.render = function render() {
        var _props = this.props,
            Component = _props.componentClass,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['componentClass', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement(Component, (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return Media;
    }(_react2['default'].Component);

    Media.propTypes = propTypes;
    Media.defaultProps = defaultProps;

    Media.Heading = _MediaHeading2['default'];
    Media.Body = _MediaBody2['default'];
    Media.Left = _MediaLeft2['default'];
    Media.Right = _MediaRight2['default'];
    Media.List = _MediaList2['default'];
    Media.ListItem = _MediaListItem2['default'];

    exports['default'] = (0, _bootstrapUtils.bsClass)('media', Media);
    module.exports = exports['default'];

    },{"./MediaBody":48,"./MediaHeading":49,"./MediaLeft":50,"./MediaList":51,"./MediaListItem":52,"./MediaRight":53,"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255}],48:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      componentClass: _elementType2['default']
    };

    var defaultProps = {
      componentClass: 'div'
    };

    var MediaBody = function (_React$Component) {
      (0, _inherits3['default'])(MediaBody, _React$Component);

      function MediaBody() {
        (0, _classCallCheck3['default'])(this, MediaBody);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      MediaBody.prototype.render = function render() {
        var _props = this.props,
            Component = _props.componentClass,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['componentClass', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement(Component, (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return MediaBody;
    }(_react2['default'].Component);

    MediaBody.propTypes = propTypes;
    MediaBody.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('media-body', MediaBody);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255}],49:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      componentClass: _elementType2['default']
    };

    var defaultProps = {
      componentClass: 'h4'
    };

    var MediaHeading = function (_React$Component) {
      (0, _inherits3['default'])(MediaHeading, _React$Component);

      function MediaHeading() {
        (0, _classCallCheck3['default'])(this, MediaHeading);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      MediaHeading.prototype.render = function render() {
        var _props = this.props,
            Component = _props.componentClass,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['componentClass', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement(Component, (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return MediaHeading;
    }(_react2['default'].Component);

    MediaHeading.propTypes = propTypes;
    MediaHeading.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('media-heading', MediaHeading);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255}],50:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _Media = require('./Media');

    var _Media2 = _interopRequireDefault(_Media);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      /**
       * Align the media to the top, middle, or bottom of the media object.
       */
      align: _react2['default'].PropTypes.oneOf(['top', 'middle', 'bottom'])
    };

    var MediaLeft = function (_React$Component) {
      (0, _inherits3['default'])(MediaLeft, _React$Component);

      function MediaLeft() {
        (0, _classCallCheck3['default'])(this, MediaLeft);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      MediaLeft.prototype.render = function render() {
        var _props = this.props,
            align = _props.align,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['align', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        if (align) {
          // The class is e.g. `media-top`, not `media-left-top`.
          classes[(0, _bootstrapUtils.prefix)(_Media2['default'].defaultProps, align)] = true;
        }

        return _react2['default'].createElement('div', (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return MediaLeft;
    }(_react2['default'].Component);

    MediaLeft.propTypes = propTypes;

    exports['default'] = (0, _bootstrapUtils.bsClass)('media-left', MediaLeft);
    module.exports = exports['default'];

    },{"./Media":47,"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],51:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var MediaList = function (_React$Component) {
      (0, _inherits3['default'])(MediaList, _React$Component);

      function MediaList() {
        (0, _classCallCheck3['default'])(this, MediaList);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      MediaList.prototype.render = function render() {
        var _props = this.props,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement('ul', (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return MediaList;
    }(_react2['default'].Component);

    exports['default'] = (0, _bootstrapUtils.bsClass)('media-list', MediaList);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],52:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var MediaListItem = function (_React$Component) {
      (0, _inherits3['default'])(MediaListItem, _React$Component);

      function MediaListItem() {
        (0, _classCallCheck3['default'])(this, MediaListItem);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      MediaListItem.prototype.render = function render() {
        var _props = this.props,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement('li', (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return MediaListItem;
    }(_react2['default'].Component);

    exports['default'] = (0, _bootstrapUtils.bsClass)('media', MediaListItem);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],53:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _Media = require('./Media');

    var _Media2 = _interopRequireDefault(_Media);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      /**
       * Align the media to the top, middle, or bottom of the media object.
       */
      align: _react2['default'].PropTypes.oneOf(['top', 'middle', 'bottom'])
    };

    var MediaRight = function (_React$Component) {
      (0, _inherits3['default'])(MediaRight, _React$Component);

      function MediaRight() {
        (0, _classCallCheck3['default'])(this, MediaRight);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      MediaRight.prototype.render = function render() {
        var _props = this.props,
            align = _props.align,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['align', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        if (align) {
          // The class is e.g. `media-top`, not `media-right-top`.
          classes[(0, _bootstrapUtils.prefix)(_Media2['default'].defaultProps, align)] = true;
        }

        return _react2['default'].createElement('div', (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return MediaRight;
    }(_react2['default'].Component);

    MediaRight.propTypes = propTypes;

    exports['default'] = (0, _bootstrapUtils.bsClass)('media-right', MediaRight);
    module.exports = exports['default'];

    },{"./Media":47,"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],54:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _all = require('react-prop-types/lib/all');

    var _all2 = _interopRequireDefault(_all);

    var _SafeAnchor = require('./SafeAnchor');

    var _SafeAnchor2 = _interopRequireDefault(_SafeAnchor);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _createChainedFunction = require('./utils/createChainedFunction');

    var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      /**
       * Highlight the menu item as active.
       */
      active: _react2['default'].PropTypes.bool,

      /**
       * Disable the menu item, making it unselectable.
       */
      disabled: _react2['default'].PropTypes.bool,

      /**
       * Styles the menu item as a horizontal rule, providing visual separation between
       * groups of menu items.
       */
      divider: (0, _all2['default'])(_react2['default'].PropTypes.bool, function (_ref) {
        var divider = _ref.divider,
            children = _ref.children;
        return divider && children ? new Error('Children will not be rendered for dividers') : null;
      }),

      /**
       * Value passed to the `onSelect` handler, useful for identifying the selected menu item.
       */
      eventKey: _react2['default'].PropTypes.any,

      /**
       * Styles the menu item as a header label, useful for describing a group of menu items.
       */
      header: _react2['default'].PropTypes.bool,

      /**
       * HTML `href` attribute corresponding to `a.href`.
       */
      href: _react2['default'].PropTypes.string,

      /**
       * Callback fired when the menu item is clicked.
       */
      onClick: _react2['default'].PropTypes.func,

      /**
       * Callback fired when the menu item is selected.
       *
       * ```js
       * (eventKey: any, event: Object) => any
       * ```
       */
      onSelect: _react2['default'].PropTypes.func
    };

    var defaultProps = {
      divider: false,
      disabled: false,
      header: false
    };

    var MenuItem = function (_React$Component) {
      (0, _inherits3['default'])(MenuItem, _React$Component);

      function MenuItem(props, context) {
        (0, _classCallCheck3['default'])(this, MenuItem);

        var _this = (0, _possibleConstructorReturn3['default'])(this, _React$Component.call(this, props, context));

        _this.handleClick = _this.handleClick.bind(_this);
        return _this;
      }

      MenuItem.prototype.handleClick = function handleClick(event) {
        var _props = this.props,
            href = _props.href,
            disabled = _props.disabled,
            onSelect = _props.onSelect,
            eventKey = _props.eventKey;

        if (!href || disabled) {
          event.preventDefault();
        }

        if (disabled) {
          return;
        }

        if (onSelect) {
          onSelect(eventKey, event);
        }
      };

      MenuItem.prototype.render = function render() {
        var _props2 = this.props,
            active = _props2.active,
            disabled = _props2.disabled,
            divider = _props2.divider,
            header = _props2.header,
            onClick = _props2.onClick,
            className = _props2.className,
            style = _props2.style,
            props = (0, _objectWithoutProperties3['default'])(_props2, ['active', 'disabled', 'divider', 'header', 'onClick', 'className', 'style']);

        var _splitBsPropsAndOmit = (0, _bootstrapUtils.splitBsPropsAndOmit)(props, ['eventKey', 'onSelect']),
            bsProps = _splitBsPropsAndOmit[0],
            elementProps = _splitBsPropsAndOmit[1];

        if (divider) {
          // Forcibly blank out the children; separators shouldn't render any.
          elementProps.children = undefined;

          return _react2['default'].createElement('li', (0, _extends3['default'])({}, elementProps, {
            role: 'separator',
            className: (0, _classnames2['default'])(className, 'divider'),
            style: style
          }));
        }

        if (header) {
          return _react2['default'].createElement('li', (0, _extends3['default'])({}, elementProps, {
            role: 'heading',
            className: (0, _classnames2['default'])(className, (0, _bootstrapUtils.prefix)(bsProps, 'header')),
            style: style
          }));
        }

        return _react2['default'].createElement(
          'li',
          {
            role: 'presentation',
            className: (0, _classnames2['default'])(className, { active: active, disabled: disabled }),
            style: style
          },
          _react2['default'].createElement(_SafeAnchor2['default'], (0, _extends3['default'])({}, elementProps, {
            role: 'menuitem',
            tabIndex: '-1',
            onClick: (0, _createChainedFunction2['default'])(onClick, this.handleClick)
          }))
        );
      };

      return MenuItem;
    }(_react2['default'].Component);

    MenuItem.propTypes = propTypes;
    MenuItem.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('dropdown', MenuItem);
    module.exports = exports['default'];

    },{"./SafeAnchor":84,"./utils/bootstrapUtils":101,"./utils/createChainedFunction":103,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/all":253}],55:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _events = require('dom-helpers/events');

    var _events2 = _interopRequireDefault(_events);

    var _ownerDocument = require('dom-helpers/ownerDocument');

    var _ownerDocument2 = _interopRequireDefault(_ownerDocument);

    var _inDOM = require('dom-helpers/util/inDOM');

    var _inDOM2 = _interopRequireDefault(_inDOM);

    var _scrollbarSize = require('dom-helpers/util/scrollbarSize');

    var _scrollbarSize2 = _interopRequireDefault(_scrollbarSize);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _reactDom = require('react-dom');

    var _reactDom2 = _interopRequireDefault(_reactDom);

    var _Modal = require('react-overlays/lib/Modal');

    var _Modal2 = _interopRequireDefault(_Modal);

    var _isOverflowing = require('react-overlays/lib/utils/isOverflowing');

    var _isOverflowing2 = _interopRequireDefault(_isOverflowing);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _Fade = require('./Fade');

    var _Fade2 = _interopRequireDefault(_Fade);

    var _ModalBody = require('./ModalBody');

    var _ModalBody2 = _interopRequireDefault(_ModalBody);

    var _ModalDialog = require('./ModalDialog');

    var _ModalDialog2 = _interopRequireDefault(_ModalDialog);

    var _ModalFooter = require('./ModalFooter');

    var _ModalFooter2 = _interopRequireDefault(_ModalFooter);

    var _ModalHeader = require('./ModalHeader');

    var _ModalHeader2 = _interopRequireDefault(_ModalHeader);

    var _ModalTitle = require('./ModalTitle');

    var _ModalTitle2 = _interopRequireDefault(_ModalTitle);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _createChainedFunction = require('./utils/createChainedFunction');

    var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);

    var _splitComponentProps2 = require('./utils/splitComponentProps');

    var _splitComponentProps3 = _interopRequireDefault(_splitComponentProps2);

    var _StyleConfig = require('./utils/StyleConfig');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = (0, _extends3['default'])({}, _Modal2['default'].propTypes, _ModalDialog2['default'].propTypes, {

      /**
       * Include a backdrop component. Specify 'static' for a backdrop that doesn't
       * trigger an "onHide" when clicked.
       */
      backdrop: _react2['default'].PropTypes.oneOf(['static', true, false]),

      /**
       * Close the modal when escape key is pressed
       */
      keyboard: _react2['default'].PropTypes.bool,

      /**
       * Open and close the Modal with a slide and fade animation.
       */
      animation: _react2['default'].PropTypes.bool,

      /**
       * A Component type that provides the modal content Markup. This is a useful
       * prop when you want to use your own styles and markup to create a custom
       * modal component.
       */
      dialogComponentClass: _elementType2['default'],

      /**
       * When `true` The modal will automatically shift focus to itself when it
       * opens, and replace it to the last focused element when it closes.
       * Generally this should never be set to false as it makes the Modal less
       * accessible to assistive technologies, like screen-readers.
       */
      autoFocus: _react2['default'].PropTypes.bool,

      /**
       * When `true` The modal will prevent focus from leaving the Modal while
       * open. Consider leaving the default value here, as it is necessary to make
       * the Modal work well with assistive technologies, such as screen readers.
       */
      enforceFocus: _react2['default'].PropTypes.bool,

      /**
       * When `true` The modal will show itself.
       */
      show: _react2['default'].PropTypes.bool,

      /**
       * A callback fired when the header closeButton or non-static backdrop is
       * clicked. Required if either are specified.
       */
      onHide: _react2['default'].PropTypes.func,

      /**
       * Callback fired before the Modal transitions in
       */
      onEnter: _react2['default'].PropTypes.func,

      /**
       * Callback fired as the Modal begins to transition in
       */
      onEntering: _react2['default'].PropTypes.func,

      /**
       * Callback fired after the Modal finishes transitioning in
       */
      onEntered: _react2['default'].PropTypes.func,

      /**
       * Callback fired right before the Modal transitions out
       */
      onExit: _react2['default'].PropTypes.func,

      /**
       * Callback fired as the Modal begins to transition out
       */
      onExiting: _react2['default'].PropTypes.func,

      /**
       * Callback fired after the Modal finishes transitioning out
       */
      onExited: _react2['default'].PropTypes.func,

      /**
       * @private
       */
      container: _Modal2['default'].propTypes.container
    });

    var defaultProps = (0, _extends3['default'])({}, _Modal2['default'].defaultProps, {
      animation: true,
      dialogComponentClass: _ModalDialog2['default']
    });

    var childContextTypes = {
      $bs_modal: _react2['default'].PropTypes.shape({
        onHide: _react2['default'].PropTypes.func
      })
    };

    var Modal = function (_React$Component) {
      (0, _inherits3['default'])(Modal, _React$Component);

      function Modal(props, context) {
        (0, _classCallCheck3['default'])(this, Modal);

        var _this = (0, _possibleConstructorReturn3['default'])(this, _React$Component.call(this, props, context));

        _this.handleEntering = _this.handleEntering.bind(_this);
        _this.handleExited = _this.handleExited.bind(_this);
        _this.handleWindowResize = _this.handleWindowResize.bind(_this);
        _this.handleDialogClick = _this.handleDialogClick.bind(_this);

        _this.state = {
          style: {}
        };
        return _this;
      }

      Modal.prototype.getChildContext = function getChildContext() {
        return {
          $bs_modal: {
            onHide: this.props.onHide
          }
        };
      };

      Modal.prototype.componentWillUnmount = function componentWillUnmount() {
        // Clean up the listener if we need to.
        this.handleExited();
      };

      Modal.prototype.handleEntering = function handleEntering() {
        // FIXME: This should work even when animation is disabled.
        _events2['default'].on(window, 'resize', this.handleWindowResize);
        this.updateStyle();
      };

      Modal.prototype.handleExited = function handleExited() {
        // FIXME: This should work even when animation is disabled.
        _events2['default'].off(window, 'resize', this.handleWindowResize);
      };

      Modal.prototype.handleWindowResize = function handleWindowResize() {
        this.updateStyle();
      };

      Modal.prototype.handleDialogClick = function handleDialogClick(e) {
        if (e.target !== e.currentTarget) {
          return;
        }

        this.props.onHide();
      };

      Modal.prototype.updateStyle = function updateStyle() {
        if (!_inDOM2['default']) {
          return;
        }

        var dialogNode = this._modal.getDialogElement();
        var dialogHeight = dialogNode.scrollHeight;

        var document = (0, _ownerDocument2['default'])(dialogNode);
        var bodyIsOverflowing = (0, _isOverflowing2['default'])(_reactDom2['default'].findDOMNode(this.props.container || document.body));
        var modalIsOverflowing = dialogHeight > document.documentElement.clientHeight;

        this.setState({
          style: {
            paddingRight: bodyIsOverflowing && !modalIsOverflowing ? (0, _scrollbarSize2['default'])() : undefined,
            paddingLeft: !bodyIsOverflowing && modalIsOverflowing ? (0, _scrollbarSize2['default'])() : undefined
          }
        });
      };

      Modal.prototype.render = function render() {
        var _this2 = this;

        var _props = this.props,
            backdrop = _props.backdrop,
            animation = _props.animation,
            show = _props.show,
            Dialog = _props.dialogComponentClass,
            className = _props.className,
            style = _props.style,
            children = _props.children,
            onEntering = _props.onEntering,
            onExited = _props.onExited,
            props = (0, _objectWithoutProperties3['default'])(_props, ['backdrop', 'animation', 'show', 'dialogComponentClass', 'className', 'style', 'children', 'onEntering', 'onExited']);

        var _splitComponentProps = (0, _splitComponentProps3['default'])(props, _Modal2['default']),
            baseModalProps = _splitComponentProps[0],
            dialogProps = _splitComponentProps[1];

        var inClassName = show && !animation && 'in';

        return _react2['default'].createElement(
          _Modal2['default'],
          (0, _extends3['default'])({}, baseModalProps, {
            ref: function ref(c) {
              _this2._modal = c;
            },
            show: show,
            onEntering: (0, _createChainedFunction2['default'])(onEntering, this.handleEntering),
            onExited: (0, _createChainedFunction2['default'])(onExited, this.handleExited),
            backdrop: backdrop,
            backdropClassName: (0, _classnames2['default'])((0, _bootstrapUtils.prefix)(props, 'backdrop'), inClassName),
            containerClassName: (0, _bootstrapUtils.prefix)(props, 'open'),
            transition: animation ? _Fade2['default'] : undefined,
            dialogTransitionTimeout: Modal.TRANSITION_DURATION,
            backdropTransitionTimeout: Modal.BACKDROP_TRANSITION_DURATION
          }),
          _react2['default'].createElement(
            Dialog,
            (0, _extends3['default'])({}, dialogProps, {
              style: (0, _extends3['default'])({}, this.state.style, style),
              className: (0, _classnames2['default'])(className, inClassName),
              onClick: backdrop === true ? this.handleDialogClick : null
            }),
            children
          )
        );
      };

      return Modal;
    }(_react2['default'].Component);

    Modal.propTypes = propTypes;
    Modal.defaultProps = defaultProps;
    Modal.childContextTypes = childContextTypes;

    Modal.Body = _ModalBody2['default'];
    Modal.Header = _ModalHeader2['default'];
    Modal.Title = _ModalTitle2['default'];
    Modal.Footer = _ModalFooter2['default'];

    Modal.Dialog = _ModalDialog2['default'];

    Modal.TRANSITION_DURATION = 300;
    Modal.BACKDROP_TRANSITION_DURATION = 150;

    exports['default'] = (0, _bootstrapUtils.bsClass)('modal', (0, _bootstrapUtils.bsSizes)([_StyleConfig.Size.LARGE, _StyleConfig.Size.SMALL], Modal));
    module.exports = exports['default'];

    },{"./Fade":30,"./ModalBody":56,"./ModalDialog":57,"./ModalFooter":58,"./ModalHeader":59,"./ModalTitle":60,"./utils/StyleConfig":98,"./utils/bootstrapUtils":101,"./utils/createChainedFunction":103,"./utils/splitComponentProps":106,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"dom-helpers/events":214,"dom-helpers/ownerDocument":217,"dom-helpers/util/inDOM":235,"dom-helpers/util/scrollbarSize":236,"react":618,"react-dom":262,"react-overlays/lib/Modal":239,"react-overlays/lib/utils/isOverflowing":250,"react-prop-types/lib/elementType":255}],56:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      componentClass: _elementType2['default']
    };

    var defaultProps = {
      componentClass: 'div'
    };

    var ModalBody = function (_React$Component) {
      (0, _inherits3['default'])(ModalBody, _React$Component);

      function ModalBody() {
        (0, _classCallCheck3['default'])(this, ModalBody);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      ModalBody.prototype.render = function render() {
        var _props = this.props,
            Component = _props.componentClass,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['componentClass', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement(Component, (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return ModalBody;
    }(_react2['default'].Component);

    ModalBody.propTypes = propTypes;
    ModalBody.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('modal-body', ModalBody);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255}],57:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends3 = require('babel-runtime/helpers/extends');

    var _extends4 = _interopRequireDefault(_extends3);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _StyleConfig = require('./utils/StyleConfig');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      /**
       * A css class to apply to the Modal dialog DOM node.
       */
      dialogClassName: _react2['default'].PropTypes.string
    };

    var ModalDialog = function (_React$Component) {
      (0, _inherits3['default'])(ModalDialog, _React$Component);

      function ModalDialog() {
        (0, _classCallCheck3['default'])(this, ModalDialog);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      ModalDialog.prototype.render = function render() {
        var _extends2;

        var _props = this.props,
            dialogClassName = _props.dialogClassName,
            className = _props.className,
            style = _props.style,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['dialogClassName', 'className', 'style', 'children']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var bsClassName = (0, _bootstrapUtils.prefix)(bsProps);

        var modalStyle = (0, _extends4['default'])({ display: 'block' }, style);

        var dialogClasses = (0, _extends4['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), (_extends2 = {}, _extends2[bsClassName] = false, _extends2[(0, _bootstrapUtils.prefix)(bsProps, 'dialog')] = true, _extends2));

        return _react2['default'].createElement(
          'div',
          (0, _extends4['default'])({}, elementProps, {
            tabIndex: '-1',
            role: 'dialog',
            style: modalStyle,
            className: (0, _classnames2['default'])(className, bsClassName)
          }),
          _react2['default'].createElement(
            'div',
            { className: (0, _classnames2['default'])(dialogClassName, dialogClasses) },
            _react2['default'].createElement(
              'div',
              { className: (0, _bootstrapUtils.prefix)(bsProps, 'content'), role: 'document' },
              children
            )
          )
        );
      };

      return ModalDialog;
    }(_react2['default'].Component);

    ModalDialog.propTypes = propTypes;

    exports['default'] = (0, _bootstrapUtils.bsClass)('modal', (0, _bootstrapUtils.bsSizes)([_StyleConfig.Size.LARGE, _StyleConfig.Size.SMALL], ModalDialog));
    module.exports = exports['default'];

    },{"./utils/StyleConfig":98,"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],58:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      componentClass: _elementType2['default']
    };

    var defaultProps = {
      componentClass: 'div'
    };

    var ModalFooter = function (_React$Component) {
      (0, _inherits3['default'])(ModalFooter, _React$Component);

      function ModalFooter() {
        (0, _classCallCheck3['default'])(this, ModalFooter);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      ModalFooter.prototype.render = function render() {
        var _props = this.props,
            Component = _props.componentClass,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['componentClass', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement(Component, (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return ModalFooter;
    }(_react2['default'].Component);

    ModalFooter.propTypes = propTypes;
    ModalFooter.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('modal-footer', ModalFooter);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255}],59:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _createChainedFunction = require('./utils/createChainedFunction');

    var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    // TODO: `aria-label` should be `closeLabel`.

    var propTypes = {
      /**
       * The 'aria-label' attribute provides an accessible label for the close
       * button. It is used for Assistive Technology when the label text is not
       * readable.
       */
      'aria-label': _react2['default'].PropTypes.string,

      /**
       * Specify whether the Component should contain a close button
       */
      closeButton: _react2['default'].PropTypes.bool,

      /**
       * A Callback fired when the close button is clicked. If used directly inside
       * a Modal component, the onHide will automatically be propagated up to the
       * parent Modal `onHide`.
       */
      onHide: _react2['default'].PropTypes.func
    };

    var defaultProps = {
      'aria-label': 'Close',
      closeButton: false
    };

    var contextTypes = {
      $bs_modal: _react2['default'].PropTypes.shape({
        onHide: _react2['default'].PropTypes.func
      })
    };

    var ModalHeader = function (_React$Component) {
      (0, _inherits3['default'])(ModalHeader, _React$Component);

      function ModalHeader() {
        (0, _classCallCheck3['default'])(this, ModalHeader);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      ModalHeader.prototype.render = function render() {
        var _props = this.props,
            label = _props['aria-label'],
            closeButton = _props.closeButton,
            onHide = _props.onHide,
            className = _props.className,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['aria-label', 'closeButton', 'onHide', 'className', 'children']);

        var modal = this.context.$bs_modal;

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement(
          'div',
          (0, _extends3['default'])({}, elementProps, {
            className: (0, _classnames2['default'])(className, classes)
          }),
          closeButton && _react2['default'].createElement(
            'button',
            {
              type: 'button',
              className: 'close',
              'aria-label': label,
              onClick: (0, _createChainedFunction2['default'])(modal.onHide, onHide)
            },
            _react2['default'].createElement(
              'span',
              { 'aria-hidden': 'true' },
              '\xD7'
            )
          ),
          children
        );
      };

      return ModalHeader;
    }(_react2['default'].Component);

    ModalHeader.propTypes = propTypes;
    ModalHeader.defaultProps = defaultProps;
    ModalHeader.contextTypes = contextTypes;

    exports['default'] = (0, _bootstrapUtils.bsClass)('modal-header', ModalHeader);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"./utils/createChainedFunction":103,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],60:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      componentClass: _elementType2['default']
    };

    var defaultProps = {
      componentClass: 'h4'
    };

    var ModalTitle = function (_React$Component) {
      (0, _inherits3['default'])(ModalTitle, _React$Component);

      function ModalTitle() {
        (0, _classCallCheck3['default'])(this, ModalTitle);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      ModalTitle.prototype.render = function render() {
        var _props = this.props,
            Component = _props.componentClass,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['componentClass', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement(Component, (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return ModalTitle;
    }(_react2['default'].Component);

    ModalTitle.propTypes = propTypes;
    ModalTitle.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('modal-title', ModalTitle);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255}],61:[function(require,module,exports){
    (function (process){
    'use strict';

    exports.__esModule = true;

    var _extends3 = require('babel-runtime/helpers/extends');

    var _extends4 = _interopRequireDefault(_extends3);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _keycode = require('keycode');

    var _keycode2 = _interopRequireDefault(_keycode);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _reactDom = require('react-dom');

    var _reactDom2 = _interopRequireDefault(_reactDom);

    var _all = require('react-prop-types/lib/all');

    var _all2 = _interopRequireDefault(_all);

    var _warning = require('warning');

    var _warning2 = _interopRequireDefault(_warning);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _createChainedFunction = require('./utils/createChainedFunction');

    var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);

    var _ValidComponentChildren = require('./utils/ValidComponentChildren');

    var _ValidComponentChildren2 = _interopRequireDefault(_ValidComponentChildren);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    // TODO: Should we expose `<NavItem>` as `<Nav.Item>`?

    // TODO: This `bsStyle` is very unlike the others. Should we rename it?

    // TODO: `pullRight` and `pullLeft` don't render right outside of `navbar`.
    // Consider renaming or replacing them.

    var propTypes = {
      /**
       * Marks the NavItem with a matching `eventKey` as active. Has a
       * higher precedence over `activeHref`.
       */
      activeKey: _react2['default'].PropTypes.any,

      /**
       * Marks the child NavItem with a matching `href` prop as active.
       */
      activeHref: _react2['default'].PropTypes.string,

      /**
       * NavItems are be positioned vertically.
       */
      stacked: _react2['default'].PropTypes.bool,

      justified: (0, _all2['default'])(_react2['default'].PropTypes.bool, function (_ref) {
        var justified = _ref.justified,
            navbar = _ref.navbar;
        return justified && navbar ? Error('justified navbar `Nav`s are not supported') : null;
      }),

      /**
       * A callback fired when a NavItem is selected.
       *
       * ```js
       * function (
       * 	Any eventKey,
       * 	SyntheticEvent event?
       * )
       * ```
       */
      onSelect: _react2['default'].PropTypes.func,

      /**
       * ARIA role for the Nav, in the context of a TabContainer, the default will
       * be set to "tablist", but can be overridden by the Nav when set explicitly.
       *
       * When the role is set to "tablist" NavItem focus is managed according to
       * the ARIA authoring practices for tabs:
       * https://www.w3.org/TR/2013/WD-wai-aria-practices-20130307/#tabpanel
       */
      role: _react2['default'].PropTypes.string,

      /**
       * Apply styling an alignment for use in a Navbar. This prop will be set
       * automatically when the Nav is used inside a Navbar.
       */
      navbar: _react2['default'].PropTypes.bool,

      /**
       * Float the Nav to the right. When `navbar` is `true` the appropriate
       * contextual classes are added as well.
       */
      pullRight: _react2['default'].PropTypes.bool,

      /**
       * Float the Nav to the left. When `navbar` is `true` the appropriate
       * contextual classes are added as well.
       */
      pullLeft: _react2['default'].PropTypes.bool
    };

    var defaultProps = {
      justified: false,
      pullRight: false,
      pullLeft: false,
      stacked: false
    };

    var contextTypes = {
      $bs_navbar: _react2['default'].PropTypes.shape({
        bsClass: _react2['default'].PropTypes.string,
        onSelect: _react2['default'].PropTypes.func
      }),

      $bs_tabContainer: _react2['default'].PropTypes.shape({
        activeKey: _react2['default'].PropTypes.any,
        onSelect: _react2['default'].PropTypes.func.isRequired,
        getTabId: _react2['default'].PropTypes.func.isRequired,
        getPaneId: _react2['default'].PropTypes.func.isRequired
      })
    };

    var Nav = function (_React$Component) {
      (0, _inherits3['default'])(Nav, _React$Component);

      function Nav() {
        (0, _classCallCheck3['default'])(this, Nav);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Nav.prototype.componentDidUpdate = function componentDidUpdate() {
        var _this2 = this;

        if (!this._needsRefocus) {
          return;
        }

        this._needsRefocus = false;

        var children = this.props.children;

        var _getActiveProps = this.getActiveProps(),
            activeKey = _getActiveProps.activeKey,
            activeHref = _getActiveProps.activeHref;

        var activeChild = _ValidComponentChildren2['default'].find(children, function (child) {
          return _this2.isActive(child, activeKey, activeHref);
        });

        var childrenArray = _ValidComponentChildren2['default'].toArray(children);
        var activeChildIndex = childrenArray.indexOf(activeChild);

        var childNodes = _reactDom2['default'].findDOMNode(this).children;
        var activeNode = childNodes && childNodes[activeChildIndex];

        if (!activeNode || !activeNode.firstChild) {
          return;
        }

        activeNode.firstChild.focus();
      };

      Nav.prototype.handleTabKeyDown = function handleTabKeyDown(onSelect, event) {
        var nextActiveChild = void 0;

        switch (event.keyCode) {
          case _keycode2['default'].codes.left:
          case _keycode2['default'].codes.up:
            nextActiveChild = this.getNextActiveChild(-1);
            break;
          case _keycode2['default'].codes.right:
          case _keycode2['default'].codes.down:
            nextActiveChild = this.getNextActiveChild(1);
            break;
          default:
            // It was a different key; don't handle this keypress.
            return;
        }

        event.preventDefault();

        if (onSelect && nextActiveChild && nextActiveChild.props.eventKey) {
          onSelect(nextActiveChild.props.eventKey);
        }

        this._needsRefocus = true;
      };

      Nav.prototype.getNextActiveChild = function getNextActiveChild(offset) {
        var _this3 = this;

        var children = this.props.children;

        var validChildren = children.filter(function (child) {
          return child.props.eventKey && !child.props.disabled;
        });

        var _getActiveProps2 = this.getActiveProps(),
            activeKey = _getActiveProps2.activeKey,
            activeHref = _getActiveProps2.activeHref;

        var activeChild = _ValidComponentChildren2['default'].find(children, function (child) {
          return _this3.isActive(child, activeKey, activeHref);
        });

        // This assumes the active child is not disabled.
        var activeChildIndex = validChildren.indexOf(activeChild);
        if (activeChildIndex === -1) {
          // Something has gone wrong. Select the first valid child we can find.
          return validChildren[0];
        }

        var nextIndex = activeChildIndex + offset;
        var numValidChildren = validChildren.length;

        if (nextIndex >= numValidChildren) {
          nextIndex = 0;
        } else if (nextIndex < 0) {
          nextIndex = numValidChildren - 1;
        }

        return validChildren[nextIndex];
      };

      Nav.prototype.getActiveProps = function getActiveProps() {
        var tabContainer = this.context.$bs_tabContainer;

        if (tabContainer) {
          process.env.NODE_ENV !== 'production' ? (0, _warning2['default'])(this.props.activeKey == null && !this.props.activeHref, 'Specifying a `<Nav>` `activeKey` or `activeHref` in the context of ' + 'a `<TabContainer>` is not supported. Instead use `<TabContainer ' + ('activeKey={' + this.props.activeKey + '} />`.')) : void 0;

          return tabContainer;
        }

        return this.props;
      };

      Nav.prototype.isActive = function isActive(_ref2, activeKey, activeHref) {
        var props = _ref2.props;

        if (props.active || activeKey != null && props.eventKey === activeKey || activeHref && props.href === activeHref) {
          return true;
        }

        return props.active;
      };

      Nav.prototype.getTabProps = function getTabProps(child, tabContainer, navRole, active, onSelect) {
        var _this4 = this;

        if (!tabContainer && navRole !== 'tablist') {
          // No tab props here.
          return null;
        }

        var _child$props = child.props,
            id = _child$props.id,
            controls = _child$props['aria-controls'],
            eventKey = _child$props.eventKey,
            role = _child$props.role,
            onKeyDown = _child$props.onKeyDown,
            tabIndex = _child$props.tabIndex;

        if (tabContainer) {
          process.env.NODE_ENV !== 'production' ? (0, _warning2['default'])(!id && !controls, 'In the context of a `<TabContainer>`, `<NavItem>`s are given ' + 'generated `id` and `aria-controls` attributes for the sake of ' + 'proper component accessibility. Any provided ones will be ignored. ' + 'To control these attributes directly, provide a `generateChildId` ' + 'prop to the parent `<TabContainer>`.') : void 0;

          id = tabContainer.getTabId(eventKey);
          controls = tabContainer.getPaneId(eventKey);
        }

        if (navRole === 'tablist') {
          role = role || 'tab';
          onKeyDown = (0, _createChainedFunction2['default'])(function (event) {
            return _this4.handleTabKeyDown(onSelect, event);
          }, onKeyDown);
          tabIndex = active ? tabIndex : -1;
        }

        return {
          id: id,
          role: role,
          onKeyDown: onKeyDown,
          'aria-controls': controls,
          tabIndex: tabIndex
        };
      };

      Nav.prototype.render = function render() {
        var _extends2,
            _this5 = this;

        var _props = this.props,
            stacked = _props.stacked,
            justified = _props.justified,
            onSelect = _props.onSelect,
            propsRole = _props.role,
            propsNavbar = _props.navbar,
            pullRight = _props.pullRight,
            pullLeft = _props.pullLeft,
            className = _props.className,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['stacked', 'justified', 'onSelect', 'role', 'navbar', 'pullRight', 'pullLeft', 'className', 'children']);

        var tabContainer = this.context.$bs_tabContainer;
        var role = propsRole || (tabContainer ? 'tablist' : null);

        var _getActiveProps3 = this.getActiveProps(),
            activeKey = _getActiveProps3.activeKey,
            activeHref = _getActiveProps3.activeHref;

        delete props.activeKey; // Accessed via this.getActiveProps().
        delete props.activeHref; // Accessed via this.getActiveProps().

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _extends4['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), (_extends2 = {}, _extends2[(0, _bootstrapUtils.prefix)(bsProps, 'stacked')] = stacked, _extends2[(0, _bootstrapUtils.prefix)(bsProps, 'justified')] = justified, _extends2));

        var navbar = propsNavbar != null ? propsNavbar : this.context.$bs_navbar;
        var pullLeftClassName = void 0;
        var pullRightClassName = void 0;

        if (navbar) {
          var navbarProps = this.context.$bs_navbar || { bsClass: 'navbar' };

          classes[(0, _bootstrapUtils.prefix)(navbarProps, 'nav')] = true;

          pullRightClassName = (0, _bootstrapUtils.prefix)(navbarProps, 'right');
          pullLeftClassName = (0, _bootstrapUtils.prefix)(navbarProps, 'left');
        } else {
          pullRightClassName = 'pull-right';
          pullLeftClassName = 'pull-left';
        }

        classes[pullRightClassName] = pullRight;
        classes[pullLeftClassName] = pullLeft;

        return _react2['default'].createElement(
          'ul',
          (0, _extends4['default'])({}, elementProps, {
            role: role,
            className: (0, _classnames2['default'])(className, classes)
          }),
          _ValidComponentChildren2['default'].map(children, function (child) {
            var active = _this5.isActive(child, activeKey, activeHref);
            var childOnSelect = (0, _createChainedFunction2['default'])(child.props.onSelect, onSelect, navbar && navbar.onSelect, tabContainer && tabContainer.onSelect);

            return (0, _react.cloneElement)(child, (0, _extends4['default'])({}, _this5.getTabProps(child, tabContainer, role, active, childOnSelect), {
              active: active,
              activeKey: activeKey,
              activeHref: activeHref,
              onSelect: childOnSelect
            }));
          })
        );
      };

      return Nav;
    }(_react2['default'].Component);

    Nav.propTypes = propTypes;
    Nav.defaultProps = defaultProps;
    Nav.contextTypes = contextTypes;

    exports['default'] = (0, _bootstrapUtils.bsClass)('nav', (0, _bootstrapUtils.bsStyles)(['tabs', 'pills'], Nav));
    module.exports = exports['default'];

    }).call(this,require('_process'))
    },{"./utils/ValidComponentChildren":100,"./utils/bootstrapUtils":101,"./utils/createChainedFunction":103,"_process":728,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"keycode":238,"react":618,"react-dom":262,"react-prop-types/lib/all":253,"warning":261}],62:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _Dropdown = require('./Dropdown');

    var _Dropdown2 = _interopRequireDefault(_Dropdown);

    var _splitComponentProps2 = require('./utils/splitComponentProps');

    var _splitComponentProps3 = _interopRequireDefault(_splitComponentProps2);

    var _ValidComponentChildren = require('./utils/ValidComponentChildren');

    var _ValidComponentChildren2 = _interopRequireDefault(_ValidComponentChildren);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = (0, _extends3['default'])({}, _Dropdown2['default'].propTypes, {

      // Toggle props.
      title: _react2['default'].PropTypes.node.isRequired,
      noCaret: _react2['default'].PropTypes.bool,
      active: _react2['default'].PropTypes.bool,

      // Override generated docs from <Dropdown>.
      /**
       * @private
       */
      children: _react2['default'].PropTypes.node
    });

    var NavDropdown = function (_React$Component) {
      (0, _inherits3['default'])(NavDropdown, _React$Component);

      function NavDropdown() {
        (0, _classCallCheck3['default'])(this, NavDropdown);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      NavDropdown.prototype.isActive = function isActive(_ref, activeKey, activeHref) {
        var props = _ref.props;

        var _this2 = this;

        if (props.active || activeKey != null && props.eventKey === activeKey || activeHref && props.href === activeHref) {
          return true;
        }

        if (_ValidComponentChildren2['default'].some(props.children, function (child) {
          return _this2.isActive(child, activeKey, activeHref);
        })) {
          return true;
        }

        return props.active;
      };

      NavDropdown.prototype.render = function render() {
        var _this3 = this;

        var _props = this.props,
            title = _props.title,
            activeKey = _props.activeKey,
            activeHref = _props.activeHref,
            className = _props.className,
            style = _props.style,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['title', 'activeKey', 'activeHref', 'className', 'style', 'children']);

        var active = this.isActive(this, activeKey, activeHref);
        delete props.active; // Accessed via this.isActive().
        delete props.eventKey; // Accessed via this.isActive().

        var _splitComponentProps = (0, _splitComponentProps3['default'])(props, _Dropdown2['default'].ControlledComponent),
            dropdownProps = _splitComponentProps[0],
            toggleProps = _splitComponentProps[1];

        // Unlike for the other dropdowns, styling needs to go to the `<Dropdown>`
        // rather than the `<Dropdown.Toggle>`.

        return _react2['default'].createElement(
          _Dropdown2['default'],
          (0, _extends3['default'])({}, dropdownProps, {
            componentClass: 'li',
            className: (0, _classnames2['default'])(className, { active: active }),
            style: style
          }),
          _react2['default'].createElement(
            _Dropdown2['default'].Toggle,
            (0, _extends3['default'])({}, toggleProps, { useAnchor: true }),
            title
          ),
          _react2['default'].createElement(
            _Dropdown2['default'].Menu,
            null,
            _ValidComponentChildren2['default'].map(children, function (child) {
              return _react2['default'].cloneElement(child, {
                active: _this3.isActive(child, activeKey, activeHref)
              });
            })
          )
        );
      };

      return NavDropdown;
    }(_react2['default'].Component);

    NavDropdown.propTypes = propTypes;

    exports['default'] = NavDropdown;
    module.exports = exports['default'];

    },{"./Dropdown":26,"./utils/ValidComponentChildren":100,"./utils/splitComponentProps":106,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],63:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _SafeAnchor = require('./SafeAnchor');

    var _SafeAnchor2 = _interopRequireDefault(_SafeAnchor);

    var _createChainedFunction = require('./utils/createChainedFunction');

    var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      active: _react2['default'].PropTypes.bool,
      disabled: _react2['default'].PropTypes.bool,
      role: _react2['default'].PropTypes.string,
      href: _react2['default'].PropTypes.string,
      onClick: _react2['default'].PropTypes.func,
      onSelect: _react2['default'].PropTypes.func,
      eventKey: _react2['default'].PropTypes.any
    };

    var defaultProps = {
      active: false,
      disabled: false
    };

    var NavItem = function (_React$Component) {
      (0, _inherits3['default'])(NavItem, _React$Component);

      function NavItem(props, context) {
        (0, _classCallCheck3['default'])(this, NavItem);

        var _this = (0, _possibleConstructorReturn3['default'])(this, _React$Component.call(this, props, context));

        _this.handleClick = _this.handleClick.bind(_this);
        return _this;
      }

      NavItem.prototype.handleClick = function handleClick(e) {
        if (this.props.onSelect) {
          e.preventDefault();

          if (!this.props.disabled) {
            this.props.onSelect(this.props.eventKey, e);
          }
        }
      };

      NavItem.prototype.render = function render() {
        var _props = this.props,
            active = _props.active,
            disabled = _props.disabled,
            onClick = _props.onClick,
            className = _props.className,
            style = _props.style,
            props = (0, _objectWithoutProperties3['default'])(_props, ['active', 'disabled', 'onClick', 'className', 'style']);

        delete props.onSelect;
        delete props.eventKey;

        // These are injected down by `<Nav>` for building `<SubNav>`s.
        delete props.activeKey;
        delete props.activeHref;

        if (!props.role) {
          if (props.href === '#') {
            props.role = 'button';
          }
        } else if (props.role === 'tab') {
          props['aria-selected'] = active;
        }

        return _react2['default'].createElement(
          'li',
          {
            role: 'presentation',
            className: (0, _classnames2['default'])(className, { active: active, disabled: disabled }),
            style: style
          },
          _react2['default'].createElement(_SafeAnchor2['default'], (0, _extends3['default'])({}, props, {
            disabled: disabled,
            onClick: (0, _createChainedFunction2['default'])(onClick, this.handleClick)
          }))
        );
      };

      return NavItem;
    }(_react2['default'].Component);

    NavItem.propTypes = propTypes;
    NavItem.defaultProps = defaultProps;

    exports['default'] = NavItem;
    module.exports = exports['default'];

    },{"./SafeAnchor":84,"./utils/createChainedFunction":103,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],64:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends3 = require('babel-runtime/helpers/extends');

    var _extends4 = _interopRequireDefault(_extends3);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _uncontrollable = require('uncontrollable');

    var _uncontrollable2 = _interopRequireDefault(_uncontrollable);

    var _Grid = require('./Grid');

    var _Grid2 = _interopRequireDefault(_Grid);

    var _NavbarBrand = require('./NavbarBrand');

    var _NavbarBrand2 = _interopRequireDefault(_NavbarBrand);

    var _NavbarCollapse = require('./NavbarCollapse');

    var _NavbarCollapse2 = _interopRequireDefault(_NavbarCollapse);

    var _NavbarHeader = require('./NavbarHeader');

    var _NavbarHeader2 = _interopRequireDefault(_NavbarHeader);

    var _NavbarToggle = require('./NavbarToggle');

    var _NavbarToggle2 = _interopRequireDefault(_NavbarToggle);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _StyleConfig = require('./utils/StyleConfig');

    var _createChainedFunction = require('./utils/createChainedFunction');

    var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    // TODO: Remove this pragma once we upgrade eslint-config-airbnb.
    /* eslint-disable react/no-multi-comp */

    var propTypes = {
      /**
       * Create a fixed navbar along the top of the screen, that scrolls with the
       * page
       */
      fixedTop: _react2['default'].PropTypes.bool,
      /**
       * Create a fixed navbar along the bottom of the screen, that scrolls with
       * the page
       */
      fixedBottom: _react2['default'].PropTypes.bool,
      /**
       * Create a full-width navbar that scrolls away with the page
       */
      staticTop: _react2['default'].PropTypes.bool,
      /**
       * An alternative dark visual style for the Navbar
       */
      inverse: _react2['default'].PropTypes.bool,
      /**
       * Allow the Navbar to fluidly adjust to the page or container width, instead
       * of at the predefined screen breakpoints
       */
      fluid: _react2['default'].PropTypes.bool,

      /**
       * Set a custom element for this component.
       */
      componentClass: _elementType2['default'],
      /**
       * A callback fired when the `<Navbar>` body collapses or expands. Fired when
       * a `<Navbar.Toggle>` is clicked and called with the new `navExpanded`
       * boolean value.
       *
       * @controllable navExpanded
       */
      onToggle: _react2['default'].PropTypes.func,
      /**
       * A callback fired when a descendant of a child `<Nav>` is selected. Should
       * be used to execute complex closing or other miscellaneous actions desired
       * after selecting a descendant of `<Nav>`. Does nothing if no `<Nav>` or `<Nav>`
       * descendants exist. The callback is called with an eventKey, which is a
       * prop from the selected `<Nav>` descendant, and an event.
       *
       * ```js
       * function (
       * 	Any eventKey,
       * 	SyntheticEvent event?
       * )
       * ```
       *
       * For basic closing behavior after all `<Nav>` descendant onSelect events in
       * mobile viewports, try using collapseOnSelect.
       *
       * Note: If you are manually closing the navbar using this `OnSelect` prop,
       * ensure that you are setting `expanded` to false and not *toggling* between
       * true and false.
       */
      onSelect: _react2['default'].PropTypes.func,
      /**
       * Sets `expanded` to `false` after the onSelect event of a descendant of a
       * child `<Nav>`. Does nothing if no `<Nav>` or `<Nav>` descendants exist.
       *
       * The onSelect callback should be used instead for more complex operations
       * that need to be executed after the `select` event of `<Nav>` descendants.
       */
      collapseOnSelect: _react2['default'].PropTypes.bool,
      /**
       * Explicitly set the visiblity of the navbar body
       *
       * @controllable onToggle
       */
      expanded: _react2['default'].PropTypes.bool,

      role: _react2['default'].PropTypes.string
    };

    var defaultProps = {
      componentClass: 'nav',
      fixedTop: false,
      fixedBottom: false,
      staticTop: false,
      inverse: false,
      fluid: false,
      collapseOnSelect: false
    };

    var childContextTypes = {
      $bs_navbar: _react.PropTypes.shape({
        bsClass: _react.PropTypes.string,
        expanded: _react.PropTypes.bool,
        onToggle: _react.PropTypes.func.isRequired,
        onSelect: _react.PropTypes.func
      })
    };

    var Navbar = function (_React$Component) {
      (0, _inherits3['default'])(Navbar, _React$Component);

      function Navbar(props, context) {
        (0, _classCallCheck3['default'])(this, Navbar);

        var _this = (0, _possibleConstructorReturn3['default'])(this, _React$Component.call(this, props, context));

        _this.handleToggle = _this.handleToggle.bind(_this);
        _this.handleCollapse = _this.handleCollapse.bind(_this);
        return _this;
      }

      Navbar.prototype.getChildContext = function getChildContext() {
        var _props = this.props,
            bsClass = _props.bsClass,
            expanded = _props.expanded,
            onSelect = _props.onSelect,
            collapseOnSelect = _props.collapseOnSelect;

        return {
          $bs_navbar: {
            bsClass: bsClass,
            expanded: expanded,
            onToggle: this.handleToggle,
            onSelect: (0, _createChainedFunction2['default'])(onSelect, collapseOnSelect ? this.handleCollapse : null)
          }
        };
      };

      Navbar.prototype.handleCollapse = function handleCollapse() {
        var _props2 = this.props,
            onToggle = _props2.onToggle,
            expanded = _props2.expanded;

        if (expanded) {
          onToggle(false);
        }
      };

      Navbar.prototype.handleToggle = function handleToggle() {
        var _props3 = this.props,
            onToggle = _props3.onToggle,
            expanded = _props3.expanded;

        onToggle(!expanded);
      };

      Navbar.prototype.render = function render() {
        var _extends2;

        var _props4 = this.props,
            Component = _props4.componentClass,
            fixedTop = _props4.fixedTop,
            fixedBottom = _props4.fixedBottom,
            staticTop = _props4.staticTop,
            inverse = _props4.inverse,
            fluid = _props4.fluid,
            className = _props4.className,
            children = _props4.children,
            props = (0, _objectWithoutProperties3['default'])(_props4, ['componentClass', 'fixedTop', 'fixedBottom', 'staticTop', 'inverse', 'fluid', 'className', 'children']);

        var _splitBsPropsAndOmit = (0, _bootstrapUtils.splitBsPropsAndOmit)(props, ['expanded', 'onToggle', 'onSelect', 'collapseOnSelect']),
            bsProps = _splitBsPropsAndOmit[0],
            elementProps = _splitBsPropsAndOmit[1];

        // will result in some false positives but that seems better
        // than false negatives. strict `undefined` check allows explicit
        // "nulling" of the role if the user really doesn't want one

        if (elementProps.role === undefined && Component !== 'nav') {
          elementProps.role = 'navigation';
        }

        if (inverse) {
          bsProps.bsStyle = _StyleConfig.Style.INVERSE;
        }

        var classes = (0, _extends4['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), (_extends2 = {}, _extends2[(0, _bootstrapUtils.prefix)(bsProps, 'fixed-top')] = fixedTop, _extends2[(0, _bootstrapUtils.prefix)(bsProps, 'fixed-bottom')] = fixedBottom, _extends2[(0, _bootstrapUtils.prefix)(bsProps, 'static-top')] = staticTop, _extends2));

        return _react2['default'].createElement(
          Component,
          (0, _extends4['default'])({}, elementProps, {
            className: (0, _classnames2['default'])(className, classes)
          }),
          _react2['default'].createElement(
            _Grid2['default'],
            { fluid: fluid },
            children
          )
        );
      };

      return Navbar;
    }(_react2['default'].Component);

    Navbar.propTypes = propTypes;
    Navbar.defaultProps = defaultProps;
    Navbar.childContextTypes = childContextTypes;

    (0, _bootstrapUtils.bsClass)('navbar', Navbar);

    var UncontrollableNavbar = (0, _uncontrollable2['default'])(Navbar, { expanded: 'onToggle' });

    function createSimpleWrapper(tag, suffix, displayName) {
      var Wrapper = function Wrapper(_ref, _ref2) {
        var _ref2$$bs_navbar = _ref2.$bs_navbar,
            navbarProps = _ref2$$bs_navbar === undefined ? { bsClass: 'navbar' } : _ref2$$bs_navbar;
        var Component = _ref.componentClass,
            className = _ref.className,
            pullRight = _ref.pullRight,
            pullLeft = _ref.pullLeft,
            props = (0, _objectWithoutProperties3['default'])(_ref, ['componentClass', 'className', 'pullRight', 'pullLeft']);
        return _react2['default'].createElement(Component, (0, _extends4['default'])({}, props, {
          className: (0, _classnames2['default'])(className, (0, _bootstrapUtils.prefix)(navbarProps, suffix), pullRight && (0, _bootstrapUtils.prefix)(navbarProps, 'right'), pullLeft && (0, _bootstrapUtils.prefix)(navbarProps, 'left'))
        }));
      };

      Wrapper.displayName = displayName;

      Wrapper.propTypes = {
        componentClass: _elementType2['default'],
        pullRight: _react2['default'].PropTypes.bool,
        pullLeft: _react2['default'].PropTypes.bool
      };

      Wrapper.defaultProps = {
        componentClass: tag,
        pullRight: false,
        pullLeft: false
      };

      Wrapper.contextTypes = {
        $bs_navbar: _react.PropTypes.shape({
          bsClass: _react.PropTypes.string
        })
      };

      return Wrapper;
    }

    UncontrollableNavbar.Brand = _NavbarBrand2['default'];
    UncontrollableNavbar.Header = _NavbarHeader2['default'];
    UncontrollableNavbar.Toggle = _NavbarToggle2['default'];
    UncontrollableNavbar.Collapse = _NavbarCollapse2['default'];

    UncontrollableNavbar.Form = createSimpleWrapper('div', 'form', 'NavbarForm');
    UncontrollableNavbar.Text = createSimpleWrapper('p', 'text', 'NavbarText');
    UncontrollableNavbar.Link = createSimpleWrapper('a', 'link', 'NavbarLink');

    // Set bsStyles here so they can be overridden.
    exports['default'] = (0, _bootstrapUtils.bsStyles)([_StyleConfig.Style.DEFAULT, _StyleConfig.Style.INVERSE], _StyleConfig.Style.DEFAULT, UncontrollableNavbar);
    module.exports = exports['default'];

    },{"./Grid":37,"./NavbarBrand":65,"./NavbarCollapse":66,"./NavbarHeader":67,"./NavbarToggle":68,"./utils/StyleConfig":98,"./utils/bootstrapUtils":101,"./utils/createChainedFunction":103,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255,"uncontrollable":259}],65:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var contextTypes = {
      $bs_navbar: _react2['default'].PropTypes.shape({
        bsClass: _react2['default'].PropTypes.string
      })
    };

    var NavbarBrand = function (_React$Component) {
      (0, _inherits3['default'])(NavbarBrand, _React$Component);

      function NavbarBrand() {
        (0, _classCallCheck3['default'])(this, NavbarBrand);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      NavbarBrand.prototype.render = function render() {
        var _props = this.props,
            className = _props.className,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['className', 'children']);

        var navbarProps = this.context.$bs_navbar || { bsClass: 'navbar' };

        var bsClassName = (0, _bootstrapUtils.prefix)(navbarProps, 'brand');

        if (_react2['default'].isValidElement(children)) {
          return _react2['default'].cloneElement(children, {
            className: (0, _classnames2['default'])(children.props.className, className, bsClassName)
          });
        }

        return _react2['default'].createElement(
          'span',
          (0, _extends3['default'])({}, props, { className: (0, _classnames2['default'])(className, bsClassName) }),
          children
        );
      };

      return NavbarBrand;
    }(_react2['default'].Component);

    NavbarBrand.contextTypes = contextTypes;

    exports['default'] = NavbarBrand;
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],66:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _Collapse = require('./Collapse');

    var _Collapse2 = _interopRequireDefault(_Collapse);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var contextTypes = {
      $bs_navbar: _react.PropTypes.shape({
        bsClass: _react.PropTypes.string,
        expanded: _react.PropTypes.bool
      })
    };

    var NavbarCollapse = function (_React$Component) {
      (0, _inherits3['default'])(NavbarCollapse, _React$Component);

      function NavbarCollapse() {
        (0, _classCallCheck3['default'])(this, NavbarCollapse);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      NavbarCollapse.prototype.render = function render() {
        var _props = this.props,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['children']);

        var navbarProps = this.context.$bs_navbar || { bsClass: 'navbar' };

        var bsClassName = (0, _bootstrapUtils.prefix)(navbarProps, 'collapse');

        return _react2['default'].createElement(
          _Collapse2['default'],
          (0, _extends3['default'])({ 'in': navbarProps.expanded }, props),
          _react2['default'].createElement(
            'div',
            { className: bsClassName },
            children
          )
        );
      };

      return NavbarCollapse;
    }(_react2['default'].Component);

    NavbarCollapse.contextTypes = contextTypes;

    exports['default'] = NavbarCollapse;
    module.exports = exports['default'];

    },{"./Collapse":24,"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"react":618}],67:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var contextTypes = {
      $bs_navbar: _react2['default'].PropTypes.shape({
        bsClass: _react2['default'].PropTypes.string
      })
    };

    var NavbarHeader = function (_React$Component) {
      (0, _inherits3['default'])(NavbarHeader, _React$Component);

      function NavbarHeader() {
        (0, _classCallCheck3['default'])(this, NavbarHeader);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      NavbarHeader.prototype.render = function render() {
        var _props = this.props,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['className']);

        var navbarProps = this.context.$bs_navbar || { bsClass: 'navbar' };

        var bsClassName = (0, _bootstrapUtils.prefix)(navbarProps, 'header');

        return _react2['default'].createElement('div', (0, _extends3['default'])({}, props, { className: (0, _classnames2['default'])(className, bsClassName) }));
      };

      return NavbarHeader;
    }(_react2['default'].Component);

    NavbarHeader.contextTypes = contextTypes;

    exports['default'] = NavbarHeader;
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],68:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _createChainedFunction = require('./utils/createChainedFunction');

    var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      onClick: _react.PropTypes.func,
      /**
       * The toggle content, if left empty it will render the default toggle (seen above).
       */
      children: _react.PropTypes.node
    };

    var contextTypes = {
      $bs_navbar: _react.PropTypes.shape({
        bsClass: _react.PropTypes.string,
        expanded: _react.PropTypes.bool,
        onToggle: _react.PropTypes.func.isRequired
      })
    };

    var NavbarToggle = function (_React$Component) {
      (0, _inherits3['default'])(NavbarToggle, _React$Component);

      function NavbarToggle() {
        (0, _classCallCheck3['default'])(this, NavbarToggle);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      NavbarToggle.prototype.render = function render() {
        var _props = this.props,
            onClick = _props.onClick,
            className = _props.className,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['onClick', 'className', 'children']);

        var navbarProps = this.context.$bs_navbar || { bsClass: 'navbar' };

        var buttonProps = (0, _extends3['default'])({
          type: 'button'
        }, props, {
          onClick: (0, _createChainedFunction2['default'])(onClick, navbarProps.onToggle),
          className: (0, _classnames2['default'])(className, (0, _bootstrapUtils.prefix)(navbarProps, 'toggle'), !navbarProps.expanded && 'collapsed')
        });

        if (children) {
          return _react2['default'].createElement(
            'button',
            buttonProps,
            children
          );
        }

        return _react2['default'].createElement(
          'button',
          buttonProps,
          _react2['default'].createElement(
            'span',
            { className: 'sr-only' },
            'Toggle navigation'
          ),
          _react2['default'].createElement('span', { className: 'icon-bar' }),
          _react2['default'].createElement('span', { className: 'icon-bar' }),
          _react2['default'].createElement('span', { className: 'icon-bar' })
        );
      };

      return NavbarToggle;
    }(_react2['default'].Component);

    NavbarToggle.propTypes = propTypes;
    NavbarToggle.contextTypes = contextTypes;

    exports['default'] = NavbarToggle;
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"./utils/createChainedFunction":103,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],69:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _Overlay = require('react-overlays/lib/Overlay');

    var _Overlay2 = _interopRequireDefault(_Overlay);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _Fade = require('./Fade');

    var _Fade2 = _interopRequireDefault(_Fade);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = (0, _extends3['default'])({}, _Overlay2['default'].propTypes, {

      /**
       * Set the visibility of the Overlay
       */
      show: _react2['default'].PropTypes.bool,
      /**
       * Specify whether the overlay should trigger onHide when the user clicks outside the overlay
       */
      rootClose: _react2['default'].PropTypes.bool,
      /**
       * A callback invoked by the overlay when it wishes to be hidden. Required if
       * `rootClose` is specified.
       */
      onHide: _react2['default'].PropTypes.func,

      /**
       * Use animation
       */
      animation: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.bool, _elementType2['default']]),

      /**
       * Callback fired before the Overlay transitions in
       */
      onEnter: _react2['default'].PropTypes.func,

      /**
       * Callback fired as the Overlay begins to transition in
       */
      onEntering: _react2['default'].PropTypes.func,

      /**
       * Callback fired after the Overlay finishes transitioning in
       */
      onEntered: _react2['default'].PropTypes.func,

      /**
       * Callback fired right before the Overlay transitions out
       */
      onExit: _react2['default'].PropTypes.func,

      /**
       * Callback fired as the Overlay begins to transition out
       */
      onExiting: _react2['default'].PropTypes.func,

      /**
       * Callback fired after the Overlay finishes transitioning out
       */
      onExited: _react2['default'].PropTypes.func,

      /**
       * Sets the direction of the Overlay.
       */
      placement: _react2['default'].PropTypes.oneOf(['top', 'right', 'bottom', 'left'])
    });

    var defaultProps = {
      animation: _Fade2['default'],
      rootClose: false,
      show: false,
      placement: 'right'
    };

    var Overlay = function (_React$Component) {
      (0, _inherits3['default'])(Overlay, _React$Component);

      function Overlay() {
        (0, _classCallCheck3['default'])(this, Overlay);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Overlay.prototype.render = function render() {
        var _props = this.props,
            animation = _props.animation,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['animation', 'children']);

        var transition = animation === true ? _Fade2['default'] : animation || null;

        var child = void 0;

        if (!transition) {
          child = (0, _react.cloneElement)(children, {
            className: (0, _classnames2['default'])(children.props.className, 'in')
          });
        } else {
          child = children;
        }

        return _react2['default'].createElement(
          _Overlay2['default'],
          (0, _extends3['default'])({}, props, {
            transition: transition
          }),
          child
        );
      };

      return Overlay;
    }(_react2['default'].Component);

    Overlay.propTypes = propTypes;
    Overlay.defaultProps = defaultProps;

    exports['default'] = Overlay;
    module.exports = exports['default'];

    },{"./Fade":30,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-overlays/lib/Overlay":241,"react-prop-types/lib/elementType":255}],70:[function(require,module,exports){
    (function (process){
    'use strict';

    exports.__esModule = true;

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _contains = require('dom-helpers/query/contains');

    var _contains2 = _interopRequireDefault(_contains);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _reactDom = require('react-dom');

    var _reactDom2 = _interopRequireDefault(_reactDom);

    var _warning = require('warning');

    var _warning2 = _interopRequireDefault(_warning);

    var _Overlay = require('./Overlay');

    var _Overlay2 = _interopRequireDefault(_Overlay);

    var _createChainedFunction = require('./utils/createChainedFunction');

    var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    /**
     * Check if value one is inside or equal to the of value
     *
     * @param {string} one
     * @param {string|array} of
     * @returns {boolean}
     */
    function isOneOf(one, of) {
      if (Array.isArray(of)) {
        return of.indexOf(one) >= 0;
      }
      return one === of;
    }

    var triggerType = _react2['default'].PropTypes.oneOf(['click', 'hover', 'focus']);

    var propTypes = (0, _extends3['default'])({}, _Overlay2['default'].propTypes, {

      /**
      * Specify which action or actions trigger Overlay visibility
      */
      trigger: _react2['default'].PropTypes.oneOfType([triggerType, _react2['default'].PropTypes.arrayOf(triggerType)]),

      /**
       * A millisecond delay amount to show and hide the Overlay once triggered
       */
      delay: _react2['default'].PropTypes.number,
      /**
       * A millisecond delay amount before showing the Overlay once triggered.
       */
      delayShow: _react2['default'].PropTypes.number,
      /**
       * A millisecond delay amount before hiding the Overlay once triggered.
       */
      delayHide: _react2['default'].PropTypes.number,

      // FIXME: This should be `defaultShow`.
      /**
       * The initial visibility state of the Overlay. For more nuanced visibility
       * control, consider using the Overlay component directly.
       */
      defaultOverlayShown: _react2['default'].PropTypes.bool,

      /**
       * An element or text to overlay next to the target.
       */
      overlay: _react2['default'].PropTypes.node.isRequired,

      /**
       * @private
       */
      onBlur: _react2['default'].PropTypes.func,
      /**
       * @private
       */
      onClick: _react2['default'].PropTypes.func,
      /**
       * @private
       */
      onFocus: _react2['default'].PropTypes.func,
      /**
       * @private
       */
      onMouseOut: _react2['default'].PropTypes.func,
      /**
       * @private
       */
      onMouseOver: _react2['default'].PropTypes.func,

      // Overridden props from `<Overlay>`.
      /**
       * @private
       */
      target: _react2['default'].PropTypes.oneOf([null]),
      /**
      * @private
      */
      onHide: _react2['default'].PropTypes.oneOf([null]),
      /**
       * @private
       */
      show: _react2['default'].PropTypes.oneOf([null])
    });

    var defaultProps = {
      defaultOverlayShown: false,
      trigger: ['hover', 'focus']
    };

    var OverlayTrigger = function (_React$Component) {
      (0, _inherits3['default'])(OverlayTrigger, _React$Component);

      function OverlayTrigger(props, context) {
        (0, _classCallCheck3['default'])(this, OverlayTrigger);

        var _this = (0, _possibleConstructorReturn3['default'])(this, _React$Component.call(this, props, context));

        _this.handleToggle = _this.handleToggle.bind(_this);
        _this.handleDelayedShow = _this.handleDelayedShow.bind(_this);
        _this.handleDelayedHide = _this.handleDelayedHide.bind(_this);
        _this.handleHide = _this.handleHide.bind(_this);

        _this.handleMouseOver = function (e) {
          return _this.handleMouseOverOut(_this.handleDelayedShow, e);
        };
        _this.handleMouseOut = function (e) {
          return _this.handleMouseOverOut(_this.handleDelayedHide, e);
        };

        _this._mountNode = null;

        _this.state = {
          show: props.defaultOverlayShown
        };
        return _this;
      }

      OverlayTrigger.prototype.componentDidMount = function componentDidMount() {
        this._mountNode = document.createElement('div');
        this.renderOverlay();
      };

      OverlayTrigger.prototype.componentDidUpdate = function componentDidUpdate() {
        this.renderOverlay();
      };

      OverlayTrigger.prototype.componentWillUnmount = function componentWillUnmount() {
        _reactDom2['default'].unmountComponentAtNode(this._mountNode);
        this._mountNode = null;

        clearTimeout(this._hoverShowDelay);
        clearTimeout(this._hoverHideDelay);
      };

      OverlayTrigger.prototype.handleToggle = function handleToggle() {
        if (this.state.show) {
          this.hide();
        } else {
          this.show();
        }
      };

      OverlayTrigger.prototype.handleDelayedShow = function handleDelayedShow() {
        var _this2 = this;

        if (this._hoverHideDelay != null) {
          clearTimeout(this._hoverHideDelay);
          this._hoverHideDelay = null;
          return;
        }

        if (this.state.show || this._hoverShowDelay != null) {
          return;
        }

        var delay = this.props.delayShow != null ? this.props.delayShow : this.props.delay;

        if (!delay) {
          this.show();
          return;
        }

        this._hoverShowDelay = setTimeout(function () {
          _this2._hoverShowDelay = null;
          _this2.show();
        }, delay);
      };

      OverlayTrigger.prototype.handleDelayedHide = function handleDelayedHide() {
        var _this3 = this;

        if (this._hoverShowDelay != null) {
          clearTimeout(this._hoverShowDelay);
          this._hoverShowDelay = null;
          return;
        }

        if (!this.state.show || this._hoverHideDelay != null) {
          return;
        }

        var delay = this.props.delayHide != null ? this.props.delayHide : this.props.delay;

        if (!delay) {
          this.hide();
          return;
        }

        this._hoverHideDelay = setTimeout(function () {
          _this3._hoverHideDelay = null;
          _this3.hide();
        }, delay);
      };

      // Simple implementation of mouseEnter and mouseLeave.
      // React's built version is broken: https://github.com/facebook/react/issues/4251
      // for cases when the trigger is disabled and mouseOut/Over can cause flicker
      // moving from one child element to another.

      OverlayTrigger.prototype.handleMouseOverOut = function handleMouseOverOut(handler, e) {
        var target = e.currentTarget;
        var related = e.relatedTarget || e.nativeEvent.toElement;

        if (!related || related !== target && !(0, _contains2['default'])(target, related)) {
          handler(e);
        }
      };

      OverlayTrigger.prototype.handleHide = function handleHide() {
        this.hide();
      };

      OverlayTrigger.prototype.show = function show() {
        this.setState({ show: true });
      };

      OverlayTrigger.prototype.hide = function hide() {
        this.setState({ show: false });
      };

      OverlayTrigger.prototype.makeOverlay = function makeOverlay(overlay, props) {
        return _react2['default'].createElement(
          _Overlay2['default'],
          (0, _extends3['default'])({}, props, {
            show: this.state.show,
            onHide: this.handleHide,
            target: this
          }),
          overlay
        );
      };

      OverlayTrigger.prototype.renderOverlay = function renderOverlay() {
        _reactDom2['default'].unstable_renderSubtreeIntoContainer(this, this._overlay, this._mountNode);
      };

      OverlayTrigger.prototype.render = function render() {
        var _props = this.props,
            trigger = _props.trigger,
            overlay = _props.overlay,
            children = _props.children,
            onBlur = _props.onBlur,
            onClick = _props.onClick,
            onFocus = _props.onFocus,
            onMouseOut = _props.onMouseOut,
            onMouseOver = _props.onMouseOver,
            props = (0, _objectWithoutProperties3['default'])(_props, ['trigger', 'overlay', 'children', 'onBlur', 'onClick', 'onFocus', 'onMouseOut', 'onMouseOver']);

        delete props.delay;
        delete props.delayShow;
        delete props.delayHide;
        delete props.defaultOverlayShown;

        var child = _react2['default'].Children.only(children);
        var childProps = child.props;

        var triggerProps = {
          'aria-describedby': overlay.props.id
        };

        // FIXME: The logic here for passing through handlers on this component is
        // inconsistent. We shouldn't be passing any of these props through.

        triggerProps.onClick = (0, _createChainedFunction2['default'])(childProps.onClick, onClick);

        if (isOneOf('click', trigger)) {
          triggerProps.onClick = (0, _createChainedFunction2['default'])(triggerProps.onClick, this.handleToggle);
        }

        if (isOneOf('hover', trigger)) {
          process.env.NODE_ENV !== 'production' ? (0, _warning2['default'])(!(trigger === 'hover'), '[react-bootstrap] Specifying only the `"hover"` trigger limits the ' + 'visibility of the overlay to just mouse users. Consider also ' + 'including the `"focus"` trigger so that touch and keyboard only ' + 'users can see the overlay as well.') : void 0;

          triggerProps.onMouseOver = (0, _createChainedFunction2['default'])(childProps.onMouseOver, onMouseOver, this.handleMouseOver);
          triggerProps.onMouseOut = (0, _createChainedFunction2['default'])(childProps.onMouseOut, onMouseOut, this.handleMouseOut);
        }

        if (isOneOf('focus', trigger)) {
          triggerProps.onFocus = (0, _createChainedFunction2['default'])(childProps.onFocus, onFocus, this.handleDelayedShow);
          triggerProps.onBlur = (0, _createChainedFunction2['default'])(childProps.onBlur, onBlur, this.handleDelayedHide);
        }

        this._overlay = this.makeOverlay(overlay, props);

        return (0, _react.cloneElement)(child, triggerProps);
      };

      return OverlayTrigger;
    }(_react2['default'].Component);

    OverlayTrigger.propTypes = propTypes;
    OverlayTrigger.defaultProps = defaultProps;

    exports['default'] = OverlayTrigger;
    module.exports = exports['default'];

    }).call(this,require('_process'))
    },{"./Overlay":69,"./utils/createChainedFunction":103,"_process":728,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"dom-helpers/query/contains":218,"react":618,"react-dom":262,"warning":261}],71:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var PageHeader = function (_React$Component) {
      (0, _inherits3['default'])(PageHeader, _React$Component);

      function PageHeader() {
        (0, _classCallCheck3['default'])(this, PageHeader);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      PageHeader.prototype.render = function render() {
        var _props = this.props,
            className = _props.className,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['className', 'children']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement(
          'div',
          (0, _extends3['default'])({}, elementProps, {
            className: (0, _classnames2['default'])(className, classes)
          }),
          _react2['default'].createElement(
            'h1',
            null,
            children
          )
        );
      };

      return PageHeader;
    }(_react2['default'].Component);

    exports['default'] = (0, _bootstrapUtils.bsClass)('page-header', PageHeader);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],72:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _PagerItem = require('./PagerItem');

    var _PagerItem2 = _interopRequireDefault(_PagerItem);

    var _deprecationWarning = require('./utils/deprecationWarning');

    var _deprecationWarning2 = _interopRequireDefault(_deprecationWarning);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    exports['default'] = _deprecationWarning2['default'].wrapper(_PagerItem2['default'], '`<PageItem>`', '`<Pager.Item>`');
    module.exports = exports['default'];

    },{"./PagerItem":74,"./utils/deprecationWarning":104}],73:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _PagerItem = require('./PagerItem');

    var _PagerItem2 = _interopRequireDefault(_PagerItem);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _createChainedFunction = require('./utils/createChainedFunction');

    var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);

    var _ValidComponentChildren = require('./utils/ValidComponentChildren');

    var _ValidComponentChildren2 = _interopRequireDefault(_ValidComponentChildren);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      onSelect: _react2['default'].PropTypes.func
    };

    var Pager = function (_React$Component) {
      (0, _inherits3['default'])(Pager, _React$Component);

      function Pager() {
        (0, _classCallCheck3['default'])(this, Pager);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Pager.prototype.render = function render() {
        var _props = this.props,
            onSelect = _props.onSelect,
            className = _props.className,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['onSelect', 'className', 'children']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement(
          'ul',
          (0, _extends3['default'])({}, elementProps, {
            className: (0, _classnames2['default'])(className, classes)
          }),
          _ValidComponentChildren2['default'].map(children, function (child) {
            return (0, _react.cloneElement)(child, {
              onSelect: (0, _createChainedFunction2['default'])(child.props.onSelect, onSelect)
            });
          })
        );
      };

      return Pager;
    }(_react2['default'].Component);

    Pager.propTypes = propTypes;

    Pager.Item = _PagerItem2['default'];

    exports['default'] = (0, _bootstrapUtils.bsClass)('pager', Pager);
    module.exports = exports['default'];

    },{"./PagerItem":74,"./utils/ValidComponentChildren":100,"./utils/bootstrapUtils":101,"./utils/createChainedFunction":103,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],74:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _SafeAnchor = require('./SafeAnchor');

    var _SafeAnchor2 = _interopRequireDefault(_SafeAnchor);

    var _createChainedFunction = require('./utils/createChainedFunction');

    var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      disabled: _react2['default'].PropTypes.bool,
      previous: _react2['default'].PropTypes.bool,
      next: _react2['default'].PropTypes.bool,
      onClick: _react2['default'].PropTypes.func,
      onSelect: _react2['default'].PropTypes.func,
      eventKey: _react2['default'].PropTypes.any
    };

    var defaultProps = {
      disabled: false,
      previous: false,
      next: false
    };

    var PagerItem = function (_React$Component) {
      (0, _inherits3['default'])(PagerItem, _React$Component);

      function PagerItem(props, context) {
        (0, _classCallCheck3['default'])(this, PagerItem);

        var _this = (0, _possibleConstructorReturn3['default'])(this, _React$Component.call(this, props, context));

        _this.handleSelect = _this.handleSelect.bind(_this);
        return _this;
      }

      PagerItem.prototype.handleSelect = function handleSelect(e) {
        var _props = this.props,
            disabled = _props.disabled,
            onSelect = _props.onSelect,
            eventKey = _props.eventKey;

        if (onSelect || disabled) {
          e.preventDefault();
        }

        if (disabled) {
          return;
        }

        if (onSelect) {
          onSelect(eventKey, e);
        }
      };

      PagerItem.prototype.render = function render() {
        var _props2 = this.props,
            disabled = _props2.disabled,
            previous = _props2.previous,
            next = _props2.next,
            onClick = _props2.onClick,
            className = _props2.className,
            style = _props2.style,
            props = (0, _objectWithoutProperties3['default'])(_props2, ['disabled', 'previous', 'next', 'onClick', 'className', 'style']);

        delete props.onSelect;
        delete props.eventKey;

        return _react2['default'].createElement(
          'li',
          {
            className: (0, _classnames2['default'])(className, { disabled: disabled, previous: previous, next: next }),
            style: style
          },
          _react2['default'].createElement(_SafeAnchor2['default'], (0, _extends3['default'])({}, props, {
            disabled: disabled,
            onClick: (0, _createChainedFunction2['default'])(onClick, this.handleSelect)
          }))
        );
      };

      return PagerItem;
    }(_react2['default'].Component);

    PagerItem.propTypes = propTypes;
    PagerItem.defaultProps = defaultProps;

    exports['default'] = PagerItem;
    module.exports = exports['default'];

    },{"./SafeAnchor":84,"./utils/createChainedFunction":103,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],75:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _PaginationButton = require('./PaginationButton');

    var _PaginationButton2 = _interopRequireDefault(_PaginationButton);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      activePage: _react2['default'].PropTypes.number,
      items: _react2['default'].PropTypes.number,
      maxButtons: _react2['default'].PropTypes.number,

      /**
       * When `true`, will display the first and the last button page
       */
      boundaryLinks: _react2['default'].PropTypes.bool,

      /**
       * When `true`, will display the default node value ('&hellip;').
       * Otherwise, will display provided node (when specified).
       */
      ellipsis: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.bool, _react2['default'].PropTypes.node]),

      /**
       * When `true`, will display the default node value ('&laquo;').
       * Otherwise, will display provided node (when specified).
       */
      first: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.bool, _react2['default'].PropTypes.node]),

      /**
       * When `true`, will display the default node value ('&raquo;').
       * Otherwise, will display provided node (when specified).
       */
      last: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.bool, _react2['default'].PropTypes.node]),

      /**
       * When `true`, will display the default node value ('&lsaquo;').
       * Otherwise, will display provided node (when specified).
       */
      prev: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.bool, _react2['default'].PropTypes.node]),

      /**
       * When `true`, will display the default node value ('&rsaquo;').
       * Otherwise, will display provided node (when specified).
       */
      next: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.bool, _react2['default'].PropTypes.node]),

      onSelect: _react2['default'].PropTypes.func,

      /**
       * You can use a custom element for the buttons
       */
      buttonComponentClass: _elementType2['default']
    };

    var defaultProps = {
      activePage: 1,
      items: 1,
      maxButtons: 0,
      first: false,
      last: false,
      prev: false,
      next: false,
      ellipsis: true,
      boundaryLinks: false
    };

    var Pagination = function (_React$Component) {
      (0, _inherits3['default'])(Pagination, _React$Component);

      function Pagination() {
        (0, _classCallCheck3['default'])(this, Pagination);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Pagination.prototype.renderPageButtons = function renderPageButtons(activePage, items, maxButtons, boundaryLinks, ellipsis, buttonProps) {
        var pageButtons = [];

        var startPage = void 0;
        var endPage = void 0;
        var hasHiddenPagesAfter = void 0;

        if (maxButtons) {
          var hiddenPagesBefore = activePage - parseInt(maxButtons / 2, 10);
          startPage = Math.max(hiddenPagesBefore, 1);
          hasHiddenPagesAfter = items >= startPage + maxButtons;

          if (!hasHiddenPagesAfter) {
            endPage = items;
            startPage = items - maxButtons + 1;
            if (startPage < 1) {
              startPage = 1;
            }
          } else {
            endPage = startPage + maxButtons - 1;
          }
        } else {
          startPage = 1;
          endPage = items;
        }

        for (var pagenumber = startPage; pagenumber <= endPage; pagenumber++) {
          pageButtons.push(_react2['default'].createElement(
            _PaginationButton2['default'],
            (0, _extends3['default'])({}, buttonProps, {
              key: pagenumber,
              eventKey: pagenumber,
              active: pagenumber === activePage
            }),
            pagenumber
          ));
        }

        if (boundaryLinks && ellipsis && startPage !== 1) {
          pageButtons.unshift(_react2['default'].createElement(
            _PaginationButton2['default'],
            {
              key: 'ellipsisFirst',
              disabled: true,
              componentClass: buttonProps.componentClass
            },
            _react2['default'].createElement(
              'span',
              { 'aria-label': 'More' },
              ellipsis === true ? '\u2026' : ellipsis
            )
          ));

          pageButtons.unshift(_react2['default'].createElement(
            _PaginationButton2['default'],
            (0, _extends3['default'])({}, buttonProps, {
              key: 1,
              eventKey: 1,
              active: false
            }),
            '1'
          ));
        }

        if (maxButtons && hasHiddenPagesAfter && ellipsis) {
          pageButtons.push(_react2['default'].createElement(
            _PaginationButton2['default'],
            {
              key: 'ellipsis',
              disabled: true,
              componentClass: buttonProps.componentClass
            },
            _react2['default'].createElement(
              'span',
              { 'aria-label': 'More' },
              ellipsis === true ? '\u2026' : ellipsis
            )
          ));

          if (boundaryLinks && endPage !== items) {
            pageButtons.push(_react2['default'].createElement(
              _PaginationButton2['default'],
              (0, _extends3['default'])({}, buttonProps, {
                key: items,
                eventKey: items,
                active: false
              }),
              items
            ));
          }
        }

        return pageButtons;
      };

      Pagination.prototype.render = function render() {
        var _props = this.props,
            activePage = _props.activePage,
            items = _props.items,
            maxButtons = _props.maxButtons,
            boundaryLinks = _props.boundaryLinks,
            ellipsis = _props.ellipsis,
            first = _props.first,
            last = _props.last,
            prev = _props.prev,
            next = _props.next,
            onSelect = _props.onSelect,
            buttonComponentClass = _props.buttonComponentClass,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['activePage', 'items', 'maxButtons', 'boundaryLinks', 'ellipsis', 'first', 'last', 'prev', 'next', 'onSelect', 'buttonComponentClass', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        var buttonProps = {
          onSelect: onSelect,
          componentClass: buttonComponentClass
        };

        return _react2['default'].createElement(
          'ul',
          (0, _extends3['default'])({}, elementProps, {
            className: (0, _classnames2['default'])(className, classes)
          }),
          first && _react2['default'].createElement(
            _PaginationButton2['default'],
            (0, _extends3['default'])({}, buttonProps, {
              eventKey: 1,
              disabled: activePage === 1
            }),
            _react2['default'].createElement(
              'span',
              { 'aria-label': 'First' },
              first === true ? '\xAB' : first
            )
          ),
          prev && _react2['default'].createElement(
            _PaginationButton2['default'],
            (0, _extends3['default'])({}, buttonProps, {
              eventKey: activePage - 1,
              disabled: activePage === 1
            }),
            _react2['default'].createElement(
              'span',
              { 'aria-label': 'Previous' },
              prev === true ? '\u2039' : prev
            )
          ),
          this.renderPageButtons(activePage, items, maxButtons, boundaryLinks, ellipsis, buttonProps),
          next && _react2['default'].createElement(
            _PaginationButton2['default'],
            (0, _extends3['default'])({}, buttonProps, {
              eventKey: activePage + 1,
              disabled: activePage >= items
            }),
            _react2['default'].createElement(
              'span',
              { 'aria-label': 'Next' },
              next === true ? '\u203A' : next
            )
          ),
          last && _react2['default'].createElement(
            _PaginationButton2['default'],
            (0, _extends3['default'])({}, buttonProps, {
              eventKey: items,
              disabled: activePage >= items
            }),
            _react2['default'].createElement(
              'span',
              { 'aria-label': 'Last' },
              last === true ? '\xBB' : last
            )
          )
        );
      };

      return Pagination;
    }(_react2['default'].Component);

    Pagination.propTypes = propTypes;
    Pagination.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('pagination', Pagination);
    module.exports = exports['default'];

    },{"./PaginationButton":76,"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255}],76:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _SafeAnchor = require('./SafeAnchor');

    var _SafeAnchor2 = _interopRequireDefault(_SafeAnchor);

    var _createChainedFunction = require('./utils/createChainedFunction');

    var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    // TODO: This should be `<Pagination.Item>`.

    // TODO: This should use `componentClass` like other components.

    var propTypes = {
      componentClass: _elementType2['default'],
      className: _react2['default'].PropTypes.string,
      eventKey: _react2['default'].PropTypes.any,
      onSelect: _react2['default'].PropTypes.func,
      disabled: _react2['default'].PropTypes.bool,
      active: _react2['default'].PropTypes.bool,
      onClick: _react2['default'].PropTypes.func
    };

    var defaultProps = {
      componentClass: _SafeAnchor2['default'],
      active: false,
      disabled: false
    };

    var PaginationButton = function (_React$Component) {
      (0, _inherits3['default'])(PaginationButton, _React$Component);

      function PaginationButton(props, context) {
        (0, _classCallCheck3['default'])(this, PaginationButton);

        var _this = (0, _possibleConstructorReturn3['default'])(this, _React$Component.call(this, props, context));

        _this.handleClick = _this.handleClick.bind(_this);
        return _this;
      }

      PaginationButton.prototype.handleClick = function handleClick(event) {
        var _props = this.props,
            disabled = _props.disabled,
            onSelect = _props.onSelect,
            eventKey = _props.eventKey;

        if (disabled) {
          return;
        }

        if (onSelect) {
          onSelect(eventKey, event);
        }
      };

      PaginationButton.prototype.render = function render() {
        var _props2 = this.props,
            Component = _props2.componentClass,
            active = _props2.active,
            disabled = _props2.disabled,
            onClick = _props2.onClick,
            className = _props2.className,
            style = _props2.style,
            props = (0, _objectWithoutProperties3['default'])(_props2, ['componentClass', 'active', 'disabled', 'onClick', 'className', 'style']);

        if (Component === _SafeAnchor2['default']) {
          // Assume that custom components want `eventKey`.
          delete props.eventKey;
        }

        delete props.onSelect;

        return _react2['default'].createElement(
          'li',
          {
            className: (0, _classnames2['default'])(className, { active: active, disabled: disabled }),
            style: style
          },
          _react2['default'].createElement(Component, (0, _extends3['default'])({}, props, {
            disabled: disabled,
            onClick: (0, _createChainedFunction2['default'])(onClick, this.handleClick)
          }))
        );
      };

      return PaginationButton;
    }(_react2['default'].Component);

    PaginationButton.propTypes = propTypes;
    PaginationButton.defaultProps = defaultProps;

    exports['default'] = PaginationButton;
    module.exports = exports['default'];

    },{"./SafeAnchor":84,"./utils/createChainedFunction":103,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255}],77:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _values = require('babel-runtime/core-js/object/values');

    var _values2 = _interopRequireDefault(_values);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _Collapse = require('./Collapse');

    var _Collapse2 = _interopRequireDefault(_Collapse);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _StyleConfig = require('./utils/StyleConfig');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    // TODO: Use uncontrollable.

    var propTypes = {
      collapsible: _react2['default'].PropTypes.bool,
      onSelect: _react2['default'].PropTypes.func,
      header: _react2['default'].PropTypes.node,
      id: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number]),
      footer: _react2['default'].PropTypes.node,
      defaultExpanded: _react2['default'].PropTypes.bool,
      expanded: _react2['default'].PropTypes.bool,
      eventKey: _react2['default'].PropTypes.any,
      headerRole: _react2['default'].PropTypes.string,
      panelRole: _react2['default'].PropTypes.string,

      // From Collapse.
      onEnter: _react2['default'].PropTypes.func,
      onEntering: _react2['default'].PropTypes.func,
      onEntered: _react2['default'].PropTypes.func,
      onExit: _react2['default'].PropTypes.func,
      onExiting: _react2['default'].PropTypes.func,
      onExited: _react2['default'].PropTypes.func
    };

    var defaultProps = {
      defaultExpanded: false
    };

    var Panel = function (_React$Component) {
      (0, _inherits3['default'])(Panel, _React$Component);

      function Panel(props, context) {
        (0, _classCallCheck3['default'])(this, Panel);

        var _this = (0, _possibleConstructorReturn3['default'])(this, _React$Component.call(this, props, context));

        _this.handleClickTitle = _this.handleClickTitle.bind(_this);

        _this.state = {
          expanded: _this.props.defaultExpanded
        };
        return _this;
      }

      Panel.prototype.handleClickTitle = function handleClickTitle(e) {
        // FIXME: What the heck? This API is horrible. This needs to go away!
        e.persist();
        e.selected = true;

        if (this.props.onSelect) {
          this.props.onSelect(this.props.eventKey, e);
        } else {
          e.preventDefault();
        }

        if (e.selected) {
          this.setState({ expanded: !this.state.expanded });
        }
      };

      Panel.prototype.renderHeader = function renderHeader(collapsible, header, id, role, expanded, bsProps) {
        var titleClassName = (0, _bootstrapUtils.prefix)(bsProps, 'title');

        if (!collapsible) {
          if (!_react2['default'].isValidElement(header)) {
            return header;
          }

          return (0, _react.cloneElement)(header, {
            className: (0, _classnames2['default'])(header.props.className, titleClassName)
          });
        }

        if (!_react2['default'].isValidElement(header)) {
          return _react2['default'].createElement(
            'h4',
            { role: 'presentation', className: titleClassName },
            this.renderAnchor(header, id, role, expanded)
          );
        }

        return (0, _react.cloneElement)(header, {
          className: (0, _classnames2['default'])(header.props.className, titleClassName),
          children: this.renderAnchor(header.props.children, id, role, expanded)
        });
      };

      Panel.prototype.renderAnchor = function renderAnchor(header, id, role, expanded) {
        return _react2['default'].createElement(
          'a',
          {
            role: role,
            href: id && '#' + id,
            onClick: this.handleClickTitle,
            'aria-controls': id,
            'aria-expanded': expanded,
            'aria-selected': expanded,
            className: expanded ? null : 'collapsed'
          },
          header
        );
      };

      Panel.prototype.renderCollapsibleBody = function renderCollapsibleBody(id, expanded, role, children, bsProps, animationHooks) {
        return _react2['default'].createElement(
          _Collapse2['default'],
          (0, _extends3['default'])({ 'in': expanded }, animationHooks),
          _react2['default'].createElement(
            'div',
            {
              id: id,
              role: role,
              className: (0, _bootstrapUtils.prefix)(bsProps, 'collapse'),
              'aria-hidden': !expanded
            },
            this.renderBody(children, bsProps)
          )
        );
      };

      Panel.prototype.renderBody = function renderBody(rawChildren, bsProps) {
        var children = [];
        var bodyChildren = [];

        var bodyClassName = (0, _bootstrapUtils.prefix)(bsProps, 'body');

        function maybeAddBody() {
          if (!bodyChildren.length) {
            return;
          }

          // Derive the key from the index here, since we need to make one up.
          children.push(_react2['default'].createElement(
            'div',
            { key: children.length, className: bodyClassName },
            bodyChildren
          ));

          bodyChildren = [];
        }

        // Convert to array so we can re-use keys.
        _react2['default'].Children.toArray(rawChildren).forEach(function (child) {
          if (_react2['default'].isValidElement(child) && child.props.fill) {
            maybeAddBody();

            // Remove the child's unknown `fill` prop.
            children.push((0, _react.cloneElement)(child, { fill: undefined }));

            return;
          }

          bodyChildren.push(child);
        });

        maybeAddBody();

        return children;
      };

      Panel.prototype.render = function render() {
        var _props = this.props,
            collapsible = _props.collapsible,
            header = _props.header,
            id = _props.id,
            footer = _props.footer,
            propsExpanded = _props.expanded,
            headerRole = _props.headerRole,
            panelRole = _props.panelRole,
            className = _props.className,
            children = _props.children,
            onEnter = _props.onEnter,
            onEntering = _props.onEntering,
            onEntered = _props.onEntered,
            onExit = _props.onExit,
            onExiting = _props.onExiting,
            onExited = _props.onExited,
            props = (0, _objectWithoutProperties3['default'])(_props, ['collapsible', 'header', 'id', 'footer', 'expanded', 'headerRole', 'panelRole', 'className', 'children', 'onEnter', 'onEntering', 'onEntered', 'onExit', 'onExiting', 'onExited']);

        var _splitBsPropsAndOmit = (0, _bootstrapUtils.splitBsPropsAndOmit)(props, ['defaultExpanded', 'eventKey', 'onSelect']),
            bsProps = _splitBsPropsAndOmit[0],
            elementProps = _splitBsPropsAndOmit[1];

        var expanded = propsExpanded != null ? propsExpanded : this.state.expanded;

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement(
          'div',
          (0, _extends3['default'])({}, elementProps, {
            className: (0, _classnames2['default'])(className, classes),
            id: collapsible ? null : id
          }),
          header && _react2['default'].createElement(
            'div',
            { className: (0, _bootstrapUtils.prefix)(bsProps, 'heading') },
            this.renderHeader(collapsible, header, id, headerRole, expanded, bsProps)
          ),
          collapsible ? this.renderCollapsibleBody(id, expanded, panelRole, children, bsProps, { onEnter: onEnter, onEntering: onEntering, onEntered: onEntered, onExit: onExit, onExiting: onExiting, onExited: onExited }) : this.renderBody(children, bsProps),
          footer && _react2['default'].createElement(
            'div',
            { className: (0, _bootstrapUtils.prefix)(bsProps, 'footer') },
            footer
          )
        );
      };

      return Panel;
    }(_react2['default'].Component);

    Panel.propTypes = propTypes;
    Panel.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('panel', (0, _bootstrapUtils.bsStyles)([].concat((0, _values2['default'])(_StyleConfig.State), [_StyleConfig.Style.DEFAULT, _StyleConfig.Style.PRIMARY]), _StyleConfig.Style.DEFAULT, Panel));
    module.exports = exports['default'];

    },{"./Collapse":24,"./utils/StyleConfig":98,"./utils/bootstrapUtils":101,"babel-runtime/core-js/object/values":112,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],78:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _assign = require('babel-runtime/core-js/object/assign');

    var _assign2 = _interopRequireDefault(_assign);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _createChainedFunction = require('./utils/createChainedFunction');

    var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);

    var _ValidComponentChildren = require('./utils/ValidComponentChildren');

    var _ValidComponentChildren2 = _interopRequireDefault(_ValidComponentChildren);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      accordion: _react2['default'].PropTypes.bool,
      activeKey: _react2['default'].PropTypes.any,
      defaultActiveKey: _react2['default'].PropTypes.any,
      onSelect: _react2['default'].PropTypes.func,
      role: _react2['default'].PropTypes.string
    };

    var defaultProps = {
      accordion: false
    };

    // TODO: Use uncontrollable.

    var PanelGroup = function (_React$Component) {
      (0, _inherits3['default'])(PanelGroup, _React$Component);

      function PanelGroup(props, context) {
        (0, _classCallCheck3['default'])(this, PanelGroup);

        var _this = (0, _possibleConstructorReturn3['default'])(this, _React$Component.call(this, props, context));

        _this.handleSelect = _this.handleSelect.bind(_this);

        _this.state = {
          activeKey: props.defaultActiveKey
        };
        return _this;
      }

      PanelGroup.prototype.handleSelect = function handleSelect(key, e) {
        e.preventDefault();

        if (this.props.onSelect) {
          this.props.onSelect(key, e);
        }

        if (this.state.activeKey === key) {
          key = null;
        }

        this.setState({ activeKey: key });
      };

      PanelGroup.prototype.render = function render() {
        var _this2 = this;

        var _props = this.props,
            accordion = _props.accordion,
            propsActiveKey = _props.activeKey,
            className = _props.className,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['accordion', 'activeKey', 'className', 'children']);

        var _splitBsPropsAndOmit = (0, _bootstrapUtils.splitBsPropsAndOmit)(props, ['defaultActiveKey', 'onSelect']),
            bsProps = _splitBsPropsAndOmit[0],
            elementProps = _splitBsPropsAndOmit[1];

        var activeKey = void 0;
        if (accordion) {
          activeKey = propsActiveKey != null ? propsActiveKey : this.state.activeKey;
          elementProps.role = elementProps.role || 'tablist';
        }

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement(
          'div',
          (0, _extends3['default'])({}, elementProps, {
            className: (0, _classnames2['default'])(className, classes)
          }),
          _ValidComponentChildren2['default'].map(children, function (child) {
            var childProps = {
              bsStyle: child.props.bsStyle || bsProps.bsStyle
            };

            if (accordion) {
              (0, _assign2['default'])(childProps, {
                headerRole: 'tab',
                panelRole: 'tabpanel',
                collapsible: true,
                expanded: child.props.eventKey === activeKey,
                onSelect: (0, _createChainedFunction2['default'])(_this2.handleSelect, child.props.onSelect)
              });
            }

            return (0, _react.cloneElement)(child, childProps);
          })
        );
      };

      return PanelGroup;
    }(_react2['default'].Component);

    PanelGroup.propTypes = propTypes;
    PanelGroup.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('panel-group', PanelGroup);
    module.exports = exports['default'];

    },{"./utils/ValidComponentChildren":100,"./utils/bootstrapUtils":101,"./utils/createChainedFunction":103,"babel-runtime/core-js/object/assign":108,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],79:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends3 = require('babel-runtime/helpers/extends');

    var _extends4 = _interopRequireDefault(_extends3);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _isRequiredForA11y = require('react-prop-types/lib/isRequiredForA11y');

    var _isRequiredForA11y2 = _interopRequireDefault(_isRequiredForA11y);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      /**
       * An html id attribute, necessary for accessibility
       * @type {string}
       * @required
       */
      id: (0, _isRequiredForA11y2['default'])(_react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number])),

      /**
       * Sets the direction the Popover is positioned towards.
       */
      placement: _react2['default'].PropTypes.oneOf(['top', 'right', 'bottom', 'left']),

      /**
       * The "top" position value for the Popover.
       */
      positionTop: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.number, _react2['default'].PropTypes.string]),
      /**
       * The "left" position value for the Popover.
       */
      positionLeft: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.number, _react2['default'].PropTypes.string]),

      /**
       * The "top" position value for the Popover arrow.
       */
      arrowOffsetTop: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.number, _react2['default'].PropTypes.string]),
      /**
       * The "left" position value for the Popover arrow.
       */
      arrowOffsetLeft: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.number, _react2['default'].PropTypes.string]),

      /**
       * Title content
       */
      title: _react2['default'].PropTypes.node
    };

    var defaultProps = {
      placement: 'right'
    };

    var Popover = function (_React$Component) {
      (0, _inherits3['default'])(Popover, _React$Component);

      function Popover() {
        (0, _classCallCheck3['default'])(this, Popover);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Popover.prototype.render = function render() {
        var _extends2;

        var _props = this.props,
            placement = _props.placement,
            positionTop = _props.positionTop,
            positionLeft = _props.positionLeft,
            arrowOffsetTop = _props.arrowOffsetTop,
            arrowOffsetLeft = _props.arrowOffsetLeft,
            title = _props.title,
            className = _props.className,
            style = _props.style,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['placement', 'positionTop', 'positionLeft', 'arrowOffsetTop', 'arrowOffsetLeft', 'title', 'className', 'style', 'children']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _extends4['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), (_extends2 = {}, _extends2[placement] = true, _extends2));

        var outerStyle = (0, _extends4['default'])({
          display: 'block',
          top: positionTop,
          left: positionLeft
        }, style);

        var arrowStyle = {
          top: arrowOffsetTop,
          left: arrowOffsetLeft
        };

        return _react2['default'].createElement(
          'div',
          (0, _extends4['default'])({}, elementProps, {
            role: 'tooltip',
            className: (0, _classnames2['default'])(className, classes),
            style: outerStyle
          }),
          _react2['default'].createElement('div', { className: 'arrow', style: arrowStyle }),
          title && _react2['default'].createElement(
            'h3',
            { className: (0, _bootstrapUtils.prefix)(bsProps, 'title') },
            title
          ),
          _react2['default'].createElement(
            'div',
            { className: (0, _bootstrapUtils.prefix)(bsProps, 'content') },
            children
          )
        );
      };

      return Popover;
    }(_react2['default'].Component);

    Popover.propTypes = propTypes;
    Popover.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('popover', Popover);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/isRequiredForA11y":256}],80:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _values = require('babel-runtime/core-js/object/values');

    var _values2 = _interopRequireDefault(_values);

    var _extends3 = require('babel-runtime/helpers/extends');

    var _extends4 = _interopRequireDefault(_extends3);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _StyleConfig = require('./utils/StyleConfig');

    var _ValidComponentChildren = require('./utils/ValidComponentChildren');

    var _ValidComponentChildren2 = _interopRequireDefault(_ValidComponentChildren);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var ROUND_PRECISION = 1000;

    /**
     * Validate that children, if any, are instances of `<ProgressBar>`.
     */
    function onlyProgressBar(props, propName, componentName) {
      var children = props[propName];
      if (!children) {
        return null;
      }

      var error = null;

      _react2['default'].Children.forEach(children, function (child) {
        if (error) {
          return;
        }

        if (child.type === ProgressBar) {
          // eslint-disable-line no-use-before-define
          return;
        }

        var childIdentifier = _react2['default'].isValidElement(child) ? child.type.displayName || child.type.name || child.type : child;
        error = new Error('Children of ' + componentName + ' can contain only ProgressBar ' + ('components. Found ' + childIdentifier + '.'));
      });

      return error;
    }

    var propTypes = {
      min: _react.PropTypes.number,
      now: _react.PropTypes.number,
      max: _react.PropTypes.number,
      label: _react.PropTypes.node,
      srOnly: _react.PropTypes.bool,
      striped: _react.PropTypes.bool,
      active: _react.PropTypes.bool,
      children: onlyProgressBar,

      /**
       * @private
       */
      isChild: _react.PropTypes.bool
    };

    var defaultProps = {
      min: 0,
      max: 100,
      active: false,
      isChild: false,
      srOnly: false,
      striped: false
    };

    function getPercentage(now, min, max) {
      var percentage = (now - min) / (max - min) * 100;
      return Math.round(percentage * ROUND_PRECISION) / ROUND_PRECISION;
    }

    var ProgressBar = function (_React$Component) {
      (0, _inherits3['default'])(ProgressBar, _React$Component);

      function ProgressBar() {
        (0, _classCallCheck3['default'])(this, ProgressBar);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      ProgressBar.prototype.renderProgressBar = function renderProgressBar(_ref) {
        var _extends2;

        var min = _ref.min,
            now = _ref.now,
            max = _ref.max,
            label = _ref.label,
            srOnly = _ref.srOnly,
            striped = _ref.striped,
            active = _ref.active,
            className = _ref.className,
            style = _ref.style,
            props = (0, _objectWithoutProperties3['default'])(_ref, ['min', 'now', 'max', 'label', 'srOnly', 'striped', 'active', 'className', 'style']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _extends4['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), (_extends2 = {
          active: active
        }, _extends2[(0, _bootstrapUtils.prefix)(bsProps, 'striped')] = active || striped, _extends2));

        return _react2['default'].createElement(
          'div',
          (0, _extends4['default'])({}, elementProps, {
            role: 'progressbar',
            className: (0, _classnames2['default'])(className, classes),
            style: (0, _extends4['default'])({ width: getPercentage(now, min, max) + '%' }, style),
            'aria-valuenow': now,
            'aria-valuemin': min,
            'aria-valuemax': max
          }),
          srOnly ? _react2['default'].createElement(
            'span',
            { className: 'sr-only' },
            label
          ) : label
        );
      };

      ProgressBar.prototype.render = function render() {
        var _props = this.props,
            isChild = _props.isChild,
            props = (0, _objectWithoutProperties3['default'])(_props, ['isChild']);

        if (isChild) {
          return this.renderProgressBar(props);
        }

        var min = props.min,
            now = props.now,
            max = props.max,
            label = props.label,
            srOnly = props.srOnly,
            striped = props.striped,
            active = props.active,
            bsClass = props.bsClass,
            bsStyle = props.bsStyle,
            className = props.className,
            children = props.children,
            wrapperProps = (0, _objectWithoutProperties3['default'])(props, ['min', 'now', 'max', 'label', 'srOnly', 'striped', 'active', 'bsClass', 'bsStyle', 'className', 'children']);

        return _react2['default'].createElement(
          'div',
          (0, _extends4['default'])({}, wrapperProps, {
            className: (0, _classnames2['default'])(className, 'progress')
          }),
          children ? _ValidComponentChildren2['default'].map(children, function (child) {
            return (0, _react.cloneElement)(child, { isChild: true });
          }) : this.renderProgressBar({
            min: min, now: now, max: max, label: label, srOnly: srOnly, striped: striped, active: active, bsClass: bsClass, bsStyle: bsStyle
          })
        );
      };

      return ProgressBar;
    }(_react2['default'].Component);

    ProgressBar.propTypes = propTypes;
    ProgressBar.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('progress-bar', (0, _bootstrapUtils.bsStyles)((0, _values2['default'])(_StyleConfig.State), ProgressBar));
    module.exports = exports['default'];

    },{"./utils/StyleConfig":98,"./utils/ValidComponentChildren":100,"./utils/bootstrapUtils":101,"babel-runtime/core-js/object/values":112,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],81:[function(require,module,exports){
    (function (process){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _warning = require('warning');

    var _warning2 = _interopRequireDefault(_warning);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      inline: _react2['default'].PropTypes.bool,
      disabled: _react2['default'].PropTypes.bool,
      /**
       * Only valid if `inline` is not set.
       */
      validationState: _react2['default'].PropTypes.oneOf(['success', 'warning', 'error', null]),
      /**
       * Attaches a ref to the `<input>` element. Only functions can be used here.
       *
       * ```js
       * <Radio inputRef={ref => { this.input = ref; }} />
       * ```
       */
      inputRef: _react2['default'].PropTypes.func
    };

    var defaultProps = {
      inline: false,
      disabled: false
    };

    var Radio = function (_React$Component) {
      (0, _inherits3['default'])(Radio, _React$Component);

      function Radio() {
        (0, _classCallCheck3['default'])(this, Radio);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Radio.prototype.render = function render() {
        var _props = this.props,
            inline = _props.inline,
            disabled = _props.disabled,
            validationState = _props.validationState,
            inputRef = _props.inputRef,
            className = _props.className,
            style = _props.style,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['inline', 'disabled', 'validationState', 'inputRef', 'className', 'style', 'children']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var input = _react2['default'].createElement('input', (0, _extends3['default'])({}, elementProps, {
          ref: inputRef,
          type: 'radio',
          disabled: disabled
        }));

        if (inline) {
          var _classes2;

          var _classes = (_classes2 = {}, _classes2[(0, _bootstrapUtils.prefix)(bsProps, 'inline')] = true, _classes2.disabled = disabled, _classes2);

          // Use a warning here instead of in propTypes to get better-looking
          // generated documentation.
          process.env.NODE_ENV !== 'production' ? (0, _warning2['default'])(!validationState, '`validationState` is ignored on `<Radio inline>`. To display ' + 'validation state on an inline radio, set `validationState` on a ' + 'parent `<FormGroup>` or other element instead.') : void 0;

          return _react2['default'].createElement(
            'label',
            { className: (0, _classnames2['default'])(className, _classes), style: style },
            input,
            children
          );
        }

        var classes = (0, _extends3['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), {
          disabled: disabled
        });
        if (validationState) {
          classes['has-' + validationState] = true;
        }

        return _react2['default'].createElement(
          'div',
          { className: (0, _classnames2['default'])(className, classes), style: style },
          _react2['default'].createElement(
            'label',
            null,
            input,
            children
          )
        );
      };

      return Radio;
    }(_react2['default'].Component);

    Radio.propTypes = propTypes;
    Radio.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('radio', Radio);
    module.exports = exports['default'];

    }).call(this,require('_process'))
    },{"./utils/bootstrapUtils":101,"_process":728,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"warning":261}],82:[function(require,module,exports){
    (function (process){
    'use strict';

    exports.__esModule = true;

    var _extends3 = require('babel-runtime/helpers/extends');

    var _extends4 = _interopRequireDefault(_extends3);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _warning = require('warning');

    var _warning2 = _interopRequireDefault(_warning);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    // TODO: This should probably take a single `aspectRatio` prop.

    var propTypes = {
      /**
       * This component requires a single child element
       */
      children: _react.PropTypes.element.isRequired,
      /**
       * 16by9 aspect ratio
       */
      a16by9: _react.PropTypes.bool,
      /**
       * 4by3 aspect ratio
       */
      a4by3: _react.PropTypes.bool
    };

    var defaultProps = {
      a16by9: false,
      a4by3: false
    };

    var ResponsiveEmbed = function (_React$Component) {
      (0, _inherits3['default'])(ResponsiveEmbed, _React$Component);

      function ResponsiveEmbed() {
        (0, _classCallCheck3['default'])(this, ResponsiveEmbed);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      ResponsiveEmbed.prototype.render = function render() {
        var _extends2;

        var _props = this.props,
            a16by9 = _props.a16by9,
            a4by3 = _props.a4by3,
            className = _props.className,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['a16by9', 'a4by3', 'className', 'children']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        process.env.NODE_ENV !== 'production' ? (0, _warning2['default'])(a16by9 || a4by3, 'Either `a16by9` or `a4by3` must be set.') : void 0;
        process.env.NODE_ENV !== 'production' ? (0, _warning2['default'])(!(a16by9 && a4by3), 'Only one of `a16by9` or `a4by3` can be set.') : void 0;

        var classes = (0, _extends4['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), (_extends2 = {}, _extends2[(0, _bootstrapUtils.prefix)(bsProps, '16by9')] = a16by9, _extends2[(0, _bootstrapUtils.prefix)(bsProps, '4by3')] = a4by3, _extends2));

        return _react2['default'].createElement(
          'div',
          { className: (0, _classnames2['default'])(classes) },
          (0, _react.cloneElement)(children, (0, _extends4['default'])({}, elementProps, {
            className: (0, _classnames2['default'])(className, (0, _bootstrapUtils.prefix)(bsProps, 'item'))
          }))
        );
      };

      return ResponsiveEmbed;
    }(_react2['default'].Component);

    ResponsiveEmbed.propTypes = propTypes;
    ResponsiveEmbed.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('embed-responsive', ResponsiveEmbed);
    module.exports = exports['default'];

    }).call(this,require('_process'))
    },{"./utils/bootstrapUtils":101,"_process":728,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"warning":261}],83:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      componentClass: _elementType2['default']
    };

    var defaultProps = {
      componentClass: 'div'
    };

    var Row = function (_React$Component) {
      (0, _inherits3['default'])(Row, _React$Component);

      function Row() {
        (0, _classCallCheck3['default'])(this, Row);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Row.prototype.render = function render() {
        var _props = this.props,
            Component = _props.componentClass,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['componentClass', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement(Component, (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return Row;
    }(_react2['default'].Component);

    Row.propTypes = propTypes;
    Row.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('row', Row);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255}],84:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      href: _react2['default'].PropTypes.string,
      onClick: _react2['default'].PropTypes.func,
      disabled: _react2['default'].PropTypes.bool,
      role: _react2['default'].PropTypes.string,
      tabIndex: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.number, _react2['default'].PropTypes.string]),
      /**
       * this is sort of silly but needed for Button
       */
      componentClass: _elementType2['default']
    };

    var defaultProps = {
      componentClass: 'a'
    };

    function isTrivialHref(href) {
      return !href || href.trim() === '#';
    }

    /**
     * There are situations due to browser quirks or Bootstrap CSS where
     * an anchor tag is needed, when semantically a button tag is the
     * better choice. SafeAnchor ensures that when an anchor is used like a
     * button its accessible. It also emulates input `disabled` behavior for
     * links, which is usually desirable for Buttons, NavItems, MenuItems, etc.
     */

    var SafeAnchor = function (_React$Component) {
      (0, _inherits3['default'])(SafeAnchor, _React$Component);

      function SafeAnchor(props, context) {
        (0, _classCallCheck3['default'])(this, SafeAnchor);

        var _this = (0, _possibleConstructorReturn3['default'])(this, _React$Component.call(this, props, context));

        _this.handleClick = _this.handleClick.bind(_this);
        return _this;
      }

      SafeAnchor.prototype.handleClick = function handleClick(event) {
        var _props = this.props,
            disabled = _props.disabled,
            href = _props.href,
            onClick = _props.onClick;

        if (disabled || isTrivialHref(href)) {
          event.preventDefault();
        }

        if (disabled) {
          event.stopPropagation();
          return;
        }

        if (onClick) {
          onClick(event);
        }
      };

      SafeAnchor.prototype.render = function render() {
        var _props2 = this.props,
            Component = _props2.componentClass,
            disabled = _props2.disabled,
            props = (0, _objectWithoutProperties3['default'])(_props2, ['componentClass', 'disabled']);

        if (isTrivialHref(props.href)) {
          props.role = props.role || 'button';
          // we want to make sure there is a href attribute on the node
          // otherwise, the cursor incorrectly styled (except with role='button')
          props.href = props.href || '#';
        }

        if (disabled) {
          props.tabIndex = -1;
          props.style = (0, _extends3['default'])({ pointerEvents: 'none' }, props.style);
        }

        return _react2['default'].createElement(Component, (0, _extends3['default'])({}, props, {
          onClick: this.handleClick
        }));
      };

      return SafeAnchor;
    }(_react2['default'].Component);

    SafeAnchor.propTypes = propTypes;
    SafeAnchor.defaultProps = defaultProps;

    exports['default'] = SafeAnchor;
    module.exports = exports['default'];

    },{"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"react":618,"react-prop-types/lib/elementType":255}],85:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _Button = require('./Button');

    var _Button2 = _interopRequireDefault(_Button);

    var _Dropdown = require('./Dropdown');

    var _Dropdown2 = _interopRequireDefault(_Dropdown);

    var _SplitToggle = require('./SplitToggle');

    var _SplitToggle2 = _interopRequireDefault(_SplitToggle);

    var _splitComponentProps2 = require('./utils/splitComponentProps');

    var _splitComponentProps3 = _interopRequireDefault(_splitComponentProps2);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = (0, _extends3['default'])({}, _Dropdown2['default'].propTypes, {

      // Toggle props.
      bsStyle: _react2['default'].PropTypes.string,
      bsSize: _react2['default'].PropTypes.string,
      href: _react2['default'].PropTypes.string,
      onClick: _react2['default'].PropTypes.func,
      /**
       * The content of the split button.
       */
      title: _react2['default'].PropTypes.node.isRequired,
      /**
       * Accessible label for the toggle; the value of `title` if not specified.
       */
      toggleLabel: _react2['default'].PropTypes.string,

      // Override generated docs from <Dropdown>.
      /**
       * @private
       */
      children: _react2['default'].PropTypes.node
    });

    var SplitButton = function (_React$Component) {
      (0, _inherits3['default'])(SplitButton, _React$Component);

      function SplitButton() {
        (0, _classCallCheck3['default'])(this, SplitButton);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      SplitButton.prototype.render = function render() {
        var _props = this.props,
            bsSize = _props.bsSize,
            bsStyle = _props.bsStyle,
            title = _props.title,
            toggleLabel = _props.toggleLabel,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['bsSize', 'bsStyle', 'title', 'toggleLabel', 'children']);

        var _splitComponentProps = (0, _splitComponentProps3['default'])(props, _Dropdown2['default'].ControlledComponent),
            dropdownProps = _splitComponentProps[0],
            buttonProps = _splitComponentProps[1];

        return _react2['default'].createElement(
          _Dropdown2['default'],
          (0, _extends3['default'])({}, dropdownProps, {
            bsSize: bsSize,
            bsStyle: bsStyle
          }),
          _react2['default'].createElement(
            _Button2['default'],
            (0, _extends3['default'])({}, buttonProps, {
              disabled: props.disabled,
              bsSize: bsSize,
              bsStyle: bsStyle
            }),
            title
          ),
          _react2['default'].createElement(_SplitToggle2['default'], {
            'aria-label': toggleLabel || title,
            bsSize: bsSize,
            bsStyle: bsStyle
          }),
          _react2['default'].createElement(
            _Dropdown2['default'].Menu,
            null,
            children
          )
        );
      };

      return SplitButton;
    }(_react2['default'].Component);

    SplitButton.propTypes = propTypes;

    SplitButton.Toggle = _SplitToggle2['default'];

    exports['default'] = SplitButton;
    module.exports = exports['default'];

    },{"./Button":15,"./Dropdown":26,"./SplitToggle":86,"./utils/splitComponentProps":106,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"react":618}],86:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _DropdownToggle = require('./DropdownToggle');

    var _DropdownToggle2 = _interopRequireDefault(_DropdownToggle);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var SplitToggle = function (_React$Component) {
      (0, _inherits3['default'])(SplitToggle, _React$Component);

      function SplitToggle() {
        (0, _classCallCheck3['default'])(this, SplitToggle);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      SplitToggle.prototype.render = function render() {
        return _react2['default'].createElement(_DropdownToggle2['default'], (0, _extends3['default'])({}, this.props, {
          useAnchor: false,
          noCaret: false
        }));
      };

      return SplitToggle;
    }(_react2['default'].Component);

    SplitToggle.defaultProps = _DropdownToggle2['default'].defaultProps;

    exports['default'] = SplitToggle;
    module.exports = exports['default'];

    },{"./DropdownToggle":29,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/possibleConstructorReturn":119,"react":618}],87:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _TabContainer = require('./TabContainer');

    var _TabContainer2 = _interopRequireDefault(_TabContainer);

    var _TabContent = require('./TabContent');

    var _TabContent2 = _interopRequireDefault(_TabContent);

    var _TabPane = require('./TabPane');

    var _TabPane2 = _interopRequireDefault(_TabPane);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = (0, _extends3['default'])({}, _TabPane2['default'].propTypes, {

      disabled: _react2['default'].PropTypes.bool,

      title: _react2['default'].PropTypes.node,

      /**
       * tabClassName is used as className for the associated NavItem
       */
      tabClassName: _react2['default'].PropTypes.string
    });

    var Tab = function (_React$Component) {
      (0, _inherits3['default'])(Tab, _React$Component);

      function Tab() {
        (0, _classCallCheck3['default'])(this, Tab);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Tab.prototype.render = function render() {
        var props = (0, _extends3['default'])({}, this.props);

        // These props are for the parent `<Tabs>` rather than the `<TabPane>`.
        delete props.title;
        delete props.disabled;
        delete props.tabClassName;

        return _react2['default'].createElement(_TabPane2['default'], props);
      };

      return Tab;
    }(_react2['default'].Component);

    Tab.propTypes = propTypes;

    Tab.Container = _TabContainer2['default'];
    Tab.Content = _TabContent2['default'];
    Tab.Pane = _TabPane2['default'];

    exports['default'] = Tab;
    module.exports = exports['default'];

    },{"./TabContainer":88,"./TabContent":89,"./TabPane":90,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/possibleConstructorReturn":119,"react":618}],88:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _uncontrollable = require('uncontrollable');

    var _uncontrollable2 = _interopRequireDefault(_uncontrollable);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var TAB = 'tab';
    var PANE = 'pane';

    var idPropType = _react.PropTypes.oneOfType([_react.PropTypes.string, _react.PropTypes.number]);

    var propTypes = {
      /**
       * HTML id attribute, required if no `generateChildId` prop
       * is specified.
       */
      id: function id(props) {
        var error = null;

        if (!props.generateChildId) {
          for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
            args[_key - 1] = arguments[_key];
          }

          error = idPropType.apply(undefined, [props].concat(args));

          if (!error && !props.id) {
            error = new Error('In order to properly initialize Tabs in a way that is accessible ' + 'to assistive technologies (such as screen readers) an `id` or a ' + '`generateChildId` prop to TabContainer is required');
          }
        }

        return error;
      },

      /**
       * A function that takes an `eventKey` and `type` and returns a unique id for
       * child tab `<NavItem>`s and `<TabPane>`s. The function _must_ be a pure
       * function, meaning it should always return the _same_ id for the same set
       * of inputs. The default value requires that an `id` to be set for the
       * `<TabContainer>`.
       *
       * The `type` argument will either be `"tab"` or `"pane"`.
       *
       * @defaultValue (eventKey, type) => `${this.props.id}-${type}-${key}`
       */
      generateChildId: _react.PropTypes.func,

      /**
       * A callback fired when a tab is selected.
       *
       * @controllable activeKey
       */
      onSelect: _react.PropTypes.func,

      /**
       * The `eventKey` of the currently active tab.
       *
       * @controllable onSelect
       */
      activeKey: _react.PropTypes.any
    };

    var childContextTypes = {
      $bs_tabContainer: _react2['default'].PropTypes.shape({
        activeKey: _react.PropTypes.any,
        onSelect: _react.PropTypes.func.isRequired,
        getTabId: _react.PropTypes.func.isRequired,
        getPaneId: _react.PropTypes.func.isRequired
      })
    };

    var TabContainer = function (_React$Component) {
      (0, _inherits3['default'])(TabContainer, _React$Component);

      function TabContainer() {
        (0, _classCallCheck3['default'])(this, TabContainer);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      TabContainer.prototype.getChildContext = function getChildContext() {
        var _props = this.props,
            activeKey = _props.activeKey,
            onSelect = _props.onSelect,
            generateChildId = _props.generateChildId,
            id = _props.id;

        var getId = generateChildId || function (key, type) {
          return id ? id + '-' + type + '-' + key : null;
        };

        return {
          $bs_tabContainer: {
            activeKey: activeKey,
            onSelect: onSelect,
            getTabId: function getTabId(key) {
              return getId(key, TAB);
            },
            getPaneId: function getPaneId(key) {
              return getId(key, PANE);
            }
          }
        };
      };

      TabContainer.prototype.render = function render() {
        var _props2 = this.props,
            children = _props2.children,
            props = (0, _objectWithoutProperties3['default'])(_props2, ['children']);

        delete props.generateChildId;
        delete props.onSelect;
        delete props.activeKey;

        return _react2['default'].cloneElement(_react2['default'].Children.only(children), props);
      };

      return TabContainer;
    }(_react2['default'].Component);

    TabContainer.propTypes = propTypes;
    TabContainer.childContextTypes = childContextTypes;

    exports['default'] = (0, _uncontrollable2['default'])(TabContainer, { activeKey: 'onSelect' });
    module.exports = exports['default'];

    },{"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"react":618,"uncontrollable":259}],89:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      componentClass: _elementType2['default'],

      /**
       * Sets a default animation strategy for all children `<TabPane>`s. Use
       * `false` to disable, `true` to enable the default `<Fade>` animation or any
       * `<Transition>` component.
       */
      animation: _react.PropTypes.oneOfType([_react.PropTypes.bool, _elementType2['default']]),

      /**
       * Unmount tabs (remove it from the DOM) when they are no longer visible
       */
      unmountOnExit: _react.PropTypes.bool
    };

    var defaultProps = {
      componentClass: 'div',
      animation: true,
      unmountOnExit: false
    };

    var contextTypes = {
      $bs_tabContainer: _react.PropTypes.shape({
        activeKey: _react.PropTypes.any
      })
    };

    var childContextTypes = {
      $bs_tabContent: _react.PropTypes.shape({
        bsClass: _react.PropTypes.string,
        animation: _react.PropTypes.oneOfType([_react.PropTypes.bool, _elementType2['default']]),
        activeKey: _react.PropTypes.any,
        unmountOnExit: _react.PropTypes.bool,
        onPaneEnter: _react.PropTypes.func.isRequired,
        onPaneExited: _react.PropTypes.func.isRequired,
        exiting: _react.PropTypes.bool.isRequired
      })
    };

    var TabContent = function (_React$Component) {
      (0, _inherits3['default'])(TabContent, _React$Component);

      function TabContent(props, context) {
        (0, _classCallCheck3['default'])(this, TabContent);

        var _this = (0, _possibleConstructorReturn3['default'])(this, _React$Component.call(this, props, context));

        _this.handlePaneEnter = _this.handlePaneEnter.bind(_this);
        _this.handlePaneExited = _this.handlePaneExited.bind(_this);

        // Active entries in state will be `null` unless `animation` is set. Need
        // to track active child in case keys swap and the active child changes
        // but the active key does not.
        _this.state = {
          activeKey: null,
          activeChild: null
        };
        return _this;
      }

      TabContent.prototype.getChildContext = function getChildContext() {
        var _props = this.props,
            bsClass = _props.bsClass,
            animation = _props.animation,
            unmountOnExit = _props.unmountOnExit;

        var stateActiveKey = this.state.activeKey;
        var containerActiveKey = this.getContainerActiveKey();

        var activeKey = stateActiveKey != null ? stateActiveKey : containerActiveKey;
        var exiting = stateActiveKey != null && stateActiveKey !== containerActiveKey;

        return {
          $bs_tabContent: {
            bsClass: bsClass,
            animation: animation,
            activeKey: activeKey,
            unmountOnExit: unmountOnExit,
            onPaneEnter: this.handlePaneEnter,
            onPaneExited: this.handlePaneExited,
            exiting: exiting
          }
        };
      };

      TabContent.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
        if (!nextProps.animation && this.state.activeChild) {
          this.setState({ activeKey: null, activeChild: null });
        }
      };

      TabContent.prototype.componentWillUnmount = function componentWillUnmount() {
        this.isUnmounted = true;
      };

      TabContent.prototype.handlePaneEnter = function handlePaneEnter(child, childKey) {
        if (!this.props.animation) {
          return false;
        }

        // It's possible that this child should be transitioning out.
        if (childKey !== this.getContainerActiveKey()) {
          return false;
        }

        this.setState({
          activeKey: childKey,
          activeChild: child
        });

        return true;
      };

      TabContent.prototype.handlePaneExited = function handlePaneExited(child) {
        // This might happen as everything is unmounting.
        if (this.isUnmounted) {
          return;
        }

        this.setState(function (_ref) {
          var activeChild = _ref.activeChild;

          if (activeChild !== child) {
            return null;
          }

          return {
            activeKey: null,
            activeChild: null
          };
        });
      };

      TabContent.prototype.getContainerActiveKey = function getContainerActiveKey() {
        var tabContainer = this.context.$bs_tabContainer;
        return tabContainer && tabContainer.activeKey;
      };

      TabContent.prototype.render = function render() {
        var _props2 = this.props,
            Component = _props2.componentClass,
            className = _props2.className,
            props = (0, _objectWithoutProperties3['default'])(_props2, ['componentClass', 'className']);

        var _splitBsPropsAndOmit = (0, _bootstrapUtils.splitBsPropsAndOmit)(props, ['animation', 'unmountOnExit']),
            bsProps = _splitBsPropsAndOmit[0],
            elementProps = _splitBsPropsAndOmit[1];

        return _react2['default'].createElement(Component, (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, (0, _bootstrapUtils.prefix)(bsProps, 'content'))
        }));
      };

      return TabContent;
    }(_react2['default'].Component);

    TabContent.propTypes = propTypes;
    TabContent.defaultProps = defaultProps;
    TabContent.contextTypes = contextTypes;
    TabContent.childContextTypes = childContextTypes;

    exports['default'] = (0, _bootstrapUtils.bsClass)('tab', TabContent);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255}],90:[function(require,module,exports){
    (function (process){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _warning = require('warning');

    var _warning2 = _interopRequireDefault(_warning);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _createChainedFunction = require('./utils/createChainedFunction');

    var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);

    var _Fade = require('./Fade');

    var _Fade2 = _interopRequireDefault(_Fade);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      /**
       * Uniquely identify the `<TabPane>` among its siblings.
       */
      eventKey: _react.PropTypes.any,

      /**
       * Use animation when showing or hiding `<TabPane>`s. Use `false` to disable,
       * `true` to enable the default `<Fade>` animation or any `<Transition>`
       * component.
       */
      animation: _react.PropTypes.oneOfType([_react.PropTypes.bool, _elementType2['default']]),

      /** @private **/
      id: _react.PropTypes.string,

      /** @private **/
      'aria-labelledby': _react.PropTypes.string,

      /**
       * If not explicitly specified and rendered in the context of a
       * `<TabContent>`, the `bsClass` of the `<TabContent>` suffixed by `-pane`.
       * If otherwise not explicitly specified, `tab-pane`.
       */
      bsClass: _react2['default'].PropTypes.string,

      /**
       * Transition onEnter callback when animation is not `false`
       */
      onEnter: _react.PropTypes.func,

      /**
       * Transition onEntering callback when animation is not `false`
       */
      onEntering: _react.PropTypes.func,

      /**
       * Transition onEntered callback when animation is not `false`
       */
      onEntered: _react.PropTypes.func,

      /**
       * Transition onExit callback when animation is not `false`
       */
      onExit: _react.PropTypes.func,

      /**
       * Transition onExiting callback when animation is not `false`
       */
      onExiting: _react.PropTypes.func,

      /**
       * Transition onExited callback when animation is not `false`
       */
      onExited: _react.PropTypes.func,

      /**
       * Unmount the tab (remove it from the DOM) when it is no longer visible
       */
      unmountOnExit: _react.PropTypes.bool
    };

    var contextTypes = {
      $bs_tabContainer: _react.PropTypes.shape({
        getId: _react.PropTypes.func,
        unmountOnExit: _react.PropTypes.bool
      }),
      $bs_tabContent: _react.PropTypes.shape({
        bsClass: _react.PropTypes.string,
        animation: _react.PropTypes.oneOfType([_react.PropTypes.bool, _elementType2['default']]),
        activeKey: _react.PropTypes.any,
        unmountOnExit: _react.PropTypes.bool,
        onPaneEnter: _react.PropTypes.func.isRequired,
        onPaneExited: _react.PropTypes.func.isRequired,
        exiting: _react.PropTypes.bool.isRequired
      })
    };

    /**
     * We override the `<TabContainer>` context so `<Nav>`s in `<TabPane>`s don't
     * conflict with the top level one.
     */
    var childContextTypes = {
      $bs_tabContainer: _react.PropTypes.oneOf([null])
    };

    var TabPane = function (_React$Component) {
      (0, _inherits3['default'])(TabPane, _React$Component);

      function TabPane(props, context) {
        (0, _classCallCheck3['default'])(this, TabPane);

        var _this = (0, _possibleConstructorReturn3['default'])(this, _React$Component.call(this, props, context));

        _this.handleEnter = _this.handleEnter.bind(_this);
        _this.handleExited = _this.handleExited.bind(_this);

        _this['in'] = false;
        return _this;
      }

      TabPane.prototype.getChildContext = function getChildContext() {
        return {
          $bs_tabContainer: null
        };
      };

      TabPane.prototype.componentDidMount = function componentDidMount() {
        if (this.shouldBeIn()) {
          // In lieu of the action event firing.
          this.handleEnter();
        }
      };

      TabPane.prototype.componentDidUpdate = function componentDidUpdate() {
        if (this['in']) {
          if (!this.shouldBeIn()) {
            // We shouldn't be active any more. Notify the parent.
            this.handleExited();
          }
        } else if (this.shouldBeIn()) {
          // We are the active child. Notify the parent.
          this.handleEnter();
        }
      };

      TabPane.prototype.componentWillUnmount = function componentWillUnmount() {
        if (this['in']) {
          // In lieu of the action event firing.
          this.handleExited();
        }
      };

      TabPane.prototype.handleEnter = function handleEnter() {
        var tabContent = this.context.$bs_tabContent;
        if (!tabContent) {
          return;
        }

        this['in'] = tabContent.onPaneEnter(this, this.props.eventKey);
      };

      TabPane.prototype.handleExited = function handleExited() {
        var tabContent = this.context.$bs_tabContent;
        if (!tabContent) {
          return;
        }

        tabContent.onPaneExited(this);
        this['in'] = false;
      };

      TabPane.prototype.getAnimation = function getAnimation() {
        if (this.props.animation != null) {
          return this.props.animation;
        }

        var tabContent = this.context.$bs_tabContent;
        return tabContent && tabContent.animation;
      };

      TabPane.prototype.isActive = function isActive() {
        var tabContent = this.context.$bs_tabContent;
        var activeKey = tabContent && tabContent.activeKey;

        return this.props.eventKey === activeKey;
      };

      TabPane.prototype.shouldBeIn = function shouldBeIn() {
        return this.getAnimation() && this.isActive();
      };

      TabPane.prototype.render = function render() {
        var _props = this.props,
            eventKey = _props.eventKey,
            className = _props.className,
            onEnter = _props.onEnter,
            onEntering = _props.onEntering,
            onEntered = _props.onEntered,
            onExit = _props.onExit,
            onExiting = _props.onExiting,
            onExited = _props.onExited,
            propsUnmountOnExit = _props.unmountOnExit,
            props = (0, _objectWithoutProperties3['default'])(_props, ['eventKey', 'className', 'onEnter', 'onEntering', 'onEntered', 'onExit', 'onExiting', 'onExited', 'unmountOnExit']);
        var _context = this.context,
            tabContent = _context.$bs_tabContent,
            tabContainer = _context.$bs_tabContainer;

        var _splitBsPropsAndOmit = (0, _bootstrapUtils.splitBsPropsAndOmit)(props, ['animation']),
            bsProps = _splitBsPropsAndOmit[0],
            elementProps = _splitBsPropsAndOmit[1];

        var active = this.isActive();
        var animation = this.getAnimation();

        var unmountOnExit = propsUnmountOnExit != null ? propsUnmountOnExit : tabContent && tabContent.unmountOnExit;

        if (!active && !animation && unmountOnExit) {
          return null;
        }

        var Transition = animation === true ? _Fade2['default'] : animation || null;

        if (tabContent) {
          bsProps.bsClass = (0, _bootstrapUtils.prefix)(tabContent, 'pane');
        }

        var classes = (0, _extends3['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), {
          active: active
        });

        if (tabContainer) {
          process.env.NODE_ENV !== 'production' ? (0, _warning2['default'])(!elementProps.id && !elementProps['aria-labelledby'], 'In the context of a `<TabContainer>`, `<TabPanes>` are given ' + 'generated `id` and `aria-labelledby` attributes for the sake of ' + 'proper component accessibility. Any provided ones will be ignored. ' + 'To control these attributes directly provide a `generateChildId` ' + 'prop to the parent `<TabContainer>`.') : void 0;

          elementProps.id = tabContainer.getPaneId(eventKey);
          elementProps['aria-labelledby'] = tabContainer.getTabId(eventKey);
        }

        var pane = _react2['default'].createElement('div', (0, _extends3['default'])({}, elementProps, {
          role: 'tabpanel',
          'aria-hidden': !active,
          className: (0, _classnames2['default'])(className, classes)
        }));

        if (Transition) {
          var exiting = tabContent && tabContent.exiting;

          return _react2['default'].createElement(
            Transition,
            {
              'in': active && !exiting,
              onEnter: (0, _createChainedFunction2['default'])(this.handleEnter, onEnter),
              onEntering: onEntering,
              onEntered: onEntered,
              onExit: onExit,
              onExiting: onExiting,
              onExited: (0, _createChainedFunction2['default'])(this.handleExited, onExited),
              unmountOnExit: unmountOnExit
            },
            pane
          );
        }

        return pane;
      };

      return TabPane;
    }(_react2['default'].Component);

    TabPane.propTypes = propTypes;
    TabPane.contextTypes = contextTypes;
    TabPane.childContextTypes = childContextTypes;

    exports['default'] = (0, _bootstrapUtils.bsClass)('tab-pane', TabPane);
    module.exports = exports['default'];

    }).call(this,require('_process'))
    },{"./Fade":30,"./utils/bootstrapUtils":101,"./utils/createChainedFunction":103,"_process":728,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/elementType":255,"warning":261}],91:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends3 = require('babel-runtime/helpers/extends');

    var _extends4 = _interopRequireDefault(_extends3);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      striped: _react2['default'].PropTypes.bool,
      bordered: _react2['default'].PropTypes.bool,
      condensed: _react2['default'].PropTypes.bool,
      hover: _react2['default'].PropTypes.bool,
      responsive: _react2['default'].PropTypes.bool
    };

    var defaultProps = {
      bordered: false,
      condensed: false,
      hover: false,
      responsive: false,
      striped: false
    };

    var Table = function (_React$Component) {
      (0, _inherits3['default'])(Table, _React$Component);

      function Table() {
        (0, _classCallCheck3['default'])(this, Table);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Table.prototype.render = function render() {
        var _extends2;

        var _props = this.props,
            striped = _props.striped,
            bordered = _props.bordered,
            condensed = _props.condensed,
            hover = _props.hover,
            responsive = _props.responsive,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['striped', 'bordered', 'condensed', 'hover', 'responsive', 'className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _extends4['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), (_extends2 = {}, _extends2[(0, _bootstrapUtils.prefix)(bsProps, 'striped')] = striped, _extends2[(0, _bootstrapUtils.prefix)(bsProps, 'bordered')] = bordered, _extends2[(0, _bootstrapUtils.prefix)(bsProps, 'condensed')] = condensed, _extends2[(0, _bootstrapUtils.prefix)(bsProps, 'hover')] = hover, _extends2));

        var table = _react2['default'].createElement('table', (0, _extends4['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));

        if (responsive) {
          return _react2['default'].createElement(
            'div',
            { className: (0, _bootstrapUtils.prefix)(bsProps, 'responsive') },
            table
          );
        }

        return table;
      };

      return Table;
    }(_react2['default'].Component);

    Table.propTypes = propTypes;
    Table.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('table', Table);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],92:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _isRequiredForA11y = require('react-prop-types/lib/isRequiredForA11y');

    var _isRequiredForA11y2 = _interopRequireDefault(_isRequiredForA11y);

    var _uncontrollable = require('uncontrollable');

    var _uncontrollable2 = _interopRequireDefault(_uncontrollable);

    var _Nav = require('./Nav');

    var _Nav2 = _interopRequireDefault(_Nav);

    var _NavItem = require('./NavItem');

    var _NavItem2 = _interopRequireDefault(_NavItem);

    var _TabContainer = require('./TabContainer');

    var _TabContainer2 = _interopRequireDefault(_TabContainer);

    var _TabContent = require('./TabContent');

    var _TabContent2 = _interopRequireDefault(_TabContent);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _ValidComponentChildren = require('./utils/ValidComponentChildren');

    var _ValidComponentChildren2 = _interopRequireDefault(_ValidComponentChildren);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var TabContainer = _TabContainer2['default'].ControlledComponent;

    var propTypes = {
      /**
       * Mark the Tab with a matching `eventKey` as active.
       *
       * @controllable onSelect
       */
      activeKey: _react2['default'].PropTypes.any,

      /**
       * Navigation style
       */
      bsStyle: _react2['default'].PropTypes.oneOf(['tabs', 'pills']),

      animation: _react2['default'].PropTypes.bool,

      id: (0, _isRequiredForA11y2['default'])(_react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number])),

      /**
       * Callback fired when a Tab is selected.
       *
       * ```js
       * function (
       * 	Any eventKey,
       * 	SyntheticEvent event?
       * )
       * ```
       *
       * @controllable activeKey
       */
      onSelect: _react2['default'].PropTypes.func,

      /**
       * Unmount tabs (remove it from the DOM) when it is no longer visible
       */
      unmountOnExit: _react2['default'].PropTypes.bool
    };

    var defaultProps = {
      bsStyle: 'tabs',
      animation: true,
      unmountOnExit: false
    };

    function getDefaultActiveKey(children) {
      var defaultActiveKey = void 0;
      _ValidComponentChildren2['default'].forEach(children, function (child) {
        if (defaultActiveKey == null) {
          defaultActiveKey = child.props.eventKey;
        }
      });

      return defaultActiveKey;
    }

    var Tabs = function (_React$Component) {
      (0, _inherits3['default'])(Tabs, _React$Component);

      function Tabs() {
        (0, _classCallCheck3['default'])(this, Tabs);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Tabs.prototype.renderTab = function renderTab(child) {
        var _child$props = child.props,
            title = _child$props.title,
            eventKey = _child$props.eventKey,
            disabled = _child$props.disabled,
            tabClassName = _child$props.tabClassName;

        if (title == null) {
          return null;
        }

        return _react2['default'].createElement(
          _NavItem2['default'],
          {
            eventKey: eventKey,
            disabled: disabled,
            className: tabClassName
          },
          title
        );
      };

      Tabs.prototype.render = function render() {
        var _props = this.props,
            id = _props.id,
            onSelect = _props.onSelect,
            animation = _props.animation,
            unmountOnExit = _props.unmountOnExit,
            bsClass = _props.bsClass,
            className = _props.className,
            style = _props.style,
            children = _props.children,
            _props$activeKey = _props.activeKey,
            activeKey = _props$activeKey === undefined ? getDefaultActiveKey(children) : _props$activeKey,
            props = (0, _objectWithoutProperties3['default'])(_props, ['id', 'onSelect', 'animation', 'unmountOnExit', 'bsClass', 'className', 'style', 'children', 'activeKey']);

        return _react2['default'].createElement(
          TabContainer,
          {
            id: id,
            activeKey: activeKey,
            onSelect: onSelect,
            className: className,
            style: style
          },
          _react2['default'].createElement(
            'div',
            null,
            _react2['default'].createElement(
              _Nav2['default'],
              (0, _extends3['default'])({}, props, {
                role: 'tablist'
              }),
              _ValidComponentChildren2['default'].map(children, this.renderTab)
            ),
            _react2['default'].createElement(
              _TabContent2['default'],
              {
                bsClass: bsClass,
                animation: animation,
                unmountOnExit: unmountOnExit
              },
              children
            )
          )
        );
      };

      return Tabs;
    }(_react2['default'].Component);

    Tabs.propTypes = propTypes;
    Tabs.defaultProps = defaultProps;

    (0, _bootstrapUtils.bsClass)('tab', Tabs);

    exports['default'] = (0, _uncontrollable2['default'])(Tabs, { activeKey: 'onSelect' });
    module.exports = exports['default'];

    },{"./Nav":61,"./NavItem":63,"./TabContainer":88,"./TabContent":89,"./utils/ValidComponentChildren":100,"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"react":618,"react-prop-types/lib/isRequiredForA11y":256,"uncontrollable":259}],93:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _SafeAnchor = require('./SafeAnchor');

    var _SafeAnchor2 = _interopRequireDefault(_SafeAnchor);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      src: _react2['default'].PropTypes.string,
      alt: _react2['default'].PropTypes.string,
      href: _react2['default'].PropTypes.string
    };

    var Thumbnail = function (_React$Component) {
      (0, _inherits3['default'])(Thumbnail, _React$Component);

      function Thumbnail() {
        (0, _classCallCheck3['default'])(this, Thumbnail);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Thumbnail.prototype.render = function render() {
        var _props = this.props,
            src = _props.src,
            alt = _props.alt,
            className = _props.className,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['src', 'alt', 'className', 'children']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var Component = elementProps.href ? _SafeAnchor2['default'] : 'div';
        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement(
          Component,
          (0, _extends3['default'])({}, elementProps, {
            className: (0, _classnames2['default'])(className, classes)
          }),
          _react2['default'].createElement('img', { src: src, alt: alt }),
          children && _react2['default'].createElement(
            'div',
            { className: 'caption' },
            children
          )
        );
      };

      return Thumbnail;
    }(_react2['default'].Component);

    Thumbnail.propTypes = propTypes;

    exports['default'] = (0, _bootstrapUtils.bsClass)('thumbnail', Thumbnail);
    module.exports = exports['default'];

    },{"./SafeAnchor":84,"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],94:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends3 = require('babel-runtime/helpers/extends');

    var _extends4 = _interopRequireDefault(_extends3);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _isRequiredForA11y = require('react-prop-types/lib/isRequiredForA11y');

    var _isRequiredForA11y2 = _interopRequireDefault(_isRequiredForA11y);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var propTypes = {
      /**
       * An html id attribute, necessary for accessibility
       * @type {string|number}
       * @required
       */
      id: (0, _isRequiredForA11y2['default'])(_react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number])),

      /**
       * Sets the direction the Tooltip is positioned towards.
       */
      placement: _react2['default'].PropTypes.oneOf(['top', 'right', 'bottom', 'left']),

      /**
       * The "top" position value for the Tooltip.
       */
      positionTop: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.number, _react2['default'].PropTypes.string]),
      /**
       * The "left" position value for the Tooltip.
       */
      positionLeft: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.number, _react2['default'].PropTypes.string]),

      /**
       * The "top" position value for the Tooltip arrow.
       */
      arrowOffsetTop: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.number, _react2['default'].PropTypes.string]),
      /**
       * The "left" position value for the Tooltip arrow.
       */
      arrowOffsetLeft: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.number, _react2['default'].PropTypes.string])
    };

    var defaultProps = {
      placement: 'right'
    };

    var Tooltip = function (_React$Component) {
      (0, _inherits3['default'])(Tooltip, _React$Component);

      function Tooltip() {
        (0, _classCallCheck3['default'])(this, Tooltip);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Tooltip.prototype.render = function render() {
        var _extends2;

        var _props = this.props,
            placement = _props.placement,
            positionTop = _props.positionTop,
            positionLeft = _props.positionLeft,
            arrowOffsetTop = _props.arrowOffsetTop,
            arrowOffsetLeft = _props.arrowOffsetLeft,
            className = _props.className,
            style = _props.style,
            children = _props.children,
            props = (0, _objectWithoutProperties3['default'])(_props, ['placement', 'positionTop', 'positionLeft', 'arrowOffsetTop', 'arrowOffsetLeft', 'className', 'style', 'children']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _extends4['default'])({}, (0, _bootstrapUtils.getClassSet)(bsProps), (_extends2 = {}, _extends2[placement] = true, _extends2));

        var outerStyle = (0, _extends4['default'])({
          top: positionTop,
          left: positionLeft
        }, style);

        var arrowStyle = {
          top: arrowOffsetTop,
          left: arrowOffsetLeft
        };

        return _react2['default'].createElement(
          'div',
          (0, _extends4['default'])({}, elementProps, {
            role: 'tooltip',
            className: (0, _classnames2['default'])(className, classes),
            style: outerStyle
          }),
          _react2['default'].createElement('div', { className: (0, _bootstrapUtils.prefix)(bsProps, 'arrow'), style: arrowStyle }),
          _react2['default'].createElement(
            'div',
            { className: (0, _bootstrapUtils.prefix)(bsProps, 'inner') },
            children
          )
        );
      };

      return Tooltip;
    }(_react2['default'].Component);

    Tooltip.propTypes = propTypes;
    Tooltip.defaultProps = defaultProps;

    exports['default'] = (0, _bootstrapUtils.bsClass)('tooltip', Tooltip);
    module.exports = exports['default'];

    },{"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618,"react-prop-types/lib/isRequiredForA11y":256}],95:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

    var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _bootstrapUtils = require('./utils/bootstrapUtils');

    var _StyleConfig = require('./utils/StyleConfig');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var Well = function (_React$Component) {
      (0, _inherits3['default'])(Well, _React$Component);

      function Well() {
        (0, _classCallCheck3['default'])(this, Well);
        return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
      }

      Well.prototype.render = function render() {
        var _props = this.props,
            className = _props.className,
            props = (0, _objectWithoutProperties3['default'])(_props, ['className']);

        var _splitBsProps = (0, _bootstrapUtils.splitBsProps)(props),
            bsProps = _splitBsProps[0],
            elementProps = _splitBsProps[1];

        var classes = (0, _bootstrapUtils.getClassSet)(bsProps);

        return _react2['default'].createElement('div', (0, _extends3['default'])({}, elementProps, {
          className: (0, _classnames2['default'])(className, classes)
        }));
      };

      return Well;
    }(_react2['default'].Component);

    exports['default'] = (0, _bootstrapUtils.bsClass)('well', (0, _bootstrapUtils.bsSizes)([_StyleConfig.Size.LARGE, _StyleConfig.Size.SMALL], Well));
    module.exports = exports['default'];

    },{"./utils/StyleConfig":98,"./utils/bootstrapUtils":101,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/extends":116,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/objectWithoutProperties":118,"babel-runtime/helpers/possibleConstructorReturn":119,"classnames":207,"react":618}],96:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;
    exports.utils = exports.Well = exports.Tooltip = exports.Thumbnail = exports.Tabs = exports.TabPane = exports.Table = exports.TabContent = exports.TabContainer = exports.Tab = exports.SplitButton = exports.SafeAnchor = exports.Row = exports.ResponsiveEmbed = exports.Radio = exports.ProgressBar = exports.Popover = exports.PanelGroup = exports.Panel = exports.Pagination = exports.Pager = exports.PageItem = exports.PageHeader = exports.OverlayTrigger = exports.Overlay = exports.NavItem = exports.NavDropdown = exports.NavbarBrand = exports.Navbar = exports.Nav = exports.ModalTitle = exports.ModalHeader = exports.ModalFooter = exports.ModalBody = exports.Modal = exports.MenuItem = exports.Media = exports.ListGroupItem = exports.ListGroup = exports.Label = exports.Jumbotron = exports.InputGroup = exports.Image = exports.HelpBlock = exports.Grid = exports.Glyphicon = exports.FormGroup = exports.FormControl = exports.Form = exports.Fade = exports.DropdownButton = exports.Dropdown = exports.Collapse = exports.Col = exports.ControlLabel = exports.Clearfix = exports.Checkbox = exports.CarouselItem = exports.Carousel = exports.ButtonToolbar = exports.ButtonGroup = exports.Button = exports.BreadcrumbItem = exports.Breadcrumb = exports.Badge = exports.Alert = exports.Accordion = undefined;

    var _Accordion2 = require('./Accordion');

    var _Accordion3 = _interopRequireDefault(_Accordion2);

    var _Alert2 = require('./Alert');

    var _Alert3 = _interopRequireDefault(_Alert2);

    var _Badge2 = require('./Badge');

    var _Badge3 = _interopRequireDefault(_Badge2);

    var _Breadcrumb2 = require('./Breadcrumb');

    var _Breadcrumb3 = _interopRequireDefault(_Breadcrumb2);

    var _BreadcrumbItem2 = require('./BreadcrumbItem');

    var _BreadcrumbItem3 = _interopRequireDefault(_BreadcrumbItem2);

    var _Button2 = require('./Button');

    var _Button3 = _interopRequireDefault(_Button2);

    var _ButtonGroup2 = require('./ButtonGroup');

    var _ButtonGroup3 = _interopRequireDefault(_ButtonGroup2);

    var _ButtonToolbar2 = require('./ButtonToolbar');

    var _ButtonToolbar3 = _interopRequireDefault(_ButtonToolbar2);

    var _Carousel2 = require('./Carousel');

    var _Carousel3 = _interopRequireDefault(_Carousel2);

    var _CarouselItem2 = require('./CarouselItem');

    var _CarouselItem3 = _interopRequireDefault(_CarouselItem2);

    var _Checkbox2 = require('./Checkbox');

    var _Checkbox3 = _interopRequireDefault(_Checkbox2);

    var _Clearfix2 = require('./Clearfix');

    var _Clearfix3 = _interopRequireDefault(_Clearfix2);

    var _ControlLabel2 = require('./ControlLabel');

    var _ControlLabel3 = _interopRequireDefault(_ControlLabel2);

    var _Col2 = require('./Col');

    var _Col3 = _interopRequireDefault(_Col2);

    var _Collapse2 = require('./Collapse');

    var _Collapse3 = _interopRequireDefault(_Collapse2);

    var _Dropdown2 = require('./Dropdown');

    var _Dropdown3 = _interopRequireDefault(_Dropdown2);

    var _DropdownButton2 = require('./DropdownButton');

    var _DropdownButton3 = _interopRequireDefault(_DropdownButton2);

    var _Fade2 = require('./Fade');

    var _Fade3 = _interopRequireDefault(_Fade2);

    var _Form2 = require('./Form');

    var _Form3 = _interopRequireDefault(_Form2);

    var _FormControl2 = require('./FormControl');

    var _FormControl3 = _interopRequireDefault(_FormControl2);

    var _FormGroup2 = require('./FormGroup');

    var _FormGroup3 = _interopRequireDefault(_FormGroup2);

    var _Glyphicon2 = require('./Glyphicon');

    var _Glyphicon3 = _interopRequireDefault(_Glyphicon2);

    var _Grid2 = require('./Grid');

    var _Grid3 = _interopRequireDefault(_Grid2);

    var _HelpBlock2 = require('./HelpBlock');

    var _HelpBlock3 = _interopRequireDefault(_HelpBlock2);

    var _Image2 = require('./Image');

    var _Image3 = _interopRequireDefault(_Image2);

    var _InputGroup2 = require('./InputGroup');

    var _InputGroup3 = _interopRequireDefault(_InputGroup2);

    var _Jumbotron2 = require('./Jumbotron');

    var _Jumbotron3 = _interopRequireDefault(_Jumbotron2);

    var _Label2 = require('./Label');

    var _Label3 = _interopRequireDefault(_Label2);

    var _ListGroup2 = require('./ListGroup');

    var _ListGroup3 = _interopRequireDefault(_ListGroup2);

    var _ListGroupItem2 = require('./ListGroupItem');

    var _ListGroupItem3 = _interopRequireDefault(_ListGroupItem2);

    var _Media2 = require('./Media');

    var _Media3 = _interopRequireDefault(_Media2);

    var _MenuItem2 = require('./MenuItem');

    var _MenuItem3 = _interopRequireDefault(_MenuItem2);

    var _Modal2 = require('./Modal');

    var _Modal3 = _interopRequireDefault(_Modal2);

    var _ModalBody2 = require('./ModalBody');

    var _ModalBody3 = _interopRequireDefault(_ModalBody2);

    var _ModalFooter2 = require('./ModalFooter');

    var _ModalFooter3 = _interopRequireDefault(_ModalFooter2);

    var _ModalHeader2 = require('./ModalHeader');

    var _ModalHeader3 = _interopRequireDefault(_ModalHeader2);

    var _ModalTitle2 = require('./ModalTitle');

    var _ModalTitle3 = _interopRequireDefault(_ModalTitle2);

    var _Nav2 = require('./Nav');

    var _Nav3 = _interopRequireDefault(_Nav2);

    var _Navbar2 = require('./Navbar');

    var _Navbar3 = _interopRequireDefault(_Navbar2);

    var _NavbarBrand2 = require('./NavbarBrand');

    var _NavbarBrand3 = _interopRequireDefault(_NavbarBrand2);

    var _NavDropdown2 = require('./NavDropdown');

    var _NavDropdown3 = _interopRequireDefault(_NavDropdown2);

    var _NavItem2 = require('./NavItem');

    var _NavItem3 = _interopRequireDefault(_NavItem2);

    var _Overlay2 = require('./Overlay');

    var _Overlay3 = _interopRequireDefault(_Overlay2);

    var _OverlayTrigger2 = require('./OverlayTrigger');

    var _OverlayTrigger3 = _interopRequireDefault(_OverlayTrigger2);

    var _PageHeader2 = require('./PageHeader');

    var _PageHeader3 = _interopRequireDefault(_PageHeader2);

    var _PageItem2 = require('./PageItem');

    var _PageItem3 = _interopRequireDefault(_PageItem2);

    var _Pager2 = require('./Pager');

    var _Pager3 = _interopRequireDefault(_Pager2);

    var _Pagination2 = require('./Pagination');

    var _Pagination3 = _interopRequireDefault(_Pagination2);

    var _Panel2 = require('./Panel');

    var _Panel3 = _interopRequireDefault(_Panel2);

    var _PanelGroup2 = require('./PanelGroup');

    var _PanelGroup3 = _interopRequireDefault(_PanelGroup2);

    var _Popover2 = require('./Popover');

    var _Popover3 = _interopRequireDefault(_Popover2);

    var _ProgressBar2 = require('./ProgressBar');

    var _ProgressBar3 = _interopRequireDefault(_ProgressBar2);

    var _Radio2 = require('./Radio');

    var _Radio3 = _interopRequireDefault(_Radio2);

    var _ResponsiveEmbed2 = require('./ResponsiveEmbed');

    var _ResponsiveEmbed3 = _interopRequireDefault(_ResponsiveEmbed2);

    var _Row2 = require('./Row');

    var _Row3 = _interopRequireDefault(_Row2);

    var _SafeAnchor2 = require('./SafeAnchor');

    var _SafeAnchor3 = _interopRequireDefault(_SafeAnchor2);

    var _SplitButton2 = require('./SplitButton');

    var _SplitButton3 = _interopRequireDefault(_SplitButton2);

    var _Tab2 = require('./Tab');

    var _Tab3 = _interopRequireDefault(_Tab2);

    var _TabContainer2 = require('./TabContainer');

    var _TabContainer3 = _interopRequireDefault(_TabContainer2);

    var _TabContent2 = require('./TabContent');

    var _TabContent3 = _interopRequireDefault(_TabContent2);

    var _Table2 = require('./Table');

    var _Table3 = _interopRequireDefault(_Table2);

    var _TabPane2 = require('./TabPane');

    var _TabPane3 = _interopRequireDefault(_TabPane2);

    var _Tabs2 = require('./Tabs');

    var _Tabs3 = _interopRequireDefault(_Tabs2);

    var _Thumbnail2 = require('./Thumbnail');

    var _Thumbnail3 = _interopRequireDefault(_Thumbnail2);

    var _Tooltip2 = require('./Tooltip');

    var _Tooltip3 = _interopRequireDefault(_Tooltip2);

    var _Well2 = require('./Well');

    var _Well3 = _interopRequireDefault(_Well2);

    var _utils2 = require('./utils');

    var _utils = _interopRequireWildcard(_utils2);

    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 }; }

    exports.Accordion = _Accordion3['default'];
    exports.Alert = _Alert3['default'];
    exports.Badge = _Badge3['default'];
    exports.Breadcrumb = _Breadcrumb3['default'];
    exports.BreadcrumbItem = _BreadcrumbItem3['default'];
    exports.Button = _Button3['default'];
    exports.ButtonGroup = _ButtonGroup3['default'];
    exports.ButtonToolbar = _ButtonToolbar3['default'];
    exports.Carousel = _Carousel3['default'];
    exports.CarouselItem = _CarouselItem3['default'];
    exports.Checkbox = _Checkbox3['default'];
    exports.Clearfix = _Clearfix3['default'];
    exports.ControlLabel = _ControlLabel3['default'];
    exports.Col = _Col3['default'];
    exports.Collapse = _Collapse3['default'];
    exports.Dropdown = _Dropdown3['default'];
    exports.DropdownButton = _DropdownButton3['default'];
    exports.Fade = _Fade3['default'];
    exports.Form = _Form3['default'];
    exports.FormControl = _FormControl3['default'];
    exports.FormGroup = _FormGroup3['default'];
    exports.Glyphicon = _Glyphicon3['default'];
    exports.Grid = _Grid3['default'];
    exports.HelpBlock = _HelpBlock3['default'];
    exports.Image = _Image3['default'];
    exports.InputGroup = _InputGroup3['default'];
    exports.Jumbotron = _Jumbotron3['default'];
    exports.Label = _Label3['default'];
    exports.ListGroup = _ListGroup3['default'];
    exports.ListGroupItem = _ListGroupItem3['default'];
    exports.Media = _Media3['default'];
    exports.MenuItem = _MenuItem3['default'];
    exports.Modal = _Modal3['default'];
    exports.ModalBody = _ModalBody3['default'];
    exports.ModalFooter = _ModalFooter3['default'];
    exports.ModalHeader = _ModalHeader3['default'];
    exports.ModalTitle = _ModalTitle3['default'];
    exports.Nav = _Nav3['default'];
    exports.Navbar = _Navbar3['default'];
    exports.NavbarBrand = _NavbarBrand3['default'];
    exports.NavDropdown = _NavDropdown3['default'];
    exports.NavItem = _NavItem3['default'];
    exports.Overlay = _Overlay3['default'];
    exports.OverlayTrigger = _OverlayTrigger3['default'];
    exports.PageHeader = _PageHeader3['default'];
    exports.PageItem = _PageItem3['default'];
    exports.Pager = _Pager3['default'];
    exports.Pagination = _Pagination3['default'];
    exports.Panel = _Panel3['default'];
    exports.PanelGroup = _PanelGroup3['default'];
    exports.Popover = _Popover3['default'];
    exports.ProgressBar = _ProgressBar3['default'];
    exports.Radio = _Radio3['default'];
    exports.ResponsiveEmbed = _ResponsiveEmbed3['default'];
    exports.Row = _Row3['default'];
    exports.SafeAnchor = _SafeAnchor3['default'];
    exports.SplitButton = _SplitButton3['default'];
    exports.Tab = _Tab3['default'];
    exports.TabContainer = _TabContainer3['default'];
    exports.TabContent = _TabContent3['default'];
    exports.Table = _Table3['default'];
    exports.TabPane = _TabPane3['default'];
    exports.Tabs = _Tabs3['default'];
    exports.Thumbnail = _Thumbnail3['default'];
    exports.Tooltip = _Tooltip3['default'];
    exports.Well = _Well3['default'];
    exports.utils = _utils;

    },{"./Accordion":10,"./Alert":11,"./Badge":12,"./Breadcrumb":13,"./BreadcrumbItem":14,"./Button":15,"./ButtonGroup":16,"./ButtonToolbar":17,"./Carousel":18,"./CarouselItem":20,"./Checkbox":21,"./Clearfix":22,"./Col":23,"./Collapse":24,"./ControlLabel":25,"./Dropdown":26,"./DropdownButton":27,"./Fade":30,"./Form":31,"./FormControl":32,"./FormGroup":35,"./Glyphicon":36,"./Grid":37,"./HelpBlock":38,"./Image":39,"./InputGroup":40,"./Jumbotron":43,"./Label":44,"./ListGroup":45,"./ListGroupItem":46,"./Media":47,"./MenuItem":54,"./Modal":55,"./ModalBody":56,"./ModalFooter":58,"./ModalHeader":59,"./ModalTitle":60,"./Nav":61,"./NavDropdown":62,"./NavItem":63,"./Navbar":64,"./NavbarBrand":65,"./Overlay":69,"./OverlayTrigger":70,"./PageHeader":71,"./PageItem":72,"./Pager":73,"./Pagination":75,"./Panel":77,"./PanelGroup":78,"./Popover":79,"./ProgressBar":80,"./Radio":81,"./ResponsiveEmbed":82,"./Row":83,"./SafeAnchor":84,"./SplitButton":85,"./Tab":87,"./TabContainer":88,"./TabContent":89,"./TabPane":90,"./Table":91,"./Tabs":92,"./Thumbnail":93,"./Tooltip":94,"./Well":95,"./utils":105}],97:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;
    exports.requiredRoles = requiredRoles;
    exports.exclusiveRoles = exclusiveRoles;

    var _createChainableTypeChecker = require('react-prop-types/lib/utils/createChainableTypeChecker');

    var _createChainableTypeChecker2 = _interopRequireDefault(_createChainableTypeChecker);

    var _ValidComponentChildren = require('./ValidComponentChildren');

    var _ValidComponentChildren2 = _interopRequireDefault(_ValidComponentChildren);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    function requiredRoles() {
      for (var _len = arguments.length, roles = Array(_len), _key = 0; _key < _len; _key++) {
        roles[_key] = arguments[_key];
      }

      return (0, _createChainableTypeChecker2['default'])(function (props, propName, component) {
        var missing = void 0;

        roles.every(function (role) {
          if (!_ValidComponentChildren2['default'].some(props.children, function (child) {
            return child.props.bsRole === role;
          })) {
            missing = role;
            return false;
          }

          return true;
        });

        if (missing) {
          return new Error('(children) ' + component + ' - Missing a required child with bsRole: ' + (missing + '. ' + component + ' must have at least one child of each of ') + ('the following bsRoles: ' + roles.join(', ')));
        }

        return null;
      });
    }

    function exclusiveRoles() {
      for (var _len2 = arguments.length, roles = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        roles[_key2] = arguments[_key2];
      }

      return (0, _createChainableTypeChecker2['default'])(function (props, propName, component) {
        var duplicate = void 0;

        roles.every(function (role) {
          var childrenWithRole = _ValidComponentChildren2['default'].filter(props.children, function (child) {
            return child.props.bsRole === role;
          });

          if (childrenWithRole.length > 1) {
            duplicate = role;
            return false;
          }

          return true;
        });

        if (duplicate) {
          return new Error('(children) ' + component + ' - Duplicate children detected of bsRole: ' + (duplicate + '. Only one child each allowed with the following ') + ('bsRoles: ' + roles.join(', ')));
        }

        return null;
      });
    }

    },{"./ValidComponentChildren":100,"react-prop-types/lib/utils/createChainableTypeChecker":257}],98:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;
    var Size = exports.Size = {
      LARGE: 'large',
      SMALL: 'small',
      XSMALL: 'xsmall'
    };

    var SIZE_MAP = exports.SIZE_MAP = {
      large: 'lg',
      medium: 'md',
      small: 'sm',
      xsmall: 'xs',
      lg: 'lg',
      md: 'md',
      sm: 'sm',
      xs: 'xs'
    };

    var DEVICE_SIZES = exports.DEVICE_SIZES = ['lg', 'md', 'sm', 'xs'];

    var State = exports.State = {
      SUCCESS: 'success',
      WARNING: 'warning',
      DANGER: 'danger',
      INFO: 'info'
    };

    var Style = exports.Style = {
      DEFAULT: 'default',
      PRIMARY: 'primary',
      LINK: 'link',
      INVERSE: 'inverse'
    };

    },{}],99:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;
    /**
     * Copyright 2013-2014, Facebook, Inc.
     * All rights reserved.
     *
     * This file contains a modified version of:
     * https://github.com/facebook/react/blob/v0.12.0/src/addons/transitions/ReactTransitionEvents.js
     *
     * This source code is licensed under the BSD-style license found here:
     * https://github.com/facebook/react/blob/v0.12.0/LICENSE
     * An additional grant of patent rights can be found here:
     * https://github.com/facebook/react/blob/v0.12.0/PATENTS
     */

    var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);

    /**
     * EVENT_NAME_MAP is used to determine which event fired when a
     * transition/animation ends, based on the style property used to
     * define that event.
     */
    var EVENT_NAME_MAP = {
      transitionend: {
        'transition': 'transitionend',
        'WebkitTransition': 'webkitTransitionEnd',
        'MozTransition': 'mozTransitionEnd',
        'OTransition': 'oTransitionEnd',
        'msTransition': 'MSTransitionEnd'
      },

      animationend: {
        'animation': 'animationend',
        'WebkitAnimation': 'webkitAnimationEnd',
        'MozAnimation': 'mozAnimationEnd',
        'OAnimation': 'oAnimationEnd',
        'msAnimation': 'MSAnimationEnd'
      }
    };

    var endEvents = [];

    function detectEvents() {
      var testEl = document.createElement('div');
      var style = testEl.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 useable, and if not remove them
      // from the map
      if (!('AnimationEvent' in window)) {
        delete EVENT_NAME_MAP.animationend.animation;
      }

      if (!('TransitionEvent' in window)) {
        delete EVENT_NAME_MAP.transitionend.transition;
      }

      for (var baseEventName in EVENT_NAME_MAP) {
        // eslint-disable-line guard-for-in
        var baseEvents = EVENT_NAME_MAP[baseEventName];
        for (var styleName in baseEvents) {
          if (styleName in style) {
            endEvents.push(baseEvents[styleName]);
            break;
          }
        }
      }
    }

    if (canUseDOM) {
      detectEvents();
    }

    // We use the raw {add|remove}EventListener() call because EventListener
    // does not know how to remove event listeners and we really should
    // clean up. Also, these events are not triggered in older browsers
    // so we should be A-OK here.

    function addEventListener(node, eventName, eventListener) {
      node.addEventListener(eventName, eventListener, false);
    }

    function removeEventListener(node, eventName, eventListener) {
      node.removeEventListener(eventName, eventListener, false);
    }

    var ReactTransitionEvents = {
      addEndEventListener: function addEndEventListener(node, eventListener) {
        if (endEvents.length === 0) {
          // If CSS transitions are not supported, trigger an "end animation"
          // event immediately.
          window.setTimeout(eventListener, 0);
          return;
        }
        endEvents.forEach(function (endEvent) {
          addEventListener(node, endEvent, eventListener);
        });
      },
      removeEndEventListener: function removeEndEventListener(node, eventListener) {
        if (endEvents.length === 0) {
          return;
        }
        endEvents.forEach(function (endEvent) {
          removeEventListener(node, endEvent, eventListener);
        });
      }
    };

    exports['default'] = ReactTransitionEvents;
    module.exports = exports['default'];

    },{}],100:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    /**
     * Iterates through children that are typically specified as `props.children`,
     * but only maps over children that are "valid components".
     *
     * The mapFunction provided index will be normalised to the components mapped,
     * so an invalid component would not increase the index.
     *
     * @param {?*} children Children tree container.
     * @param {function(*, int)} func.
     * @param {*} context Context for func.
     * @return {object} Object containing the ordered map of results.
     */
    function map(children, func, context) {
      var index = 0;

      return _react2['default'].Children.map(children, function (child) {
        if (!_react2['default'].isValidElement(child)) {
          return child;
        }

        return func.call(context, child, index++);
      });
    }

    /**
     * Iterates through children that are "valid components".
     *
     * The provided forEachFunc(child, index) will be called for each
     * leaf child with the index reflecting the position relative to "valid components".
     *
     * @param {?*} children Children tree container.
     * @param {function(*, int)} func.
     * @param {*} context Context for context.
     */
    // TODO: This module should be ElementChildren, and should use named exports.

    function forEach(children, func, context) {
      var index = 0;

      _react2['default'].Children.forEach(children, function (child) {
        if (!_react2['default'].isValidElement(child)) {
          return;
        }

        func.call(context, child, index++);
      });
    }

    /**
     * Count the number of "valid components" in the Children container.
     *
     * @param {?*} children Children tree container.
     * @returns {number}
     */
    function count(children) {
      var result = 0;

      _react2['default'].Children.forEach(children, function (child) {
        if (!_react2['default'].isValidElement(child)) {
          return;
        }

        ++result;
      });

      return result;
    }

    /**
     * Finds children that are typically specified as `props.children`,
     * but only iterates over children that are "valid components".
     *
     * The provided forEachFunc(child, index) will be called for each
     * leaf child with the index reflecting the position relative to "valid components".
     *
     * @param {?*} children Children tree container.
     * @param {function(*, int)} func.
     * @param {*} context Context for func.
     * @returns {array} of children that meet the func return statement
     */
    function filter(children, func, context) {
      var index = 0;
      var result = [];

      _react2['default'].Children.forEach(children, function (child) {
        if (!_react2['default'].isValidElement(child)) {
          return;
        }

        if (func.call(context, child, index++)) {
          result.push(child);
        }
      });

      return result;
    }

    function find(children, func, context) {
      var index = 0;
      var result = undefined;

      _react2['default'].Children.forEach(children, function (child) {
        if (result) {
          return;
        }
        if (!_react2['default'].isValidElement(child)) {
          return;
        }

        if (func.call(context, child, index++)) {
          result = child;
        }
      });

      return result;
    }

    function every(children, func, context) {
      var index = 0;
      var result = true;

      _react2['default'].Children.forEach(children, function (child) {
        if (!result) {
          return;
        }
        if (!_react2['default'].isValidElement(child)) {
          return;
        }

        if (!func.call(context, child, index++)) {
          result = false;
        }
      });

      return result;
    }

    function some(children, func, context) {
      var index = 0;
      var result = false;

      _react2['default'].Children.forEach(children, function (child) {
        if (result) {
          return;
        }
        if (!_react2['default'].isValidElement(child)) {
          return;
        }

        if (func.call(context, child, index++)) {
          result = true;
        }
      });

      return result;
    }

    function toArray(children) {
      var result = [];

      _react2['default'].Children.forEach(children, function (child) {
        if (!_react2['default'].isValidElement(child)) {
          return;
        }

        result.push(child);
      });

      return result;
    }

    exports['default'] = {
      map: map,
      forEach: forEach,
      count: count,
      find: find,
      filter: filter,
      every: every,
      some: some,
      toArray: toArray
    };
    module.exports = exports['default'];

    },{"react":618}],101:[function(require,module,exports){
    (function (process){
    'use strict';

    exports.__esModule = true;
    exports._curry = exports.bsSizes = exports.bsStyles = exports.bsClass = undefined;

    var _entries = require('babel-runtime/core-js/object/entries');

    var _entries2 = _interopRequireDefault(_entries);

    var _extends2 = require('babel-runtime/helpers/extends');

    var _extends3 = _interopRequireDefault(_extends2);

    exports.prefix = prefix;
    exports.getClassSet = getClassSet;
    exports.splitBsProps = splitBsProps;
    exports.splitBsPropsAndOmit = splitBsPropsAndOmit;
    exports.addStyle = addStyle;

    var _invariant = require('invariant');

    var _invariant2 = _interopRequireDefault(_invariant);

    var _react = require('react');

    var _StyleConfig = require('./StyleConfig');

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    function curry(fn) {
      return function () {
        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        var last = args[args.length - 1];
        if (typeof last === 'function') {
          return fn.apply(undefined, args);
        }
        return function (Component) {
          return fn.apply(undefined, args.concat([Component]));
        };
      };
    } // TODO: The publicly exposed parts of this should be in lib/BootstrapUtils.

    function prefix(props, variant) {
      !(props.bsClass != null) ? process.env.NODE_ENV !== 'production' ? (0, _invariant2['default'])(false, 'A `bsClass` prop is required for this component') : (0, _invariant2['default'])(false) : void 0;
      return props.bsClass + (variant ? '-' + variant : '');
    }

    var bsClass = exports.bsClass = curry(function (defaultClass, Component) {
      var propTypes = Component.propTypes || (Component.propTypes = {});
      var defaultProps = Component.defaultProps || (Component.defaultProps = {});

      propTypes.bsClass = _react.PropTypes.string;
      defaultProps.bsClass = defaultClass;

      return Component;
    });

    var bsStyles = exports.bsStyles = curry(function (styles, defaultStyle, Component) {
      if (typeof defaultStyle !== 'string') {
        Component = defaultStyle;
        defaultStyle = undefined;
      }

      var existing = Component.STYLES || [];
      var propTypes = Component.propTypes || {};

      styles.forEach(function (style) {
        if (existing.indexOf(style) === -1) {
          existing.push(style);
        }
      });

      var propType = _react.PropTypes.oneOf(existing);

      // expose the values on the propType function for documentation
      Component.STYLES = propType._values = existing;

      Component.propTypes = (0, _extends3['default'])({}, propTypes, {
        bsStyle: propType
      });

      if (defaultStyle !== undefined) {
        var defaultProps = Component.defaultProps || (Component.defaultProps = {});
        defaultProps.bsStyle = defaultStyle;
      }

      return Component;
    });

    var bsSizes = exports.bsSizes = curry(function (sizes, defaultSize, Component) {
      if (typeof defaultSize !== 'string') {
        Component = defaultSize;
        defaultSize = undefined;
      }

      var existing = Component.SIZES || [];
      var propTypes = Component.propTypes || {};

      sizes.forEach(function (size) {
        if (existing.indexOf(size) === -1) {
          existing.push(size);
        }
      });

      var values = [];
      existing.forEach(function (size) {
        var mappedSize = _StyleConfig.SIZE_MAP[size];
        if (mappedSize && mappedSize !== size) {
          values.push(mappedSize);
        }

        values.push(size);
      });

      var propType = _react.PropTypes.oneOf(values);
      propType._values = values;

      // expose the values on the propType function for documentation
      Component.SIZES = existing;

      Component.propTypes = (0, _extends3['default'])({}, propTypes, {
        bsSize: propType
      });

      if (defaultSize !== undefined) {
        if (!Component.defaultProps) {
          Component.defaultProps = {};
        }
        Component.defaultProps.bsSize = defaultSize;
      }

      return Component;
    });

    function getClassSet(props) {
      var _classes;

      var classes = (_classes = {}, _classes[prefix(props)] = true, _classes);

      if (props.bsSize) {
        var bsSize = _StyleConfig.SIZE_MAP[props.bsSize] || props.bsSize;
        classes[prefix(props, bsSize)] = true;
      }

      if (props.bsStyle) {
        classes[prefix(props, props.bsStyle)] = true;
      }

      return classes;
    }

    function getBsProps(props) {
      return {
        bsClass: props.bsClass,
        bsSize: props.bsSize,
        bsStyle: props.bsStyle,
        bsRole: props.bsRole
      };
    }

    function isBsProp(propName) {
      return propName === 'bsClass' || propName === 'bsSize' || propName === 'bsStyle' || propName === 'bsRole';
    }

    function splitBsProps(props) {
      var elementProps = {};
      (0, _entries2['default'])(props).forEach(function (_ref) {
        var propName = _ref[0],
            propValue = _ref[1];

        if (!isBsProp(propName)) {
          elementProps[propName] = propValue;
        }
      });

      return [getBsProps(props), elementProps];
    }

    function splitBsPropsAndOmit(props, omittedPropNames) {
      var isOmittedProp = {};
      omittedPropNames.forEach(function (propName) {
        isOmittedProp[propName] = true;
      });

      var elementProps = {};
      (0, _entries2['default'])(props).forEach(function (_ref2) {
        var propName = _ref2[0],
            propValue = _ref2[1];

        if (!isBsProp(propName) && !isOmittedProp[propName]) {
          elementProps[propName] = propValue;
        }
      });

      return [getBsProps(props), elementProps];
    }

    /**
     * Add a style variant to a Component. Mutates the propTypes of the component
     * in order to validate the new variant.
     */
    function addStyle(Component) {
      for (var _len2 = arguments.length, styleVariant = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
        styleVariant[_key2 - 1] = arguments[_key2];
      }

      bsStyles(styleVariant, Component);
    }

    var _curry = exports._curry = curry;

    }).call(this,require('_process'))
    },{"./StyleConfig":98,"_process":728,"babel-runtime/core-js/object/entries":110,"babel-runtime/helpers/extends":116,"invariant":237,"react":618}],102:[function(require,module,exports){
    "use strict";

    exports.__esModule = true;
    exports["default"] = capitalize;
    function capitalize(string) {
      return "" + string.charAt(0).toUpperCase() + string.slice(1);
    }
    module.exports = exports["default"];

    },{}],103:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;
    /**
     * Safe chained function
     *
     * Will only create a new function if needed,
     * otherwise will pass back existing functions or null.
     *
     * @param {function} functions to chain
     * @returns {function|null}
     */
    function createChainedFunction() {
      for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {
        funcs[_key] = arguments[_key];
      }

      return funcs.filter(function (f) {
        return f != null;
      }).reduce(function (acc, f) {
        if (typeof f !== 'function') {
          throw new Error('Invalid Argument Type, must only provide functions, undefined, or null.');
        }

        if (acc === null) {
          return f;
        }

        return function chainedFunction() {
          for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
            args[_key2] = arguments[_key2];
          }

          acc.apply(this, args);
          f.apply(this, args);
        };
      }, null);
    }

    exports['default'] = createChainedFunction;
    module.exports = exports['default'];

    },{}],104:[function(require,module,exports){
    (function (process){
    'use strict';

    exports.__esModule = true;

    var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

    var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

    var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

    var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

    var _inherits2 = require('babel-runtime/helpers/inherits');

    var _inherits3 = _interopRequireDefault(_inherits2);

    var _typeof2 = require('babel-runtime/helpers/typeof');

    var _typeof3 = _interopRequireDefault(_typeof2);

    exports._resetWarned = _resetWarned;

    var _warning = require('warning');

    var _warning2 = _interopRequireDefault(_warning);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

    var warned = {};

    function deprecationWarning(oldname, newname, link) {
      var message = void 0;

      if ((typeof oldname === 'undefined' ? 'undefined' : (0, _typeof3['default'])(oldname)) === 'object') {
        message = oldname.message;
      } else {
        message = oldname + ' is deprecated. Use ' + newname + ' instead.';

        if (link) {
          message += '\nYou can read more about it at ' + link;
        }
      }

      if (warned[message]) {
        return;
      }

      process.env.NODE_ENV !== 'production' ? (0, _warning2['default'])(false, message) : void 0;
      warned[message] = true;
    }

    deprecationWarning.wrapper = function (Component) {
      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }

      return function (_Component) {
        (0, _inherits3['default'])(DeprecatedComponent, _Component);

        function DeprecatedComponent() {
          (0, _classCallCheck3['default'])(this, DeprecatedComponent);
          return (0, _possibleConstructorReturn3['default'])(this, _Component.apply(this, arguments));
        }

        DeprecatedComponent.prototype.componentWillMount = function componentWillMount() {
          deprecationWarning.apply(undefined, args);

          if (_Component.prototype.componentWillMount) {
            var _Component$prototype$;

            for (var _len2 = arguments.length, methodArgs = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
              methodArgs[_key2] = arguments[_key2];
            }

            (_Component$prototype$ = _Component.prototype.componentWillMount).call.apply(_Component$prototype$, [this].concat(methodArgs));
          }
        };

        return DeprecatedComponent;
      }(Component);
    };

    exports['default'] = deprecationWarning;
    function _resetWarned() {
      warned = {};
    }

    }).call(this,require('_process'))
    },{"_process":728,"babel-runtime/helpers/classCallCheck":115,"babel-runtime/helpers/inherits":117,"babel-runtime/helpers/possibleConstructorReturn":119,"babel-runtime/helpers/typeof":120,"warning":261}],105:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;
    exports.ValidComponentChildren = exports.createChainedFunction = exports.bootstrapUtils = undefined;

    var _bootstrapUtils2 = require('./bootstrapUtils');

    var _bootstrapUtils = _interopRequireWildcard(_bootstrapUtils2);

    var _createChainedFunction2 = require('./createChainedFunction');

    var _createChainedFunction3 = _interopRequireDefault(_createChainedFunction2);

    var _ValidComponentChildren2 = require('./ValidComponentChildren');

    var _ValidComponentChildren3 = _interopRequireDefault(_ValidComponentChildren2);

    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; } }

    exports.bootstrapUtils = _bootstrapUtils;
    exports.createChainedFunction = _createChainedFunction3['default'];
    exports.ValidComponentChildren = _ValidComponentChildren3['default'];

    },{"./ValidComponentChildren":100,"./bootstrapUtils":101,"./createChainedFunction":103}],106:[function(require,module,exports){
    "use strict";

    exports.__esModule = true;

    var _entries = require("babel-runtime/core-js/object/entries");

    var _entries2 = _interopRequireDefault(_entries);

    exports["default"] = splitComponentProps;

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

    function splitComponentProps(props, Component) {
      var componentPropTypes = Component.propTypes;

      var parentProps = {};
      var childProps = {};

      (0, _entries2["default"])(props).forEach(function (_ref) {
        var propName = _ref[0],
            propValue = _ref[1];

        if (componentPropTypes[propName]) {
          parentProps[propName] = propValue;
        } else {
          childProps[propName] = propValue;
        }
      });

      return [parentProps, childProps];
    }
    module.exports = exports["default"];

    },{"babel-runtime/core-js/object/entries":110}],107:[function(require,module,exports){
    module.exports = { "default": require("core-js/library/fn/array/from"), __esModule: true };

    },{"core-js/library/fn/array/from":121}],108:[function(require,module,exports){
    module.exports = { "default": require("core-js/library/fn/object/assign"), __esModule: true };

    },{"core-js/library/fn/object/assign":122}],109:[function(require,module,exports){
    module.exports = { "default": require("core-js/library/fn/object/create"), __esModule: true };

    },{"core-js/library/fn/object/create":123}],110:[function(require,module,exports){
    module.exports = { "default": require("core-js/library/fn/object/entries"), __esModule: true };

    },{"core-js/library/fn/object/entries":124}],111:[function(require,module,exports){
    module.exports = { "default": require("core-js/library/fn/object/set-prototype-of"), __esModule: true };

    },{"core-js/library/fn/object/set-prototype-of":125}],112:[function(require,module,exports){
    module.exports = { "default": require("core-js/library/fn/object/values"), __esModule: true };

    },{"core-js/library/fn/object/values":126}],113:[function(require,module,exports){
    module.exports = { "default": require("core-js/library/fn/symbol"), __esModule: true };

    },{"core-js/library/fn/symbol":127}],114:[function(require,module,exports){
    module.exports = { "default": require("core-js/library/fn/symbol/iterator"), __esModule: true };

    },{"core-js/library/fn/symbol/iterator":128}],115:[function(require,module,exports){
    "use strict";

    exports.__esModule = true;

    exports.default = function (instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    };

    },{}],116:[function(require,module,exports){
    "use strict";

    exports.__esModule = true;

    var _assign = require("../core-js/object/assign");

    var _assign2 = _interopRequireDefault(_assign);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    exports.default = _assign2.default || 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;
    };

    },{"../core-js/object/assign":108}],117:[function(require,module,exports){
    "use strict";

    exports.__esModule = true;

    var _setPrototypeOf = require("../core-js/object/set-prototype-of");

    var _setPrototypeOf2 = _interopRequireDefault(_setPrototypeOf);

    var _create = require("../core-js/object/create");

    var _create2 = _interopRequireDefault(_create);

    var _typeof2 = require("../helpers/typeof");

    var _typeof3 = _interopRequireDefault(_typeof2);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    exports.default = function (subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : (0, _typeof3.default)(superClass)));
      }

      subClass.prototype = (0, _create2.default)(superClass && superClass.prototype, {
        constructor: {
          value: subClass,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      if (superClass) _setPrototypeOf2.default ? (0, _setPrototypeOf2.default)(subClass, superClass) : subClass.__proto__ = superClass;
    };

    },{"../core-js/object/create":109,"../core-js/object/set-prototype-of":111,"../helpers/typeof":120}],118:[function(require,module,exports){
    "use strict";

    exports.__esModule = true;

    exports.default = function (obj, keys) {
      var target = {};

      for (var i in obj) {
        if (keys.indexOf(i) >= 0) continue;
        if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;
        target[i] = obj[i];
      }

      return target;
    };

    },{}],119:[function(require,module,exports){
    "use strict";

    exports.__esModule = true;

    var _typeof2 = require("../helpers/typeof");

    var _typeof3 = _interopRequireDefault(_typeof2);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    exports.default = function (self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }

      return call && ((typeof call === "undefined" ? "undefined" : (0, _typeof3.default)(call)) === "object" || typeof call === "function") ? call : self;
    };

    },{"../helpers/typeof":120}],120:[function(require,module,exports){
    "use strict";

    exports.__esModule = true;

    var _iterator = require("../core-js/symbol/iterator");

    var _iterator2 = _interopRequireDefault(_iterator);

    var _symbol = require("../core-js/symbol");

    var _symbol2 = _interopRequireDefault(_symbol);

    var _typeof = typeof _symbol2.default === "function" && typeof _iterator2.default === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof _symbol2.default === "function" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : typeof obj; };

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    exports.default = typeof _symbol2.default === "function" && _typeof(_iterator2.default) === "symbol" ? function (obj) {
      return typeof obj === "undefined" ? "undefined" : _typeof(obj);
    } : function (obj) {
      return obj && typeof _symbol2.default === "function" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : typeof obj === "undefined" ? "undefined" : _typeof(obj);
    };

    },{"../core-js/symbol":113,"../core-js/symbol/iterator":114}],121:[function(require,module,exports){
    require('../../modules/es6.string.iterator');
    require('../../modules/es6.array.from');
    module.exports = require('../../modules/_core').Array.from;

    },{"../../modules/_core":135,"../../modules/es6.array.from":194,"../../modules/es6.string.iterator":200}],122:[function(require,module,exports){
    require('../../modules/es6.object.assign');
    module.exports = require('../../modules/_core').Object.assign;

    },{"../../modules/_core":135,"../../modules/es6.object.assign":196}],123:[function(require,module,exports){
    require('../../modules/es6.object.create');
    var $Object = require('../../modules/_core').Object;
    module.exports = function create(P, D){
      return $Object.create(P, D);
    };

    },{"../../modules/_core":135,"../../modules/es6.object.create":197}],124:[function(require,module,exports){
    require('../../modules/es7.object.entries');
    module.exports = require('../../modules/_core').Object.entries;

    },{"../../modules/_core":135,"../../modules/es7.object.entries":202}],125:[function(require,module,exports){
    require('../../modules/es6.object.set-prototype-of');
    module.exports = require('../../modules/_core').Object.setPrototypeOf;

    },{"../../modules/_core":135,"../../modules/es6.object.set-prototype-of":198}],126:[function(require,module,exports){
    require('../../modules/es7.object.values');
    module.exports = require('../../modules/_core').Object.values;

    },{"../../modules/_core":135,"../../modules/es7.object.values":203}],127:[function(require,module,exports){
    require('../../modules/es6.symbol');
    require('../../modules/es6.object.to-string');
    require('../../modules/es7.symbol.async-iterator');
    require('../../modules/es7.symbol.observable');
    module.exports = require('../../modules/_core').Symbol;

    },{"../../modules/_core":135,"../../modules/es6.object.to-string":199,"../../modules/es6.symbol":201,"../../modules/es7.symbol.async-iterator":204,"../../modules/es7.symbol.observable":205}],128:[function(require,module,exports){
    require('../../modules/es6.string.iterator');
    require('../../modules/web.dom.iterable');
    module.exports = require('../../modules/_wks-ext').f('iterator');

    },{"../../modules/_wks-ext":191,"../../modules/es6.string.iterator":200,"../../modules/web.dom.iterable":206}],129:[function(require,module,exports){
    module.exports = function(it){
      if(typeof it != 'function')throw TypeError(it + ' is not a function!');
      return it;
    };

    },{}],130:[function(require,module,exports){
    module.exports = function(){ /* empty */ };

    },{}],131:[function(require,module,exports){
    var isObject = require('./_is-object');
    module.exports = function(it){
      if(!isObject(it))throw TypeError(it + ' is not an object!');
      return it;
    };

    },{"./_is-object":153}],132:[function(require,module,exports){
    // false -> Array#indexOf
    // true  -> Array#includes
    var toIObject = require('./_to-iobject')
      , toLength  = require('./_to-length')
      , toIndex   = require('./_to-index');
    module.exports = function(IS_INCLUDES){
      return function($this, el, fromIndex){
        var O      = toIObject($this)
          , length = toLength(O.length)
          , index  = toIndex(fromIndex, length)
          , value;
        // Array#includes uses SameValueZero equality algorithm
        if(IS_INCLUDES && el != el)while(length > index){
          value = O[index++];
          if(value != value)return true;
        // Array#toIndex ignores holes, Array#includes - not
        } else for(;length > index; index++)if(IS_INCLUDES || index in O){
          if(O[index] === el)return IS_INCLUDES || index || 0;
        } return !IS_INCLUDES && -1;
      };
    };

    },{"./_to-index":183,"./_to-iobject":185,"./_to-length":186}],133:[function(require,module,exports){
    // getting tag from 19.1.3.6 Object.prototype.toString()
    var cof = require('./_cof')
      , TAG = require('./_wks')('toStringTag')
      // ES3 wrong here
      , ARG = cof(function(){ return arguments; }()) == 'Arguments';

    // fallback for IE11 Script Access Denied error
    var tryGet = function(it, key){
      try {
        return it[key];
      } catch(e){ /* empty */ }
    };

    module.exports = function(it){
      var O, T, B;
      return it === undefined ? 'Undefined' : it === null ? 'Null'
        // @@toStringTag case
        : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T
        // builtinTag case
        : ARG ? cof(O)
        // ES3 arguments fallback
        : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
    };

    },{"./_cof":134,"./_wks":192}],134:[function(require,module,exports){
    var toString = {}.toString;

    module.exports = function(it){
      return toString.call(it).slice(8, -1);
    };

    },{}],135:[function(require,module,exports){
    var core = module.exports = {version: '2.4.0'};
    if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef

    },{}],136:[function(require,module,exports){
    'use strict';
    var $defineProperty = require('./_object-dp')
      , createDesc      = require('./_property-desc');

    module.exports = function(object, index, value){
      if(index in object)$defineProperty.f(object, index, createDesc(0, value));
      else object[index] = value;
    };

    },{"./_object-dp":165,"./_property-desc":176}],137:[function(require,module,exports){
    // optional / simple context binding
    var aFunction = require('./_a-function');
    module.exports = function(fn, that, length){
      aFunction(fn);
      if(that === undefined)return fn;
      switch(length){
        case 1: return function(a){
          return fn.call(that, a);
        };
        case 2: return function(a, b){
          return fn.call(that, a, b);
        };
        case 3: return function(a, b, c){
          return fn.call(that, a, b, c);
        };
      }
      return function(/* ...args */){
        return fn.apply(that, arguments);
      };
    };

    },{"./_a-function":129}],138:[function(require,module,exports){
    // 7.2.1 RequireObjectCoercible(argument)
    module.exports = function(it){
      if(it == undefined)throw TypeError("Can't call method on  " + it);
      return it;
    };

    },{}],139:[function(require,module,exports){
    // Thank's IE8 for his funny defineProperty
    module.exports = !require('./_fails')(function(){
      return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
    });

    },{"./_fails":144}],140:[function(require,module,exports){
    var isObject = require('./_is-object')
      , document = require('./_global').document
      // in old IE typeof document.createElement is 'object'
      , is = isObject(document) && isObject(document.createElement);
    module.exports = function(it){
      return is ? document.createElement(it) : {};
    };

    },{"./_global":145,"./_is-object":153}],141:[function(require,module,exports){
    // IE 8- don't enum bug keys
    module.exports = (
      'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
    ).split(',');

    },{}],142:[function(require,module,exports){
    // all enumerable object keys, includes symbols
    var getKeys = require('./_object-keys')
      , gOPS    = require('./_object-gops')
      , pIE     = require('./_object-pie');
    module.exports = function(it){
      var result     = getKeys(it)
        , getSymbols = gOPS.f;
      if(getSymbols){
        var symbols = getSymbols(it)
          , isEnum  = pIE.f
          , i       = 0
          , key;
        while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))result.push(key);
      } return result;
    };

    },{"./_object-gops":170,"./_object-keys":173,"./_object-pie":174}],143:[function(require,module,exports){
    var global    = require('./_global')
      , core      = require('./_core')
      , ctx       = require('./_ctx')
      , hide      = require('./_hide')
      , PROTOTYPE = 'prototype';

    var $export = function(type, name, source){
      var IS_FORCED = type & $export.F
        , IS_GLOBAL = type & $export.G
        , IS_STATIC = type & $export.S
        , IS_PROTO  = type & $export.P
        , IS_BIND   = type & $export.B
        , IS_WRAP   = type & $export.W
        , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})
        , expProto  = exports[PROTOTYPE]
        , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]
        , key, own, out;
      if(IS_GLOBAL)source = name;
      for(key in source){
        // contains in native
        own = !IS_FORCED && target && target[key] !== undefined;
        if(own && key in exports)continue;
        // export native or passed
        out = own ? target[key] : source[key];
        // prevent global pollution for namespaces
        exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
        // bind timers to global for call from export context
        : IS_BIND && own ? ctx(out, global)
        // wrap global constructors for prevent change them in library
        : IS_WRAP && target[key] == out ? (function(C){
          var F = function(a, b, c){
            if(this instanceof C){
              switch(arguments.length){
                case 0: return new C;
                case 1: return new C(a);
                case 2: return new C(a, b);
              } return new C(a, b, c);
            } return C.apply(this, arguments);
          };
          F[PROTOTYPE] = C[PROTOTYPE];
          return F;
        // make static versions for prototype methods
        })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
        // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%
        if(IS_PROTO){
          (exports.virtual || (exports.virtual = {}))[key] = out;
          // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%
          if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);
        }
      }
    };
    // type bitmap
    $export.F = 1;   // forced
    $export.G = 2;   // global
    $export.S = 4;   // static
    $export.P = 8;   // proto
    $export.B = 16;  // bind
    $export.W = 32;  // wrap
    $export.U = 64;  // safe
    $export.R = 128; // real proto method for `library`
    module.exports = $export;

    },{"./_core":135,"./_ctx":137,"./_global":145,"./_hide":147}],144:[function(require,module,exports){
    module.exports = function(exec){
      try {
        return !!exec();
      } catch(e){
        return true;
      }
    };

    },{}],145:[function(require,module,exports){
    // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
    var global = module.exports = typeof window != 'undefined' && window.Math == Math
      ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
    if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef

    },{}],146:[function(require,module,exports){
    var hasOwnProperty = {}.hasOwnProperty;
    module.exports = function(it, key){
      return hasOwnProperty.call(it, key);
    };

    },{}],147:[function(require,module,exports){
    var dP         = require('./_object-dp')
      , createDesc = require('./_property-desc');
    module.exports = require('./_descriptors') ? function(object, key, value){
      return dP.f(object, key, createDesc(1, value));
    } : function(object, key, value){
      object[key] = value;
      return object;
    };

    },{"./_descriptors":139,"./_object-dp":165,"./_property-desc":176}],148:[function(require,module,exports){
    module.exports = require('./_global').document && document.documentElement;

    },{"./_global":145}],149:[function(require,module,exports){
    module.exports = !require('./_descriptors') && !require('./_fails')(function(){
      return Object.defineProperty(require('./_dom-create')('div'), 'a', {get: function(){ return 7; }}).a != 7;
    });

    },{"./_descriptors":139,"./_dom-create":140,"./_fails":144}],150:[function(require,module,exports){
    // fallback for non-array-like ES3 and non-enumerable old V8 strings
    var cof = require('./_cof');
    module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){
      return cof(it) == 'String' ? it.split('') : Object(it);
    };

    },{"./_cof":134}],151:[function(require,module,exports){
    // check on default Array iterator
    var Iterators  = require('./_iterators')
      , ITERATOR   = require('./_wks')('iterator')
      , ArrayProto = Array.prototype;

    module.exports = function(it){
      return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
    };

    },{"./_iterators":159,"./_wks":192}],152:[function(require,module,exports){
    // 7.2.2 IsArray(argument)
    var cof = require('./_cof');
    module.exports = Array.isArray || function isArray(arg){
      return cof(arg) == 'Array';
    };

    },{"./_cof":134}],153:[function(require,module,exports){
    module.exports = function(it){
      return typeof it === 'object' ? it !== null : typeof it === 'function';
    };

    },{}],154:[function(require,module,exports){
    // call something on iterator step with safe closing on error
    var anObject = require('./_an-object');
    module.exports = function(iterator, fn, value, entries){
      try {
        return entries ? fn(anObject(value)[0], value[1]) : fn(value);
      // 7.4.6 IteratorClose(iterator, completion)
      } catch(e){
        var ret = iterator['return'];
        if(ret !== undefined)anObject(ret.call(iterator));
        throw e;
      }
    };

    },{"./_an-object":131}],155:[function(require,module,exports){
    'use strict';
    var create         = require('./_object-create')
      , descriptor     = require('./_property-desc')
      , setToStringTag = require('./_set-to-string-tag')
      , IteratorPrototype = {};

    // 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
    require('./_hide')(IteratorPrototype, require('./_wks')('iterator'), function(){ return this; });

    module.exports = function(Constructor, NAME, next){
      Constructor.prototype = create(IteratorPrototype, {next: descriptor(1, next)});
      setToStringTag(Constructor, NAME + ' Iterator');
    };

    },{"./_hide":147,"./_object-create":164,"./_property-desc":176,"./_set-to-string-tag":179,"./_wks":192}],156:[function(require,module,exports){
    'use strict';
    var LIBRARY        = require('./_library')
      , $export        = require('./_export')
      , redefine       = require('./_redefine')
      , hide           = require('./_hide')
      , has            = require('./_has')
      , Iterators      = require('./_iterators')
      , $iterCreate    = require('./_iter-create')
      , setToStringTag = require('./_set-to-string-tag')
      , getPrototypeOf = require('./_object-gpo')
      , ITERATOR       = require('./_wks')('iterator')
      , BUGGY          = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`
      , FF_ITERATOR    = '@@iterator'
      , KEYS           = 'keys'
      , VALUES         = 'values';

    var returnThis = function(){ return this; };

    module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){
      $iterCreate(Constructor, NAME, next);
      var getMethod = function(kind){
        if(!BUGGY && kind in proto)return proto[kind];
        switch(kind){
          case KEYS: return function keys(){ return new Constructor(this, kind); };
          case VALUES: return function values(){ return new Constructor(this, kind); };
        } return function entries(){ return new Constructor(this, kind); };
      };
      var TAG        = NAME + ' Iterator'
        , DEF_VALUES = DEFAULT == VALUES
        , VALUES_BUG = false
        , proto      = Base.prototype
        , $native    = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]
        , $default   = $native || getMethod(DEFAULT)
        , $entries   = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined
        , $anyNative = NAME == 'Array' ? proto.entries || $native : $native
        , methods, key, IteratorPrototype;
      // Fix native
      if($anyNative){
        IteratorPrototype = getPrototypeOf($anyNative.call(new Base));
        if(IteratorPrototype !== Object.prototype){
          // Set @@toStringTag to native iterators
          setToStringTag(IteratorPrototype, TAG, true);
          // fix for some old engines
          if(!LIBRARY && !has(IteratorPrototype, ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);
        }
      }
      // fix Array#{values, @@iterator}.name in V8 / FF
      if(DEF_VALUES && $native && $native.name !== VALUES){
        VALUES_BUG = true;
        $default = function values(){ return $native.call(this); };
      }
      // Define iterator
      if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){
        hide(proto, ITERATOR, $default);
      }
      // Plug for library
      Iterators[NAME] = $default;
      Iterators[TAG]  = returnThis;
      if(DEFAULT){
        methods = {
          values:  DEF_VALUES ? $default : getMethod(VALUES),
          keys:    IS_SET     ? $default : getMethod(KEYS),
          entries: $entries
        };
        if(FORCED)for(key in methods){
          if(!(key in proto))redefine(proto, key, methods[key]);
        } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
      }
      return methods;
    };

    },{"./_export":143,"./_has":146,"./_hide":147,"./_iter-create":155,"./_iterators":159,"./_library":161,"./_object-gpo":171,"./_redefine":177,"./_set-to-string-tag":179,"./_wks":192}],157:[function(require,module,exports){
    var ITERATOR     = require('./_wks')('iterator')
      , SAFE_CLOSING = false;

    try {
      var riter = [7][ITERATOR]();
      riter['return'] = function(){ SAFE_CLOSING = true; };
      Array.from(riter, function(){ throw 2; });
    } catch(e){ /* empty */ }

    module.exports = function(exec, skipClosing){
      if(!skipClosing && !SAFE_CLOSING)return false;
      var safe = false;
      try {
        var arr  = [7]
          , iter = arr[ITERATOR]();
        iter.next = function(){ return {done: safe = true}; };
        arr[ITERATOR] = function(){ return iter; };
        exec(arr);
      } catch(e){ /* empty */ }
      return safe;
    };

    },{"./_wks":192}],158:[function(require,module,exports){
    module.exports = function(done, value){
      return {value: value, done: !!done};
    };

    },{}],159:[function(require,module,exports){
    module.exports = {};

    },{}],160:[function(require,module,exports){
    var getKeys   = require('./_object-keys')
      , toIObject = require('./_to-iobject');
    module.exports = function(object, el){
      var O      = toIObject(object)
        , keys   = getKeys(O)
        , length = keys.length
        , index  = 0
        , key;
      while(length > index)if(O[key = keys[index++]] === el)return key;
    };

    },{"./_object-keys":173,"./_to-iobject":185}],161:[function(require,module,exports){
    module.exports = true;

    },{}],162:[function(require,module,exports){
    var META     = require('./_uid')('meta')
      , isObject = require('./_is-object')
      , has      = require('./_has')
      , setDesc  = require('./_object-dp').f
      , id       = 0;
    var isExtensible = Object.isExtensible || function(){
      return true;
    };
    var FREEZE = !require('./_fails')(function(){
      return isExtensible(Object.preventExtensions({}));
    });
    var setMeta = function(it){
      setDesc(it, META, {value: {
        i: 'O' + ++id, // object ID
        w: {}          // weak collections IDs
      }});
    };
    var fastKey = function(it, create){
      // return primitive with prefix
      if(!isObject(it))return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
      if(!has(it, META)){
        // can't set metadata to uncaught frozen object
        if(!isExtensible(it))return 'F';
        // not necessary to add metadata
        if(!create)return 'E';
        // add missing metadata
        setMeta(it);
      // return object ID
      } return it[META].i;
    };
    var getWeak = function(it, create){
      if(!has(it, META)){
        // can't set metadata to uncaught frozen object
        if(!isExtensible(it))return true;
        // not necessary to add metadata
        if(!create)return false;
        // add missing metadata
        setMeta(it);
      // return hash weak collections IDs
      } return it[META].w;
    };
    // add metadata on freeze-family methods calling
    var onFreeze = function(it){
      if(FREEZE && meta.NEED && isExtensible(it) && !has(it, META))setMeta(it);
      return it;
    };
    var meta = module.exports = {
      KEY:      META,
      NEED:     false,
      fastKey:  fastKey,
      getWeak:  getWeak,
      onFreeze: onFreeze
    };

    },{"./_fails":144,"./_has":146,"./_is-object":153,"./_object-dp":165,"./_uid":189}],163:[function(require,module,exports){
    'use strict';
    // 19.1.2.1 Object.assign(target, source, ...)
    var getKeys  = require('./_object-keys')
      , gOPS     = require('./_object-gops')
      , pIE      = require('./_object-pie')
      , toObject = require('./_to-object')
      , IObject  = require('./_iobject')
      , $assign  = Object.assign;

    // should work with symbols and should have deterministic property order (V8 bug)
    module.exports = !$assign || require('./_fails')(function(){
      var A = {}
        , B = {}
        , S = Symbol()
        , K = 'abcdefghijklmnopqrst';
      A[S] = 7;
      K.split('').forEach(function(k){ B[k] = k; });
      return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;
    }) ? function assign(target, source){ // eslint-disable-line no-unused-vars
      var T     = toObject(target)
        , aLen  = arguments.length
        , index = 1
        , getSymbols = gOPS.f
        , isEnum     = pIE.f;
      while(aLen > index){
        var S      = IObject(arguments[index++])
          , keys   = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S)
          , length = keys.length
          , j      = 0
          , key;
        while(length > j)if(isEnum.call(S, key = keys[j++]))T[key] = S[key];
      } return T;
    } : $assign;

    },{"./_fails":144,"./_iobject":150,"./_object-gops":170,"./_object-keys":173,"./_object-pie":174,"./_to-object":187}],164:[function(require,module,exports){
    // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
    var anObject    = require('./_an-object')
      , dPs         = require('./_object-dps')
      , enumBugKeys = require('./_enum-bug-keys')
      , IE_PROTO    = require('./_shared-key')('IE_PROTO')
      , Empty       = function(){ /* empty */ }
      , PROTOTYPE   = 'prototype';

    // Create object with fake `null` prototype: use iframe Object with cleared prototype
    var createDict = function(){
      // Thrash, waste and sodomy: IE GC bug
      var iframe = require('./_dom-create')('iframe')
        , i      = enumBugKeys.length
        , lt     = '<'
        , gt     = '>'
        , iframeDocument;
      iframe.style.display = 'none';
      require('./_html').appendChild(iframe);
      iframe.src = 'javascript:'; // eslint-disable-line no-script-url
      // createDict = iframe.contentWindow.Object;
      // html.removeChild(iframe);
      iframeDocument = iframe.contentWindow.document;
      iframeDocument.open();
      iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
      iframeDocument.close();
      createDict = iframeDocument.F;
      while(i--)delete createDict[PROTOTYPE][enumBugKeys[i]];
      return createDict();
    };

    module.exports = Object.create || function create(O, Properties){
      var result;
      if(O !== null){
        Empty[PROTOTYPE] = anObject(O);
        result = new Empty;
        Empty[PROTOTYPE] = null;
        // add "__proto__" for Object.getPrototypeOf polyfill
        result[IE_PROTO] = O;
      } else result = createDict();
      return Properties === undefined ? result : dPs(result, Properties);
    };

    },{"./_an-object":131,"./_dom-create":140,"./_enum-bug-keys":141,"./_html":148,"./_object-dps":166,"./_shared-key":180}],165:[function(require,module,exports){
    var anObject       = require('./_an-object')
      , IE8_DOM_DEFINE = require('./_ie8-dom-define')
      , toPrimitive    = require('./_to-primitive')
      , dP             = Object.defineProperty;

    exports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes){
      anObject(O);
      P = toPrimitive(P, true);
      anObject(Attributes);
      if(IE8_DOM_DEFINE)try {
        return dP(O, P, Attributes);
      } catch(e){ /* empty */ }
      if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');
      if('value' in Attributes)O[P] = Attributes.value;
      return O;
    };

    },{"./_an-object":131,"./_descriptors":139,"./_ie8-dom-define":149,"./_to-primitive":188}],166:[function(require,module,exports){
    var dP       = require('./_object-dp')
      , anObject = require('./_an-object')
      , getKeys  = require('./_object-keys');

    module.exports = require('./_descriptors') ? Object.defineProperties : function defineProperties(O, Properties){
      anObject(O);
      var keys   = getKeys(Properties)
        , length = keys.length
        , i = 0
        , P;
      while(length > i)dP.f(O, P = keys[i++], Properties[P]);
      return O;
    };

    },{"./_an-object":131,"./_descriptors":139,"./_object-dp":165,"./_object-keys":173}],167:[function(require,module,exports){
    var pIE            = require('./_object-pie')
      , createDesc     = require('./_property-desc')
      , toIObject      = require('./_to-iobject')
      , toPrimitive    = require('./_to-primitive')
      , has            = require('./_has')
      , IE8_DOM_DEFINE = require('./_ie8-dom-define')
      , gOPD           = Object.getOwnPropertyDescriptor;

    exports.f = require('./_descriptors') ? gOPD : function getOwnPropertyDescriptor(O, P){
      O = toIObject(O);
      P = toPrimitive(P, true);
      if(IE8_DOM_DEFINE)try {
        return gOPD(O, P);
      } catch(e){ /* empty */ }
      if(has(O, P))return createDesc(!pIE.f.call(O, P), O[P]);
    };

    },{"./_descriptors":139,"./_has":146,"./_ie8-dom-define":149,"./_object-pie":174,"./_property-desc":176,"./_to-iobject":185,"./_to-primitive":188}],168:[function(require,module,exports){
    // fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
    var toIObject = require('./_to-iobject')
      , gOPN      = require('./_object-gopn').f
      , toString  = {}.toString;

    var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames
      ? Object.getOwnPropertyNames(window) : [];

    var getWindowNames = function(it){
      try {
        return gOPN(it);
      } catch(e){
        return windowNames.slice();
      }
    };

    module.exports.f = function getOwnPropertyNames(it){
      return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it));
    };

    },{"./_object-gopn":169,"./_to-iobject":185}],169:[function(require,module,exports){
    // 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
    var $keys      = require('./_object-keys-internal')
      , hiddenKeys = require('./_enum-bug-keys').concat('length', 'prototype');

    exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O){
      return $keys(O, hiddenKeys);
    };

    },{"./_enum-bug-keys":141,"./_object-keys-internal":172}],170:[function(require,module,exports){
    exports.f = Object.getOwnPropertySymbols;

    },{}],171:[function(require,module,exports){
    // 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
    var has         = require('./_has')
      , toObject    = require('./_to-object')
      , IE_PROTO    = require('./_shared-key')('IE_PROTO')
      , ObjectProto = Object.prototype;

    module.exports = Object.getPrototypeOf || function(O){
      O = toObject(O);
      if(has(O, IE_PROTO))return O[IE_PROTO];
      if(typeof O.constructor == 'function' && O instanceof O.constructor){
        return O.constructor.prototype;
      } return O instanceof Object ? ObjectProto : null;
    };

    },{"./_has":146,"./_shared-key":180,"./_to-object":187}],172:[function(require,module,exports){
    var has          = require('./_has')
      , toIObject    = require('./_to-iobject')
      , arrayIndexOf = require('./_array-includes')(false)
      , IE_PROTO     = require('./_shared-key')('IE_PROTO');

    module.exports = function(object, names){
      var O      = toIObject(object)
        , i      = 0
        , result = []
        , key;
      for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);
      // Don't enum bug & hidden keys
      while(names.length > i)if(has(O, key = names[i++])){
        ~arrayIndexOf(result, key) || result.push(key);
      }
      return result;
    };

    },{"./_array-includes":132,"./_has":146,"./_shared-key":180,"./_to-iobject":185}],173:[function(require,module,exports){
    // 19.1.2.14 / 15.2.3.14 Object.keys(O)
    var $keys       = require('./_object-keys-internal')
      , enumBugKeys = require('./_enum-bug-keys');

    module.exports = Object.keys || function keys(O){
      return $keys(O, enumBugKeys);
    };

    },{"./_enum-bug-keys":141,"./_object-keys-internal":172}],174:[function(require,module,exports){
    exports.f = {}.propertyIsEnumerable;

    },{}],175:[function(require,module,exports){
    var getKeys   = require('./_object-keys')
      , toIObject = require('./_to-iobject')
      , isEnum    = require('./_object-pie').f;
    module.exports = function(isEntries){
      return function(it){
        var O      = toIObject(it)
          , keys   = getKeys(O)
          , length = keys.length
          , i      = 0
          , result = []
          , key;
        while(length > i)if(isEnum.call(O, key = keys[i++])){
          result.push(isEntries ? [key, O[key]] : O[key]);
        } return result;
      };
    };

    },{"./_object-keys":173,"./_object-pie":174,"./_to-iobject":185}],176:[function(require,module,exports){
    module.exports = function(bitmap, value){
      return {
        enumerable  : !(bitmap & 1),
        configurable: !(bitmap & 2),
        writable    : !(bitmap & 4),
        value       : value
      };
    };

    },{}],177:[function(require,module,exports){
    module.exports = require('./_hide');

    },{"./_hide":147}],178:[function(require,module,exports){
    // Works with __proto__ only. Old v8 can't work with null proto objects.
    /* eslint-disable no-proto */
    var isObject = require('./_is-object')
      , anObject = require('./_an-object');
    var check = function(O, proto){
      anObject(O);
      if(!isObject(proto) && proto !== null)throw TypeError(proto + ": can't set as prototype!");
    };
    module.exports = {
      set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line
        function(test, buggy, set){
          try {
            set = require('./_ctx')(Function.call, require('./_object-gopd').f(Object.prototype, '__proto__').set, 2);
            set(test, []);
            buggy = !(test instanceof Array);
          } catch(e){ buggy = true; }
          return function setPrototypeOf(O, proto){
            check(O, proto);
            if(buggy)O.__proto__ = proto;
            else set(O, proto);
            return O;
          };
        }({}, false) : undefined),
      check: check
    };

    },{"./_an-object":131,"./_ctx":137,"./_is-object":153,"./_object-gopd":167}],179:[function(require,module,exports){
    var def = require('./_object-dp').f
      , has = require('./_has')
      , TAG = require('./_wks')('toStringTag');

    module.exports = function(it, tag, stat){
      if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});
    };

    },{"./_has":146,"./_object-dp":165,"./_wks":192}],180:[function(require,module,exports){
    var shared = require('./_shared')('keys')
      , uid    = require('./_uid');
    module.exports = function(key){
      return shared[key] || (shared[key] = uid(key));
    };

    },{"./_shared":181,"./_uid":189}],181:[function(require,module,exports){
    var global = require('./_global')
      , SHARED = '__core-js_shared__'
      , store  = global[SHARED] || (global[SHARED] = {});
    module.exports = function(key){
      return store[key] || (store[key] = {});
    };

    },{"./_global":145}],182:[function(require,module,exports){
    var toInteger = require('./_to-integer')
      , defined   = require('./_defined');
    // true  -> String#at
    // false -> String#codePointAt
    module.exports = function(TO_STRING){
      return function(that, pos){
        var s = String(defined(that))
          , i = toInteger(pos)
          , l = s.length
          , a, b;
        if(i < 0 || i >= l)return TO_STRING ? '' : undefined;
        a = s.charCodeAt(i);
        return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
          ? TO_STRING ? s.charAt(i) : a
          : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
      };
    };

    },{"./_defined":138,"./_to-integer":184}],183:[function(require,module,exports){
    var toInteger = require('./_to-integer')
      , max       = Math.max
      , min       = Math.min;
    module.exports = function(index, length){
      index = toInteger(index);
      return index < 0 ? max(index + length, 0) : min(index, length);
    };

    },{"./_to-integer":184}],184:[function(require,module,exports){
    // 7.1.4 ToInteger
    var ceil  = Math.ceil
      , floor = Math.floor;
    module.exports = function(it){
      return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
    };

    },{}],185:[function(require,module,exports){
    // to indexed object, toObject with fallback for non-array-like ES3 strings
    var IObject = require('./_iobject')
      , defined = require('./_defined');
    module.exports = function(it){
      return IObject(defined(it));
    };

    },{"./_defined":138,"./_iobject":150}],186:[function(require,module,exports){
    // 7.1.15 ToLength
    var toInteger = require('./_to-integer')
      , min       = Math.min;
    module.exports = function(it){
      return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
    };

    },{"./_to-integer":184}],187:[function(require,module,exports){
    // 7.1.13 ToObject(argument)
    var defined = require('./_defined');
    module.exports = function(it){
      return Object(defined(it));
    };

    },{"./_defined":138}],188:[function(require,module,exports){
    // 7.1.1 ToPrimitive(input [, PreferredType])
    var isObject = require('./_is-object');
    // instead of the ES6 spec version, we didn't implement @@toPrimitive case
    // and the second argument - flag - preferred type is a string
    module.exports = function(it, S){
      if(!isObject(it))return it;
      var fn, val;
      if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
      if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;
      if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
      throw TypeError("Can't convert object to primitive value");
    };

    },{"./_is-object":153}],189:[function(require,module,exports){
    var id = 0
      , px = Math.random();
    module.exports = function(key){
      return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
    };

    },{}],190:[function(require,module,exports){
    var global         = require('./_global')
      , core           = require('./_core')
      , LIBRARY        = require('./_library')
      , wksExt         = require('./_wks-ext')
      , defineProperty = require('./_object-dp').f;
    module.exports = function(name){
      var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});
      if(name.charAt(0) != '_' && !(name in $Symbol))defineProperty($Symbol, name, {value: wksExt.f(name)});
    };

    },{"./_core":135,"./_global":145,"./_library":161,"./_object-dp":165,"./_wks-ext":191}],191:[function(require,module,exports){
    exports.f = require('./_wks');

    },{"./_wks":192}],192:[function(require,module,exports){
    var store      = require('./_shared')('wks')
      , uid        = require('./_uid')
      , Symbol     = require('./_global').Symbol
      , USE_SYMBOL = typeof Symbol == 'function';

    var $exports = module.exports = function(name){
      return store[name] || (store[name] =
        USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
    };

    $exports.store = store;

    },{"./_global":145,"./_shared":181,"./_uid":189}],193:[function(require,module,exports){
    var classof   = require('./_classof')
      , ITERATOR  = require('./_wks')('iterator')
      , Iterators = require('./_iterators');
    module.exports = require('./_core').getIteratorMethod = function(it){
      if(it != undefined)return it[ITERATOR]
        || it['@@iterator']
        || Iterators[classof(it)];
    };

    },{"./_classof":133,"./_core":135,"./_iterators":159,"./_wks":192}],194:[function(require,module,exports){
    'use strict';
    var ctx            = require('./_ctx')
      , $export        = require('./_export')
      , toObject       = require('./_to-object')
      , call           = require('./_iter-call')
      , isArrayIter    = require('./_is-array-iter')
      , toLength       = require('./_to-length')
      , createProperty = require('./_create-property')
      , getIterFn      = require('./core.get-iterator-method');

    $export($export.S + $export.F * !require('./_iter-detect')(function(iter){ Array.from(iter); }), 'Array', {
      // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)
      from: function from(arrayLike/*, mapfn = undefined, thisArg = undefined*/){
        var O       = toObject(arrayLike)
          , C       = typeof this == 'function' ? this : Array
          , aLen    = arguments.length
          , mapfn   = aLen > 1 ? arguments[1] : undefined
          , mapping = mapfn !== undefined
          , index   = 0
          , iterFn  = getIterFn(O)
          , length, result, step, iterator;
        if(mapping)mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);
        // if object isn't iterable or it's array with default iterator - use simple case
        if(iterFn != undefined && !(C == Array && isArrayIter(iterFn))){
          for(iterator = iterFn.call(O), result = new C; !(step = iterator.next()).done; index++){
            createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);
          }
        } else {
          length = toLength(O.length);
          for(result = new C(length); length > index; index++){
            createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);
          }
        }
        result.length = index;
        return result;
      }
    });

    },{"./_create-property":136,"./_ctx":137,"./_export":143,"./_is-array-iter":151,"./_iter-call":154,"./_iter-detect":157,"./_to-length":186,"./_to-object":187,"./core.get-iterator-method":193}],195:[function(require,module,exports){
    'use strict';
    var addToUnscopables = require('./_add-to-unscopables')
      , step             = require('./_iter-step')
      , Iterators        = require('./_iterators')
      , toIObject        = require('./_to-iobject');

    // 22.1.3.4 Array.prototype.entries()
    // 22.1.3.13 Array.prototype.keys()
    // 22.1.3.29 Array.prototype.values()
    // 22.1.3.30 Array.prototype[@@iterator]()
    module.exports = require('./_iter-define')(Array, 'Array', function(iterated, kind){
      this._t = toIObject(iterated); // target
      this._i = 0;                   // next index
      this._k = kind;                // kind
    // 22.1.5.2.1 %ArrayIteratorPrototype%.next()
    }, function(){
      var O     = this._t
        , kind  = this._k
        , index = this._i++;
      if(!O || index >= O.length){
        this._t = undefined;
        return step(1);
      }
      if(kind == 'keys'  )return step(0, index);
      if(kind == 'values')return step(0, O[index]);
      return step(0, [index, O[index]]);
    }, 'values');

    // argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
    Iterators.Arguments = Iterators.Array;

    addToUnscopables('keys');
    addToUnscopables('values');
    addToUnscopables('entries');

    },{"./_add-to-unscopables":130,"./_iter-define":156,"./_iter-step":158,"./_iterators":159,"./_to-iobject":185}],196:[function(require,module,exports){
    // 19.1.3.1 Object.assign(target, source)
    var $export = require('./_export');

    $export($export.S + $export.F, 'Object', {assign: require('./_object-assign')});

    },{"./_export":143,"./_object-assign":163}],197:[function(require,module,exports){
    var $export = require('./_export')
    // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
    $export($export.S, 'Object', {create: require('./_object-create')});

    },{"./_export":143,"./_object-create":164}],198:[function(require,module,exports){
    // 19.1.3.19 Object.setPrototypeOf(O, proto)
    var $export = require('./_export');
    $export($export.S, 'Object', {setPrototypeOf: require('./_set-proto').set});

    },{"./_export":143,"./_set-proto":178}],199:[function(require,module,exports){

    },{}],200:[function(require,module,exports){
    'use strict';
    var $at  = require('./_string-at')(true);

    // 21.1.3.27 String.prototype[@@iterator]()
    require('./_iter-define')(String, 'String', function(iterated){
      this._t = String(iterated); // target
      this._i = 0;                // next index
    // 21.1.5.2.1 %StringIteratorPrototype%.next()
    }, function(){
      var O     = this._t
        , index = this._i
        , point;
      if(index >= O.length)return {value: undefined, done: true};
      point = $at(O, index);
      this._i += point.length;
      return {value: point, done: false};
    });

    },{"./_iter-define":156,"./_string-at":182}],201:[function(require,module,exports){
    'use strict';
    // ECMAScript 6 symbols shim
    var global         = require('./_global')
      , has            = require('./_has')
      , DESCRIPTORS    = require('./_descriptors')
      , $export        = require('./_export')
      , redefine       = require('./_redefine')
      , META           = require('./_meta').KEY
      , $fails         = require('./_fails')
      , shared         = require('./_shared')
      , setToStringTag = require('./_set-to-string-tag')
      , uid            = require('./_uid')
      , wks            = require('./_wks')
      , wksExt         = require('./_wks-ext')
      , wksDefine      = require('./_wks-define')
      , keyOf          = require('./_keyof')
      , enumKeys       = require('./_enum-keys')
      , isArray        = require('./_is-array')
      , anObject       = require('./_an-object')
      , toIObject      = require('./_to-iobject')
      , toPrimitive    = require('./_to-primitive')
      , createDesc     = require('./_property-desc')
      , _create        = require('./_object-create')
      , gOPNExt        = require('./_object-gopn-ext')
      , $GOPD          = require('./_object-gopd')
      , $DP            = require('./_object-dp')
      , $keys          = require('./_object-keys')
      , gOPD           = $GOPD.f
      , dP             = $DP.f
      , gOPN           = gOPNExt.f
      , $Symbol        = global.Symbol
      , $JSON          = global.JSON
      , _stringify     = $JSON && $JSON.stringify
      , PROTOTYPE      = 'prototype'
      , HIDDEN         = wks('_hidden')
      , TO_PRIMITIVE   = wks('toPrimitive')
      , isEnum         = {}.propertyIsEnumerable
      , SymbolRegistry = shared('symbol-registry')
      , AllSymbols     = shared('symbols')
      , OPSymbols      = shared('op-symbols')
      , ObjectProto    = Object[PROTOTYPE]
      , USE_NATIVE     = typeof $Symbol == 'function'
      , QObject        = global.QObject;
    // Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173
    var setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;

    // fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
    var setSymbolDesc = DESCRIPTORS && $fails(function(){
      return _create(dP({}, 'a', {
        get: function(){ return dP(this, 'a', {value: 7}).a; }
      })).a != 7;
    }) ? function(it, key, D){
      var protoDesc = gOPD(ObjectProto, key);
      if(protoDesc)delete ObjectProto[key];
      dP(it, key, D);
      if(protoDesc && it !== ObjectProto)dP(ObjectProto, key, protoDesc);
    } : dP;

    var wrap = function(tag){
      var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]);
      sym._k = tag;
      return sym;
    };

    var isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function(it){
      return typeof it == 'symbol';
    } : function(it){
      return it instanceof $Symbol;
    };

    var $defineProperty = function defineProperty(it, key, D){
      if(it === ObjectProto)$defineProperty(OPSymbols, key, D);
      anObject(it);
      key = toPrimitive(key, true);
      anObject(D);
      if(has(AllSymbols, key)){
        if(!D.enumerable){
          if(!has(it, HIDDEN))dP(it, HIDDEN, createDesc(1, {}));
          it[HIDDEN][key] = true;
        } else {
          if(has(it, HIDDEN) && it[HIDDEN][key])it[HIDDEN][key] = false;
          D = _create(D, {enumerable: createDesc(0, false)});
        } return setSymbolDesc(it, key, D);
      } return dP(it, key, D);
    };
    var $defineProperties = function defineProperties(it, P){
      anObject(it);
      var keys = enumKeys(P = toIObject(P))
        , i    = 0
        , l = keys.length
        , key;
      while(l > i)$defineProperty(it, key = keys[i++], P[key]);
      return it;
    };
    var $create = function create(it, P){
      return P === undefined ? _create(it) : $defineProperties(_create(it), P);
    };
    var $propertyIsEnumerable = function propertyIsEnumerable(key){
      var E = isEnum.call(this, key = toPrimitive(key, true));
      if(this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key))return false;
      return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true;
    };
    var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key){
      it  = toIObject(it);
      key = toPrimitive(key, true);
      if(it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key))return;
      var D = gOPD(it, key);
      if(D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key]))D.enumerable = true;
      return D;
    };
    var $getOwnPropertyNames = function getOwnPropertyNames(it){
      var names  = gOPN(toIObject(it))
        , result = []
        , i      = 0
        , key;
      while(names.length > i){
        if(!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META)result.push(key);
      } return result;
    };
    var $getOwnPropertySymbols = function getOwnPropertySymbols(it){
      var IS_OP  = it === ObjectProto
        , names  = gOPN(IS_OP ? OPSymbols : toIObject(it))
        , result = []
        , i      = 0
        , key;
      while(names.length > i){
        if(has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true))result.push(AllSymbols[key]);
      } return result;
    };

    // 19.4.1.1 Symbol([description])
    if(!USE_NATIVE){
      $Symbol = function Symbol(){
        if(this instanceof $Symbol)throw TypeError('Symbol is not a constructor!');
        var tag = uid(arguments.length > 0 ? arguments[0] : undefined);
        var $set = function(value){
          if(this === ObjectProto)$set.call(OPSymbols, value);
          if(has(this, HIDDEN) && has(this[HIDDEN], tag))this[HIDDEN][tag] = false;
          setSymbolDesc(this, tag, createDesc(1, value));
        };
        if(DESCRIPTORS && setter)setSymbolDesc(ObjectProto, tag, {configurable: true, set: $set});
        return wrap(tag);
      };
      redefine($Symbol[PROTOTYPE], 'toString', function toString(){
        return this._k;
      });

      $GOPD.f = $getOwnPropertyDescriptor;
      $DP.f   = $defineProperty;
      require('./_object-gopn').f = gOPNExt.f = $getOwnPropertyNames;
      require('./_object-pie').f  = $propertyIsEnumerable;
      require('./_object-gops').f = $getOwnPropertySymbols;

      if(DESCRIPTORS && !require('./_library')){
        redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);
      }

      wksExt.f = function(name){
        return wrap(wks(name));
      }
    }

    $export($export.G + $export.W + $export.F * !USE_NATIVE, {Symbol: $Symbol});

    for(var symbols = (
      // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14
      'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'
    ).split(','), i = 0; symbols.length > i; )wks(symbols[i++]);

    for(var symbols = $keys(wks.store), i = 0; symbols.length > i; )wksDefine(symbols[i++]);

    $export($export.S + $export.F * !USE_NATIVE, 'Symbol', {
      // 19.4.2.1 Symbol.for(key)
      'for': function(key){
        return has(SymbolRegistry, key += '')
          ? SymbolRegistry[key]
          : SymbolRegistry[key] = $Symbol(key);
      },
      // 19.4.2.5 Symbol.keyFor(sym)
      keyFor: function keyFor(key){
        if(isSymbol(key))return keyOf(SymbolRegistry, key);
        throw TypeError(key + ' is not a symbol!');
      },
      useSetter: function(){ setter = true; },
      useSimple: function(){ setter = false; }
    });

    $export($export.S + $export.F * !USE_NATIVE, 'Object', {
      // 19.1.2.2 Object.create(O [, Properties])
      create: $create,
      // 19.1.2.4 Object.defineProperty(O, P, Attributes)
      defineProperty: $defineProperty,
      // 19.1.2.3 Object.defineProperties(O, Properties)
      defineProperties: $defineProperties,
      // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
      getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
      // 19.1.2.7 Object.getOwnPropertyNames(O)
      getOwnPropertyNames: $getOwnPropertyNames,
      // 19.1.2.8 Object.getOwnPropertySymbols(O)
      getOwnPropertySymbols: $getOwnPropertySymbols
    });

    // 24.3.2 JSON.stringify(value [, replacer [, space]])
    $JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function(){
      var S = $Symbol();
      // MS Edge converts symbol values to JSON as {}
      // WebKit converts symbol values to JSON as null
      // V8 throws on boxed symbols
      return _stringify([S]) != '[null]' || _stringify({a: S}) != '{}' || _stringify(Object(S)) != '{}';
    })), 'JSON', {
      stringify: function stringify(it){
        if(it === undefined || isSymbol(it))return; // IE8 returns string on undefined
        var args = [it]
          , i    = 1
          , replacer, $replacer;
        while(arguments.length > i)args.push(arguments[i++]);
        replacer = args[1];
        if(typeof replacer == 'function')$replacer = replacer;
        if($replacer || !isArray(replacer))replacer = function(key, value){
          if($replacer)value = $replacer.call(this, key, value);
          if(!isSymbol(value))return value;
        };
        args[1] = replacer;
        return _stringify.apply($JSON, args);
      }
    });

    // 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)
    $Symbol[PROTOTYPE][TO_PRIMITIVE] || require('./_hide')($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);
    // 19.4.3.5 Symbol.prototype[@@toStringTag]
    setToStringTag($Symbol, 'Symbol');
    // 20.2.1.9 Math[@@toStringTag]
    setToStringTag(Math, 'Math', true);
    // 24.3.3 JSON[@@toStringTag]
    setToStringTag(global.JSON, 'JSON', true);

    },{"./_an-object":131,"./_descriptors":139,"./_enum-keys":142,"./_export":143,"./_fails":144,"./_global":145,"./_has":146,"./_hide":147,"./_is-array":152,"./_keyof":160,"./_library":161,"./_meta":162,"./_object-create":164,"./_object-dp":165,"./_object-gopd":167,"./_object-gopn":169,"./_object-gopn-ext":168,"./_object-gops":170,"./_object-keys":173,"./_object-pie":174,"./_property-desc":176,"./_redefine":177,"./_set-to-string-tag":179,"./_shared":181,"./_to-iobject":185,"./_to-primitive":188,"./_uid":189,"./_wks":192,"./_wks-define":190,"./_wks-ext":191}],202:[function(require,module,exports){
    // https://github.com/tc39/proposal-object-values-entries
    var $export  = require('./_export')
      , $entries = require('./_object-to-array')(true);

    $export($export.S, 'Object', {
      entries: function entries(it){
        return $entries(it);
      }
    });

    },{"./_export":143,"./_object-to-array":175}],203:[function(require,module,exports){
    // https://github.com/tc39/proposal-object-values-entries
    var $export = require('./_export')
      , $values = require('./_object-to-array')(false);

    $export($export.S, 'Object', {
      values: function values(it){
        return $values(it);
      }
    });

    },{"./_export":143,"./_object-to-array":175}],204:[function(require,module,exports){
    require('./_wks-define')('asyncIterator');

    },{"./_wks-define":190}],205:[function(require,module,exports){
    require('./_wks-define')('observable');

    },{"./_wks-define":190}],206:[function(require,module,exports){
    require('./es6.array.iterator');
    var global        = require('./_global')
      , hide          = require('./_hide')
      , Iterators     = require('./_iterators')
      , TO_STRING_TAG = require('./_wks')('toStringTag');

    for(var collections = ['NodeList', 'DOMTokenList', 'MediaList', 'StyleSheetList', 'CSSRuleList'], i = 0; i < 5; i++){
      var NAME       = collections[i]
        , Collection = global[NAME]
        , proto      = Collection && Collection.prototype;
      if(proto && !proto[TO_STRING_TAG])hide(proto, TO_STRING_TAG, NAME);
      Iterators[NAME] = Iterators.Array;
    }

    },{"./_global":145,"./_hide":147,"./_iterators":159,"./_wks":192,"./es6.array.iterator":195}],207:[function(require,module,exports){
    /*!
      Copyright (c) 2016 Jed Watson.
      Licensed under the MIT License (MIT), see
      http://jedwatson.github.io/classnames
    */
    /* global define */

    (function () {
    	'use strict';

    	var hasOwn = {}.hasOwnProperty;

    	function classNames () {
    		var classes = [];

    		for (var i = 0; i < arguments.length; i++) {
    			var arg = arguments[i];
    			if (!arg) continue;

    			var argType = typeof arg;

    			if (argType === 'string' || argType === 'number') {
    				classes.push(arg);
    			} else if (Array.isArray(arg)) {
    				classes.push(classNames.apply(null, arg));
    			} else if (argType === 'object') {
    				for (var key in arg) {
    					if (hasOwn.call(arg, key) && arg[key]) {
    						classes.push(key);
    					}
    				}
    			}
    		}

    		return classes.join(' ');
    	}

    	if (typeof module !== 'undefined' && module.exports) {
    		module.exports = classNames;
    	} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {
    		// register as 'classnames', consistent with npm package name
    		define('classnames', [], function () {
    			return classNames;
    		});
    	} else {
    		window.classNames = classNames;
    	}
    }());

    },{}],208:[function(require,module,exports){
    'use strict';

    var babelHelpers = require('./util/babelHelpers.js');

    exports.__esModule = true;

    /**
     * document.activeElement
     */
    exports['default'] = activeElement;

    var _ownerDocument = require('./ownerDocument');

    var _ownerDocument2 = babelHelpers.interopRequireDefault(_ownerDocument);

    function activeElement() {
      var doc = arguments[0] === undefined ? document : arguments[0];

      try {
        return doc.activeElement;
      } catch (e) {}
    }

    module.exports = exports['default'];

    },{"./ownerDocument":217,"./util/babelHelpers.js":230}],209:[function(require,module,exports){
    'use strict';
    var hasClass = require('./hasClass');

    module.exports = function addClass(element, className) {
      if (element.classList) element.classList.add(className);else if (!hasClass(element)) element.className = element.className + ' ' + className;
    };

    },{"./hasClass":210}],210:[function(require,module,exports){
    'use strict';
    module.exports = function hasClass(element, className) {
      if (element.classList) return !!className && element.classList.contains(className);else return (' ' + element.className + ' ').indexOf(' ' + className + ' ') !== -1;
    };

    },{}],211:[function(require,module,exports){
    'use strict';

    module.exports = {
      addClass: require('./addClass'),
      removeClass: require('./removeClass'),
      hasClass: require('./hasClass')
    };

    },{"./addClass":209,"./hasClass":210,"./removeClass":212}],212:[function(require,module,exports){
    'use strict';

    module.exports = function removeClass(element, className) {
      if (element.classList) element.classList.remove(className);else element.className = element.className.replace(new RegExp('(^|\\s)' + className + '(?:\\s|$)', 'g'), '$1').replace(/\s+/g, ' ').replace(/^\s*|\s*$/g, '');
    };

    },{}],213:[function(require,module,exports){
    'use strict';

    var contains = require('../query/contains'),
        qsa = require('../query/querySelectorAll');

    module.exports = function (selector, handler) {
      return function (e) {
        var top = e.currentTarget,
            target = e.target,
            matches = qsa(top, selector);

        if (matches.some(function (match) {
          return contains(match, target);
        })) handler.call(this, e);
      };
    };

    },{"../query/contains":218,"../query/querySelectorAll":223}],214:[function(require,module,exports){
    'use strict';
    var on = require('./on'),
        off = require('./off'),
        filter = require('./filter');

    module.exports = { on: on, off: off, filter: filter };

    },{"./filter":213,"./off":215,"./on":216}],215:[function(require,module,exports){
    'use strict';
    var canUseDOM = require('../util/inDOM');
    var off = function off() {};

    if (canUseDOM) {

      off = (function () {

        if (document.addEventListener) return function (node, eventName, handler, capture) {
          return node.removeEventListener(eventName, handler, capture || false);
        };else if (document.attachEvent) return function (node, eventName, handler) {
          return node.detachEvent('on' + eventName, handler);
        };
      })();
    }

    module.exports = off;

    },{"../util/inDOM":235}],216:[function(require,module,exports){
    'use strict';
    var canUseDOM = require('../util/inDOM');
    var on = function on() {};

    if (canUseDOM) {
      on = (function () {

        if (document.addEventListener) return function (node, eventName, handler, capture) {
          return node.addEventListener(eventName, handler, capture || false);
        };else if (document.attachEvent) return function (node, eventName, handler) {
          return node.attachEvent('on' + eventName, handler);
        };
      })();
    }

    module.exports = on;

    },{"../util/inDOM":235}],217:[function(require,module,exports){
    "use strict";

    exports.__esModule = true;
    exports["default"] = ownerDocument;

    function ownerDocument(node) {
      return node && node.ownerDocument || document;
    }

    module.exports = exports["default"];

    },{}],218:[function(require,module,exports){
    'use strict';
    var canUseDOM = require('../util/inDOM');

    var contains = (function () {
      var root = canUseDOM && document.documentElement;

      return root && root.contains ? function (context, node) {
        return context.contains(node);
      } : root && root.compareDocumentPosition ? function (context, node) {
        return context === node || !!(context.compareDocumentPosition(node) & 16);
      } : function (context, node) {
        if (node) do {
          if (node === context) return true;
        } while (node = node.parentNode);

        return false;
      };
    })();

    module.exports = contains;

    },{"../util/inDOM":235}],219:[function(require,module,exports){
    'use strict';

    module.exports = function getWindow(node) {
      return node === node.window ? node : node.nodeType === 9 ? node.defaultView || node.parentWindow : false;
    };

    },{}],220:[function(require,module,exports){
    'use strict';
    var contains = require('./contains'),
        getWindow = require('./isWindow'),
        ownerDocument = require('../ownerDocument');

    module.exports = function offset(node) {
      var doc = ownerDocument(node),
          win = getWindow(doc),
          docElem = doc && doc.documentElement,
          box = { top: 0, left: 0, height: 0, width: 0 };

      if (!doc) return;

      // Make sure it's not a disconnected DOM node
      if (!contains(docElem, node)) return box;

      if (node.getBoundingClientRect !== undefined) box = node.getBoundingClientRect();

      if (box.width || box.height) {

        box = {
          top: box.top + (win.pageYOffset || docElem.scrollTop) - (docElem.clientTop || 0),
          left: box.left + (win.pageXOffset || docElem.scrollLeft) - (docElem.clientLeft || 0),
          width: (box.width == null ? node.offsetWidth : box.width) || 0,
          height: (box.height == null ? node.offsetHeight : box.height) || 0
        };
      }

      return box;
    };

    },{"../ownerDocument":217,"./contains":218,"./isWindow":219}],221:[function(require,module,exports){
    'use strict';

    var babelHelpers = require('../util/babelHelpers.js');

    exports.__esModule = true;
    exports['default'] = offsetParent;

    var _ownerDocument = require('../ownerDocument');

    var _ownerDocument2 = babelHelpers.interopRequireDefault(_ownerDocument);

    var _style = require('../style');

    var _style2 = babelHelpers.interopRequireDefault(_style);

    function nodeName(node) {
      return node.nodeName && node.nodeName.toLowerCase();
    }

    function offsetParent(node) {
      var doc = (0, _ownerDocument2['default'])(node),
          offsetParent = node && node.offsetParent;

      while (offsetParent && nodeName(node) !== 'html' && (0, _style2['default'])(offsetParent, 'position') === 'static') {
        offsetParent = offsetParent.offsetParent;
      }

      return offsetParent || doc.documentElement;
    }

    module.exports = exports['default'];

    },{"../ownerDocument":217,"../style":227,"../util/babelHelpers.js":230}],222:[function(require,module,exports){
    'use strict';

    var babelHelpers = require('../util/babelHelpers.js');

    exports.__esModule = true;
    exports['default'] = position;

    var _offset = require('./offset');

    var _offset2 = babelHelpers.interopRequireDefault(_offset);

    var _offsetParent = require('./offsetParent');

    var _offsetParent2 = babelHelpers.interopRequireDefault(_offsetParent);

    var _scrollTop = require('./scrollTop');

    var _scrollTop2 = babelHelpers.interopRequireDefault(_scrollTop);

    var _scrollLeft = require('./scrollLeft');

    var _scrollLeft2 = babelHelpers.interopRequireDefault(_scrollLeft);

    var _style = require('../style');

    var _style2 = babelHelpers.interopRequireDefault(_style);

    function nodeName(node) {
      return node.nodeName && node.nodeName.toLowerCase();
    }

    function position(node, offsetParent) {
      var parentOffset = { top: 0, left: 0 },
          offset;

      // Fixed elements are offset from window (parentOffset = {top:0, left: 0},
      // because it is its only offset parent
      if ((0, _style2['default'])(node, 'position') === 'fixed') {
        offset = node.getBoundingClientRect();
      } else {
        offsetParent = offsetParent || (0, _offsetParent2['default'])(node);
        offset = (0, _offset2['default'])(node);

        if (nodeName(offsetParent) !== 'html') parentOffset = (0, _offset2['default'])(offsetParent);

        parentOffset.top += parseInt((0, _style2['default'])(offsetParent, 'borderTopWidth'), 10) - (0, _scrollTop2['default'])(offsetParent) || 0;
        parentOffset.left += parseInt((0, _style2['default'])(offsetParent, 'borderLeftWidth'), 10) - (0, _scrollLeft2['default'])(offsetParent) || 0;
      }

      // Subtract parent offsets and node margins
      return babelHelpers._extends({}, offset, {
        top: offset.top - parentOffset.top - (parseInt((0, _style2['default'])(node, 'marginTop'), 10) || 0),
        left: offset.left - parentOffset.left - (parseInt((0, _style2['default'])(node, 'marginLeft'), 10) || 0)
      });
    }

    module.exports = exports['default'];

    },{"../style":227,"../util/babelHelpers.js":230,"./offset":220,"./offsetParent":221,"./scrollLeft":224,"./scrollTop":225}],223:[function(require,module,exports){
    'use strict';
    //     Zepto.js
    //     (c) 2010-2015 Thomas Fuchs
    //     Zepto.js may be freely distributed under the MIT license.
    var simpleSelectorRE = /^[\w-]*$/,
        toArray = Function.prototype.bind.call(Function.prototype.call, [].slice);

    module.exports = function qsa(element, selector) {
      var maybeID = selector[0] === '#',
          maybeClass = selector[0] === '.',
          nameOnly = maybeID || maybeClass ? selector.slice(1) : selector,
          isSimple = simpleSelectorRE.test(nameOnly),
          found;

      if (isSimple) {
        if (maybeID) {
          element = element.getElementById ? element : document;
          return (found = element.getElementById(nameOnly)) ? [found] : [];
        }

        if (element.getElementsByClassName && maybeClass) return toArray(element.getElementsByClassName(nameOnly));

        return toArray(element.getElementsByTagName(selector));
      }

      return toArray(element.querySelectorAll(selector));
    };

    },{}],224:[function(require,module,exports){
    'use strict';
    var getWindow = require('./isWindow');

    module.exports = function scrollTop(node, val) {
      var win = getWindow(node);

      if (val === undefined) return win ? 'pageXOffset' in win ? win.pageXOffset : win.document.documentElement.scrollLeft : node.scrollLeft;

      if (win) win.scrollTo(val, 'pageYOffset' in win ? win.pageYOffset : win.document.documentElement.scrollTop);else node.scrollLeft = val;
    };

    },{"./isWindow":219}],225:[function(require,module,exports){
    'use strict';
    var getWindow = require('./isWindow');

    module.exports = function scrollTop(node, val) {
      var win = getWindow(node);

      if (val === undefined) return win ? 'pageYOffset' in win ? win.pageYOffset : win.document.documentElement.scrollTop : node.scrollTop;

      if (win) win.scrollTo('pageXOffset' in win ? win.pageXOffset : win.document.documentElement.scrollLeft, val);else node.scrollTop = val;
    };

    },{"./isWindow":219}],226:[function(require,module,exports){
    'use strict';

    var babelHelpers = require('../util/babelHelpers.js');

    var _utilCamelizeStyle = require('../util/camelizeStyle');

    var _utilCamelizeStyle2 = babelHelpers.interopRequireDefault(_utilCamelizeStyle);

    var rposition = /^(top|right|bottom|left)$/;
    var rnumnonpx = /^([+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|))(?!px)[a-z%]+$/i;

    module.exports = function _getComputedStyle(node) {
      if (!node) throw new TypeError('No Element passed to `getComputedStyle()`');
      var doc = node.ownerDocument;

      return 'defaultView' in doc ? doc.defaultView.opener ? node.ownerDocument.defaultView.getComputedStyle(node, null) : window.getComputedStyle(node, null) : { //ie 8 "magic" from: https://github.com/jquery/jquery/blob/1.11-stable/src/css/curCSS.js#L72
        getPropertyValue: function getPropertyValue(prop) {
          var style = node.style;

          prop = (0, _utilCamelizeStyle2['default'])(prop);

          if (prop == 'float') prop = 'styleFloat';

          var current = node.currentStyle[prop] || null;

          if (current == null && style && style[prop]) current = style[prop];

          if (rnumnonpx.test(current) && !rposition.test(prop)) {
            // Remember the original values
            var left = style.left;
            var runStyle = node.runtimeStyle;
            var rsLeft = runStyle && runStyle.left;

            // Put in the new values to get a computed value out
            if (rsLeft) runStyle.left = node.currentStyle.left;

            style.left = prop === 'fontSize' ? '1em' : current;
            current = style.pixelLeft + 'px';

            // Revert the changed values
            style.left = left;
            if (rsLeft) runStyle.left = rsLeft;
          }

          return current;
        }
      };
    };

    },{"../util/babelHelpers.js":230,"../util/camelizeStyle":232}],227:[function(require,module,exports){
    'use strict';

    var camelize = require('../util/camelizeStyle'),
        hyphenate = require('../util/hyphenateStyle'),
        _getComputedStyle = require('./getComputedStyle'),
        removeStyle = require('./removeStyle');

    var has = Object.prototype.hasOwnProperty;

    module.exports = function style(node, property, value) {
      var css = '',
          props = property;

      if (typeof property === 'string') {

        if (value === undefined) return node.style[camelize(property)] || _getComputedStyle(node).getPropertyValue(hyphenate(property));else (props = {})[property] = value;
      }

      for (var key in props) if (has.call(props, key)) {
        !props[key] && props[key] !== 0 ? removeStyle(node, hyphenate(key)) : css += hyphenate(key) + ':' + props[key] + ';';
      }

      node.style.cssText += ';' + css;
    };

    },{"../util/camelizeStyle":232,"../util/hyphenateStyle":234,"./getComputedStyle":226,"./removeStyle":228}],228:[function(require,module,exports){
    'use strict';

    module.exports = function removeStyle(node, key) {
      return 'removeProperty' in node.style ? node.style.removeProperty(key) : node.style.removeAttribute(key);
    };

    },{}],229:[function(require,module,exports){
    'use strict';
    var canUseDOM = require('../util/inDOM');

    var has = Object.prototype.hasOwnProperty,
        transform = 'transform',
        transition = {},
        transitionTiming,
        transitionDuration,
        transitionProperty,
        transitionDelay;

    if (canUseDOM) {
      transition = getTransitionProperties();

      transform = transition.prefix + transform;

      transitionProperty = transition.prefix + 'transition-property';
      transitionDuration = transition.prefix + 'transition-duration';
      transitionDelay = transition.prefix + 'transition-delay';
      transitionTiming = transition.prefix + 'transition-timing-function';
    }

    module.exports = {
      transform: transform,
      end: transition.end,
      property: transitionProperty,
      timing: transitionTiming,
      delay: transitionDelay,
      duration: transitionDuration
    };

    function getTransitionProperties() {
      var endEvent,
          prefix = '',
          transitions = {
        O: 'otransitionend',
        Moz: 'transitionend',
        Webkit: 'webkitTransitionEnd',
        ms: 'MSTransitionEnd'
      };

      var element = document.createElement('div');

      for (var vendor in transitions) if (has.call(transitions, vendor)) {
        if (element.style[vendor + 'TransitionProperty'] !== undefined) {
          prefix = '-' + vendor.toLowerCase() + '-';
          endEvent = transitions[vendor];
          break;
        }
      }

      if (!endEvent && element.style.transitionProperty !== undefined) endEvent = 'transitionend';

      return { end: endEvent, prefix: prefix };
    }

    },{"../util/inDOM":235}],230:[function(require,module,exports){
    (function (root, factory) {
      if (typeof define === "function" && define.amd) {
        define(["exports"], factory);
      } else if (typeof exports === "object") {
        factory(exports);
      } else {
        factory(root.babelHelpers = {});
      }
    })(this, function (global) {
      var babelHelpers = global;

      babelHelpers.interopRequireDefault = function (obj) {
        return obj && obj.__esModule ? obj : {
          "default": obj
        };
      };

      babelHelpers._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;
      };
    })

    },{}],231:[function(require,module,exports){
    "use strict";

    var rHyphen = /-(.)/g;

    module.exports = function camelize(string) {
      return string.replace(rHyphen, function (_, chr) {
        return chr.toUpperCase();
      });
    };

    },{}],232:[function(require,module,exports){
    /**
     * Copyright 2014-2015, Facebook, Inc.
     * All rights reserved.
     * https://github.com/facebook/react/blob/2aeb8a2a6beb00617a4217f7f8284924fa2ad819/src/vendor/core/camelizeStyleName.js
     */

    'use strict';
    var camelize = require('./camelize');
    var msPattern = /^-ms-/;

    module.exports = function camelizeStyleName(string) {
      return camelize(string.replace(msPattern, 'ms-'));
    };

    },{"./camelize":231}],233:[function(require,module,exports){
    'use strict';

    var rUpper = /([A-Z])/g;

    module.exports = function hyphenate(string) {
      return string.replace(rUpper, '-$1').toLowerCase();
    };

    },{}],234:[function(require,module,exports){
    /**
     * Copyright 2013-2014, Facebook, Inc.
     * All rights reserved.
     * https://github.com/facebook/react/blob/2aeb8a2a6beb00617a4217f7f8284924fa2ad819/src/vendor/core/hyphenateStyleName.js
     */

    "use strict";

    var hyphenate = require("./hyphenate");
    var msPattern = /^ms-/;

    module.exports = function hyphenateStyleName(string) {
      return hyphenate(string).replace(msPattern, "-ms-");
    };

    },{"./hyphenate":233}],235:[function(require,module,exports){
    'use strict';
    module.exports = !!(typeof window !== 'undefined' && window.document && window.document.createElement);

    },{}],236:[function(require,module,exports){
    'use strict';

    var canUseDOM = require('./inDOM');

    var size;

    module.exports = function (recalc) {
      if (!size || recalc) {
        if (canUseDOM) {
          var scrollDiv = document.createElement('div');

          scrollDiv.style.position = 'absolute';
          scrollDiv.style.top = '-9999px';
          scrollDiv.style.width = '50px';
          scrollDiv.style.height = '50px';
          scrollDiv.style.overflow = 'scroll';

          document.body.appendChild(scrollDiv);
          size = scrollDiv.offsetWidth - scrollDiv.clientWidth;
          document.body.removeChild(scrollDiv);
        }
      }

      return size;
    };

    },{"./inDOM":235}],237:[function(require,module,exports){
    (function (process){
    /**
     * Copyright 2013-2015, Facebook, Inc.
     * All rights reserved.
     *
     * This source code is licensed under the BSD-style license found in the
     * LICENSE file in the root directory of this source tree. An additional grant
     * of patent rights can be found in the PATENTS file in the same directory.
     */

    '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.
     */

    var invariant = function(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;

    }).call(this,require('_process'))
    },{"_process":728}],238:[function(require,module,exports){
    // Source: http://jsfiddle.net/vWx8V/
    // http://stackoverflow.com/questions/5603195/full-list-of-javascript-keycodes

    /**
     * Conenience method returns corresponding value for given keyName or keyCode.
     *
     * @param {Mixed} keyCode {Number} or keyName {String}
     * @return {Mixed}
     * @api public
     */

    exports = module.exports = function(searchInput) {
      // Keyboard Events
      if (searchInput && 'object' === typeof searchInput) {
        var hasKeyCode = searchInput.which || searchInput.keyCode || searchInput.charCode
        if (hasKeyCode) searchInput = hasKeyCode
      }

      // Numbers
      if ('number' === typeof searchInput) return names[searchInput]

      // Everything else (cast to string)
      var search = String(searchInput)

      // check codes
      var foundNamedKey = codes[search.toLowerCase()]
      if (foundNamedKey) return foundNamedKey

      // check aliases
      var foundNamedKey = aliases[search.toLowerCase()]
      if (foundNamedKey) return foundNamedKey

      // weird character?
      if (search.length === 1) return search.charCodeAt(0)

      return undefined
    }

    /**
     * Get by name
     *
     *   exports.code['enter'] // => 13
     */

    var codes = exports.code = exports.codes = {
      'backspace': 8,
      'tab': 9,
      'enter': 13,
      'shift': 16,
      'ctrl': 17,
      'alt': 18,
      'pause/break': 19,
      'caps lock': 20,
      'esc': 27,
      'space': 32,
      'page up': 33,
      'page down': 34,
      'end': 35,
      'home': 36,
      'left': 37,
      'up': 38,
      'right': 39,
      'down': 40,
      'insert': 45,
      'delete': 46,
      'command': 91,
      'left command': 91,
      'right command': 93,
      'numpad *': 106,
      'numpad +': 107,
      'numpad -': 109,
      'numpad .': 110,
      'numpad /': 111,
      'num lock': 144,
      'scroll lock': 145,
      'my computer': 182,
      'my calculator': 183,
      ';': 186,
      '=': 187,
      ',': 188,
      '-': 189,
      '.': 190,
      '/': 191,
      '`': 192,
      '[': 219,
      '\\': 220,
      ']': 221,
      "'": 222
    }

    // Helper aliases

    var aliases = exports.aliases = {
      'windows': 91,
      '⇧': 16,
      '⌥': 18,
      '⌃': 17,
      '⌘': 91,
      'ctl': 17,
      'control': 17,
      'option': 18,
      'pause': 19,
      'break': 19,
      'caps': 20,
      'return': 13,
      'escape': 27,
      'spc': 32,
      'pgup': 33,
      'pgdn': 34,
      'ins': 45,
      'del': 46,
      'cmd': 91
    }

    /*!
     * Programatically add the following
     */

    // lower case chars
    for (i = 97; i < 123; i++) codes[String.fromCharCode(i)] = i - 32

    // numbers
    for (var i = 48; i < 58; i++) codes[i - 48] = i

    // function keys
    for (i = 1; i < 13; i++) codes['f'+i] = i + 111

    // numpad keys
    for (i = 0; i < 10; i++) codes['numpad '+i] = i + 96

    /**
     * Get by code
     *
     *   exports.name[13] // => 'Enter'
     */

    var names = exports.names = exports.title = {} // title for backward compat

    // Create reverse mapping
    for (i in codes) names[codes[i]] = i

    // Add aliases
    for (var alias in aliases) {
      codes[alias] = aliases[alias]
    }

    },{}],239:[function(require,module,exports){
    'use strict';

    Object.defineProperty(exports, "__esModule", {
      value: true
    });

    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; }; /*eslint-disable react/prop-types */

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _warning = require('warning');

    var _warning2 = _interopRequireDefault(_warning);

    var _componentOrElement = require('react-prop-types/lib/componentOrElement');

    var _componentOrElement2 = _interopRequireDefault(_componentOrElement);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    var _Portal = require('./Portal');

    var _Portal2 = _interopRequireDefault(_Portal);

    var _ModalManager = require('./ModalManager');

    var _ModalManager2 = _interopRequireDefault(_ModalManager);

    var _ownerDocument = require('./utils/ownerDocument');

    var _ownerDocument2 = _interopRequireDefault(_ownerDocument);

    var _addEventListener = require('./utils/addEventListener');

    var _addEventListener2 = _interopRequireDefault(_addEventListener);

    var _addFocusListener = require('./utils/addFocusListener');

    var _addFocusListener2 = _interopRequireDefault(_addFocusListener);

    var _inDOM = require('dom-helpers/util/inDOM');

    var _inDOM2 = _interopRequireDefault(_inDOM);

    var _activeElement = require('dom-helpers/activeElement');

    var _activeElement2 = _interopRequireDefault(_activeElement);

    var _contains = require('dom-helpers/query/contains');

    var _contains2 = _interopRequireDefault(_contains);

    var _getContainer = require('./utils/getContainer');

    var _getContainer2 = _interopRequireDefault(_getContainer);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    var modalManager = new _ModalManager2.default();

    /**
     * Love them or hate them, `<Modal/>` provides a solid foundation for creating dialogs, lightboxes, or whatever else.
     * The Modal component renders its `children` node in front of a backdrop component.
     *
     * The Modal offers a few helpful features over using just a `<Portal/>` component and some styles:
     *
     * - Manages dialog stacking when one-at-a-time just isn't enough.
     * - Creates a backdrop, for disabling interaction below the modal.
     * - It properly manages focus; moving to the modal content, and keeping it there until the modal is closed.
     * - It disables scrolling of the page content while open.
     * - Adds the appropriate ARIA roles are automatically.
     * - Easily pluggable animations via a `<Transition/>` component.
     *
     * Note that, in the same way the backdrop element prevents users from clicking or interacting
     * with the page content underneath the Modal, Screen readers also need to be signaled to not to
     * interact with page content while the Modal is open. To do this, we use a common technique of applying
     * the `aria-hidden='true'` attribute to the non-Modal elements in the Modal `container`. This means that for
     * a Modal to be truly modal, it should have a `container` that is _outside_ your app's
     * React hierarchy (such as the default: document.body).
     */
    var Modal = _react2.default.createClass({
      displayName: 'Modal',

      propTypes: _extends({}, _Portal2.default.propTypes, {

        /**
         * Set the visibility of the Modal
         */
        show: _react2.default.PropTypes.bool,

        /**
         * A Node, Component instance, or function that returns either. The Modal is appended to it's container element.
         *
         * For the sake of assistive technologies, the container should usually be the document body, so that the rest of the
         * page content can be placed behind a virtual backdrop as well as a visual one.
         */
        container: _react2.default.PropTypes.oneOfType([_componentOrElement2.default, _react2.default.PropTypes.func]),

        /**
         * A callback fired when the Modal is opening.
         */
        onShow: _react2.default.PropTypes.func,

        /**
         * A callback fired when either the backdrop is clicked, or the escape key is pressed.
         *
         * The `onHide` callback only signals intent from the Modal,
         * you must actually set the `show` prop to `false` for the Modal to close.
         */
        onHide: _react2.default.PropTypes.func,

        /**
         * Include a backdrop component.
         */
        backdrop: _react2.default.PropTypes.oneOfType([_react2.default.PropTypes.bool, _react2.default.PropTypes.oneOf(['static'])]),

        /**
         * A function that returns a backdrop component. Useful for custom
         * backdrop rendering.
         *
         * ```js
         *  renderBackdrop={props => <MyBackdrop {...props} />}
         * ```
         */
        renderBackdrop: _react2.default.PropTypes.func,

        /**
         * A callback fired when the escape key, if specified in `keyboard`, is pressed.
         */
        onEscapeKeyUp: _react2.default.PropTypes.func,

        /**
         * A callback fired when the backdrop, if specified, is clicked.
         */
        onBackdropClick: _react2.default.PropTypes.func,

        /**
         * A style object for the backdrop component.
         */
        backdropStyle: _react2.default.PropTypes.object,

        /**
         * A css class or classes for the backdrop component.
         */
        backdropClassName: _react2.default.PropTypes.string,

        /**
         * A css class or set of classes applied to the modal container when the modal is open,
         * and removed when it is closed.
         */
        containerClassName: _react2.default.PropTypes.string,

        /**
         * Close the modal when escape key is pressed
         */
        keyboard: _react2.default.PropTypes.bool,

        /**
         * A `<Transition/>` component to use for the dialog and backdrop components.
         */
        transition: _elementType2.default,

        /**
         * The `timeout` of the dialog transition if specified. This number is used to ensure that
         * transition callbacks are always fired, even if browser transition events are canceled.
         *
         * See the Transition `timeout` prop for more infomation.
         */
        dialogTransitionTimeout: _react2.default.PropTypes.number,

        /**
         * The `timeout` of the backdrop transition if specified. This number is used to
         * ensure that transition callbacks are always fired, even if browser transition events are canceled.
         *
         * See the Transition `timeout` prop for more infomation.
         */
        backdropTransitionTimeout: _react2.default.PropTypes.number,

        /**
         * When `true` The modal will automatically shift focus to itself when it opens, and
         * replace it to the last focused element when it closes. This also
         * works correctly with any Modal children that have the `autoFocus` prop.
         *
         * Generally this should never be set to `false` as it makes the Modal less
         * accessible to assistive technologies, like screen readers.
         */
        autoFocus: _react2.default.PropTypes.bool,

        /**
         * When `true` The modal will prevent focus from leaving the Modal while open.
         *
         * Generally this should never be set to `false` as it makes the Modal less
         * accessible to assistive technologies, like screen readers.
         */
        enforceFocus: _react2.default.PropTypes.bool,

        /**
         * Callback fired before the Modal transitions in
         */
        onEnter: _react2.default.PropTypes.func,

        /**
         * Callback fired as the Modal begins to transition in
         */
        onEntering: _react2.default.PropTypes.func,

        /**
         * Callback fired after the Modal finishes transitioning in
         */
        onEntered: _react2.default.PropTypes.func,

        /**
         * Callback fired right before the Modal transitions out
         */
        onExit: _react2.default.PropTypes.func,

        /**
         * Callback fired as the Modal begins to transition out
         */
        onExiting: _react2.default.PropTypes.func,

        /**
         * Callback fired after the Modal finishes transitioning out
         */
        onExited: _react2.default.PropTypes.func,

        /**
         * A ModalManager instance used to track and manage the state of open
         * Modals. Useful when customizing how modals interact within a container
         */
        manager: _react2.default.PropTypes.object.isRequired
      }),

      getDefaultProps: function getDefaultProps() {
        var noop = function noop() {};

        return {
          show: false,
          backdrop: true,
          keyboard: true,
          autoFocus: true,
          enforceFocus: true,
          onHide: noop,
          manager: modalManager,
          renderBackdrop: function renderBackdrop(props) {
            return _react2.default.createElement('div', props);
          }
        };
      },
      getInitialState: function getInitialState() {
        return { exited: !this.props.show };
      },
      render: function render() {
        var _props = this.props;
        var show = _props.show;
        var container = _props.container;
        var children = _props.children;
        var Transition = _props.transition;
        var backdrop = _props.backdrop;
        var dialogTransitionTimeout = _props.dialogTransitionTimeout;
        var className = _props.className;
        var style = _props.style;
        var onExit = _props.onExit;
        var onExiting = _props.onExiting;
        var onEnter = _props.onEnter;
        var onEntering = _props.onEntering;
        var onEntered = _props.onEntered;

        var dialog = _react2.default.Children.only(children);

        var mountModal = show || Transition && !this.state.exited;
        if (!mountModal) {
          return null;
        }

        var _dialog$props = dialog.props;
        var role = _dialog$props.role;
        var tabIndex = _dialog$props.tabIndex;

        if (role === undefined || tabIndex === undefined) {
          dialog = (0, _react.cloneElement)(dialog, {
            role: role === undefined ? 'document' : role,
            tabIndex: tabIndex == null ? '-1' : tabIndex
          });
        }

        if (Transition) {
          dialog = _react2.default.createElement(
            Transition,
            {
              transitionAppear: true,
              unmountOnExit: true,
              'in': show,
              timeout: dialogTransitionTimeout,
              onExit: onExit,
              onExiting: onExiting,
              onExited: this.handleHidden,
              onEnter: onEnter,
              onEntering: onEntering,
              onEntered: onEntered
            },
            dialog
          );
        }

        return _react2.default.createElement(
          _Portal2.default,
          {
            ref: this.setMountNode,
            container: container
          },
          _react2.default.createElement(
            'div',
            {
              ref: 'modal',
              role: role || 'dialog',
              style: style,
              className: className
            },
            backdrop && this.renderBackdrop(),
            dialog
          )
        );
      },
      renderBackdrop: function renderBackdrop() {
        var _this = this;

        var _props2 = this.props;
        var backdropStyle = _props2.backdropStyle;
        var backdropClassName = _props2.backdropClassName;
        var renderBackdrop = _props2.renderBackdrop;
        var Transition = _props2.transition;
        var backdropTransitionTimeout = _props2.backdropTransitionTimeout;

        var backdropRef = function backdropRef(ref) {
          return _this.backdrop = ref;
        };

        var backdrop = _react2.default.createElement('div', {
          ref: backdropRef,
          style: this.props.backdropStyle,
          className: this.props.backdropClassName,
          onClick: this.handleBackdropClick
        });

        if (Transition) {
          backdrop = _react2.default.createElement(
            Transition,
            { transitionAppear: true,
              'in': this.props.show,
              timeout: backdropTransitionTimeout
            },
            renderBackdrop({
              ref: backdropRef,
              style: backdropStyle,
              className: backdropClassName,
              onClick: this.handleBackdropClick
            })
          );
        }

        return backdrop;
      },
      componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
        if (nextProps.show) {
          this.setState({ exited: false });
        } else if (!nextProps.transition) {
          // Otherwise let handleHidden take care of marking exited.
          this.setState({ exited: true });
        }
      },
      componentWillUpdate: function componentWillUpdate(nextProps) {
        if (!this.props.show && nextProps.show) {
          this.checkForFocus();
        }
      },
      componentDidMount: function componentDidMount() {
        if (this.props.show) {
          this.onShow();
        }
      },
      componentDidUpdate: function componentDidUpdate(prevProps) {
        var transition = this.props.transition;

        if (prevProps.show && !this.props.show && !transition) {
          // Otherwise handleHidden will call this.
          this.onHide();
        } else if (!prevProps.show && this.props.show) {
          this.onShow();
        }
      },
      componentWillUnmount: function componentWillUnmount() {
        var _props3 = this.props;
        var show = _props3.show;
        var transition = _props3.transition;

        if (show || transition && !this.state.exited) {
          this.onHide();
        }
      },
      onShow: function onShow() {
        var doc = (0, _ownerDocument2.default)(this);
        var container = (0, _getContainer2.default)(this.props.container, doc.body);

        this.props.manager.add(this, container, this.props.containerClassName);

        this._onDocumentKeyupListener = (0, _addEventListener2.default)(doc, 'keyup', this.handleDocumentKeyUp);

        this._onFocusinListener = (0, _addFocusListener2.default)(this.enforceFocus);

        this.focus();

        if (this.props.onShow) {
          this.props.onShow();
        }
      },
      onHide: function onHide() {
        this.props.manager.remove(this);

        this._onDocumentKeyupListener.remove();

        this._onFocusinListener.remove();

        this.restoreLastFocus();
      },
      setMountNode: function setMountNode(ref) {
        this.mountNode = ref ? ref.getMountNode() : ref;
      },
      handleHidden: function handleHidden() {
        this.setState({ exited: true });
        this.onHide();

        if (this.props.onExited) {
          var _props4;

          (_props4 = this.props).onExited.apply(_props4, arguments);
        }
      },
      handleBackdropClick: function handleBackdropClick(e) {
        if (e.target !== e.currentTarget) {
          return;
        }

        if (this.props.onBackdropClick) {
          this.props.onBackdropClick(e);
        }

        if (this.props.backdrop === true) {
          this.props.onHide();
        }
      },
      handleDocumentKeyUp: function handleDocumentKeyUp(e) {
        if (this.props.keyboard && e.keyCode === 27 && this.isTopModal()) {
          if (this.props.onEscapeKeyUp) {
            this.props.onEscapeKeyUp(e);
          }
          this.props.onHide();
        }
      },
      checkForFocus: function checkForFocus() {
        if (_inDOM2.default) {
          this.lastFocus = (0, _activeElement2.default)();
        }
      },
      focus: function focus() {
        var autoFocus = this.props.autoFocus;
        var modalContent = this.getDialogElement();
        var current = (0, _activeElement2.default)((0, _ownerDocument2.default)(this));
        var focusInModal = current && (0, _contains2.default)(modalContent, current);

        if (modalContent && autoFocus && !focusInModal) {
          this.lastFocus = current;

          if (!modalContent.hasAttribute('tabIndex')) {
            modalContent.setAttribute('tabIndex', -1);
            (0, _warning2.default)(false, 'The modal content node does not accept focus. ' + 'For the benefit of assistive technologies, the tabIndex of the node is being set to "-1".');
          }

          modalContent.focus();
        }
      },
      restoreLastFocus: function restoreLastFocus() {
        // Support: <=IE11 doesn't support `focus()` on svg elements (RB: #917)
        if (this.lastFocus && this.lastFocus.focus) {
          this.lastFocus.focus();
          this.lastFocus = null;
        }
      },
      enforceFocus: function enforceFocus() {
        var enforceFocus = this.props.enforceFocus;

        if (!enforceFocus || !this.isMounted() || !this.isTopModal()) {
          return;
        }

        var active = (0, _activeElement2.default)((0, _ownerDocument2.default)(this));
        var modal = this.getDialogElement();

        if (modal && modal !== active && !(0, _contains2.default)(modal, active)) {
          modal.focus();
        }
      },

      //instead of a ref, which might conflict with one the parent applied.
      getDialogElement: function getDialogElement() {
        var node = this.refs.modal;
        return node && node.lastChild;
      },
      isTopModal: function isTopModal() {
        return this.props.manager.isTopModal(this);
      }
    });

    Modal.Manager = _ModalManager2.default;

    exports.default = Modal;
    module.exports = exports['default'];

    },{"./ModalManager":240,"./Portal":242,"./utils/addEventListener":246,"./utils/addFocusListener":247,"./utils/getContainer":249,"./utils/ownerDocument":252,"dom-helpers/activeElement":208,"dom-helpers/query/contains":218,"dom-helpers/util/inDOM":235,"react":618,"react-prop-types/lib/componentOrElement":254,"react-prop-types/lib/elementType":255,"warning":261}],240:[function(require,module,exports){
    '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; }; }();

    var _style = require('dom-helpers/style');

    var _style2 = _interopRequireDefault(_style);

    var _class = require('dom-helpers/class');

    var _class2 = _interopRequireDefault(_class);

    var _scrollbarSize = require('dom-helpers/util/scrollbarSize');

    var _scrollbarSize2 = _interopRequireDefault(_scrollbarSize);

    var _isOverflowing = require('./utils/isOverflowing');

    var _isOverflowing2 = _interopRequireDefault(_isOverflowing);

    var _manageAriaHidden = require('./utils/manageAriaHidden');

    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 findIndexOf(arr, cb) {
      var idx = -1;
      arr.some(function (d, i) {
        if (cb(d, i)) {
          idx = i;
          return true;
        }
      });
      return idx;
    }

    function findContainer(data, modal) {
      return findIndexOf(data, function (d) {
        return d.modals.indexOf(modal) !== -1;
      });
    }

    function setContainerStyle(state, container) {
      var style = { overflow: 'hidden' };

      // we are only interested in the actual `style` here
      // becasue we will override it
      state.style = {
        overflow: container.style.overflow,
        paddingRight: container.style.paddingRight
      };

      if (state.overflowing) {
        // use computed style, here to get the real padding
        // to add our scrollbar width
        style.paddingRight = parseInt((0, _style2.default)(container, 'paddingRight') || 0, 10) + (0, _scrollbarSize2.default)() + 'px';
      }

      (0, _style2.default)(container, style);
    }

    function removeContainerStyle(_ref, container) {
      var style = _ref.style;

      Object.keys(style).forEach(function (key) {
        return container.style[key] = style[key];
      });
    }
    /**
     * Proper state managment for containers and the modals in those containers.
     *
     * @internal Used by the Modal to ensure proper styling of containers.
     */

    var ModalManager = function () {
      function ModalManager() {
        var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        var _ref2$hideSiblingNode = _ref2.hideSiblingNodes;
        var hideSiblingNodes = _ref2$hideSiblingNode === undefined ? true : _ref2$hideSiblingNode;
        var _ref2$handleContainer = _ref2.handleContainerOverflow;
        var handleContainerOverflow = _ref2$handleContainer === undefined ? true : _ref2$handleContainer;

        _classCallCheck(this, ModalManager);

        this.hideSiblingNodes = hideSiblingNodes;
        this.handleContainerOverflow = handleContainerOverflow;
        this.modals = [];
        this.containers = [];
        this.data = [];
      }

      _createClass(ModalManager, [{
        key: 'add',
        value: function add(modal, container, className) {
          var modalIdx = this.modals.indexOf(modal);
          var containerIdx = this.containers.indexOf(container);

          if (modalIdx !== -1) {
            return modalIdx;
          }

          modalIdx = this.modals.length;
          this.modals.push(modal);

          if (this.hideSiblingNodes) {
            (0, _manageAriaHidden.hideSiblings)(container, modal.mountNode);
          }

          if (containerIdx !== -1) {
            this.data[containerIdx].modals.push(modal);
            return modalIdx;
          }

          var data = {
            modals: [modal],
            //right now only the first modal of a container will have its classes applied
            classes: className ? className.split(/\s+/) : [],

            overflowing: (0, _isOverflowing2.default)(container)
          };

          if (this.handleContainerOverflow) {
            setContainerStyle(data, container);
          }

          data.classes.forEach(_class2.default.addClass.bind(null, container));

          this.containers.push(container);
          this.data.push(data);

          return modalIdx;
        }
      }, {
        key: 'remove',
        value: function remove(modal) {
          var modalIdx = this.modals.indexOf(modal);

          if (modalIdx === -1) {
            return;
          }

          var containerIdx = findContainer(this.data, modal);
          var data = this.data[containerIdx];
          var container = this.containers[containerIdx];

          data.modals.splice(data.modals.indexOf(modal), 1);

          this.modals.splice(modalIdx, 1);

          // if that was the last modal in a container,
          // clean up the container
          if (data.modals.length === 0) {
            data.classes.forEach(_class2.default.removeClass.bind(null, container));

            if (this.handleContainerOverflow) {
              removeContainerStyle(data, container);
            }

            if (this.hideSiblingNodes) {
              (0, _manageAriaHidden.showSiblings)(container, modal.mountNode);
            }
            this.containers.splice(containerIdx, 1);
            this.data.splice(containerIdx, 1);
          } else if (this.hideSiblingNodes) {
            //otherwise make sure the next top modal is visible to a SR
            (0, _manageAriaHidden.ariaHidden)(false, data.modals[data.modals.length - 1].mountNode);
          }
        }
      }, {
        key: 'isTopModal',
        value: function isTopModal(modal) {
          return !!this.modals.length && this.modals[this.modals.length - 1] === modal;
        }
      }]);

      return ModalManager;
    }();

    exports.default = ModalManager;
    module.exports = exports['default'];

    },{"./utils/isOverflowing":250,"./utils/manageAriaHidden":251,"dom-helpers/class":211,"dom-helpers/style":227,"dom-helpers/util/scrollbarSize":236}],241:[function(require,module,exports){
    'use strict';

    Object.defineProperty(exports, "__esModule", {
      value: true
    });

    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 = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _Portal = require('./Portal');

    var _Portal2 = _interopRequireDefault(_Portal);

    var _Position = require('./Position');

    var _Position2 = _interopRequireDefault(_Position);

    var _RootCloseWrapper = require('./RootCloseWrapper');

    var _RootCloseWrapper2 = _interopRequireDefault(_RootCloseWrapper);

    var _elementType = require('react-prop-types/lib/elementType');

    var _elementType2 = _interopRequireDefault(_elementType);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }

    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; }

    /**
     * Built on top of `<Position/>` and `<Portal/>`, the overlay component is great for custom tooltip overlays.
     */
    var Overlay = function (_React$Component) {
      _inherits(Overlay, _React$Component);

      function Overlay(props, context) {
        _classCallCheck(this, Overlay);

        var _this = _possibleConstructorReturn(this, (Overlay.__proto__ || Object.getPrototypeOf(Overlay)).call(this, props, context));

        _this.state = { exited: !props.show };
        _this.onHiddenListener = _this.handleHidden.bind(_this);
        return _this;
      }

      _createClass(Overlay, [{
        key: 'componentWillReceiveProps',
        value: function componentWillReceiveProps(nextProps) {
          if (nextProps.show) {
            this.setState({ exited: false });
          } else if (!nextProps.transition) {
            // Otherwise let handleHidden take care of marking exited.
            this.setState({ exited: true });
          }
        }
      }, {
        key: 'render',
        value: function render() {
          var _props = this.props;
          var container = _props.container;
          var containerPadding = _props.containerPadding;
          var target = _props.target;
          var placement = _props.placement;
          var shouldUpdatePosition = _props.shouldUpdatePosition;
          var rootClose = _props.rootClose;
          var children = _props.children;
          var Transition = _props.transition;

          var props = _objectWithoutProperties(_props, ['container', 'containerPadding', 'target', 'placement', 'shouldUpdatePosition', 'rootClose', 'children', 'transition']);

          // Don't un-render the overlay while it's transitioning out.

          var mountOverlay = props.show || Transition && !this.state.exited;
          if (!mountOverlay) {
            // Don't bother showing anything if we don't have to.
            return null;
          }

          var child = children;

          // Position is be inner-most because it adds inline styles into the child,
          // which the other wrappers don't forward correctly.
          child = _react2.default.createElement(
            _Position2.default,
            { container: container, containerPadding: containerPadding, target: target, placement: placement, shouldUpdatePosition: shouldUpdatePosition },
            child
          );

          if (Transition) {
            var onExit = props.onExit;
            var onExiting = props.onExiting;
            var onEnter = props.onEnter;
            var onEntering = props.onEntering;
            var onEntered = props.onEntered;

            // This animates the child node by injecting props, so it must precede
            // anything that adds a wrapping div.

            child = _react2.default.createElement(
              Transition,
              {
                'in': props.show,
                transitionAppear: true,
                onExit: onExit,
                onExiting: onExiting,
                onExited: this.onHiddenListener,
                onEnter: onEnter,
                onEntering: onEntering,
                onEntered: onEntered
              },
              child
            );
          }

          // This goes after everything else because it adds a wrapping div.
          if (rootClose) {
            child = _react2.default.createElement(
              _RootCloseWrapper2.default,
              { onRootClose: props.onHide },
              child
            );
          }

          return _react2.default.createElement(
            _Portal2.default,
            { container: container },
            child
          );
        }
      }, {
        key: 'handleHidden',
        value: function handleHidden() {
          this.setState({ exited: true });

          if (this.props.onExited) {
            var _props2;

            (_props2 = this.props).onExited.apply(_props2, arguments);
          }
        }
      }]);

      return Overlay;
    }(_react2.default.Component);

    Overlay.propTypes = _extends({}, _Portal2.default.propTypes, _Position2.default.propTypes, {

      /**
       * Set the visibility of the Overlay
       */
      show: _react2.default.PropTypes.bool,

      /**
       * Specify whether the overlay should trigger `onHide` when the user clicks outside the overlay
       */
      rootClose: _react2.default.PropTypes.bool,

      /**
       * A Callback fired by the Overlay when it wishes to be hidden.
       *
       * __required__ when `rootClose` is `true`.
       *
       * @type func
       */
      onHide: function onHide(props) {
        var propType = _react2.default.PropTypes.func;
        if (props.rootClose) {
          propType = propType.isRequired;
        }

        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
          args[_key - 1] = arguments[_key];
        }

        return propType.apply(undefined, [props].concat(args));
      },

      /**
       * A `<Transition/>` component used to animate the overlay changes visibility.
       */
      transition: _elementType2.default,

      /**
       * Callback fired before the Overlay transitions in
       */
      onEnter: _react2.default.PropTypes.func,

      /**
       * Callback fired as the Overlay begins to transition in
       */
      onEntering: _react2.default.PropTypes.func,

      /**
       * Callback fired after the Overlay finishes transitioning in
       */
      onEntered: _react2.default.PropTypes.func,

      /**
       * Callback fired right before the Overlay transitions out
       */
      onExit: _react2.default.PropTypes.func,

      /**
       * Callback fired as the Overlay begins to transition out
       */
      onExiting: _react2.default.PropTypes.func,

      /**
       * Callback fired after the Overlay finishes transitioning out
       */
      onExited: _react2.default.PropTypes.func
    });

    exports.default = Overlay;
    module.exports = exports['default'];

    },{"./Portal":242,"./Position":243,"./RootCloseWrapper":244,"react":618,"react-prop-types/lib/elementType":255}],242:[function(require,module,exports){
    'use strict';

    Object.defineProperty(exports, "__esModule", {
      value: true
    });

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _reactDom = require('react-dom');

    var _reactDom2 = _interopRequireDefault(_reactDom);

    var _componentOrElement = require('react-prop-types/lib/componentOrElement');

    var _componentOrElement2 = _interopRequireDefault(_componentOrElement);

    var _ownerDocument = require('./utils/ownerDocument');

    var _ownerDocument2 = _interopRequireDefault(_ownerDocument);

    var _getContainer = require('./utils/getContainer');

    var _getContainer2 = _interopRequireDefault(_getContainer);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    /**
     * The `<Portal/>` component renders its children into a new "subtree" outside of current component hierarchy.
     * You can think of it as a declarative `appendChild()`, or jQuery's `$.fn.appendTo()`.
     * The children of `<Portal/>` component will be appended to the `container` specified.
     */
    var Portal = _react2.default.createClass({

      displayName: 'Portal',

      propTypes: {
        /**
         * A Node, Component instance, or function that returns either. The `container` will have the Portal children
         * appended to it.
         */
        container: _react2.default.PropTypes.oneOfType([_componentOrElement2.default, _react2.default.PropTypes.func])
      },

      componentDidMount: function componentDidMount() {
        this._renderOverlay();
      },
      componentDidUpdate: function componentDidUpdate() {
        this._renderOverlay();
      },
      componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
        if (this._overlayTarget && nextProps.container !== this.props.container) {
          this._portalContainerNode.removeChild(this._overlayTarget);
          this._portalContainerNode = (0, _getContainer2.default)(nextProps.container, (0, _ownerDocument2.default)(this).body);
          this._portalContainerNode.appendChild(this._overlayTarget);
        }
      },
      componentWillUnmount: function componentWillUnmount() {
        this._unrenderOverlay();
        this._unmountOverlayTarget();
      },
      _mountOverlayTarget: function _mountOverlayTarget() {
        if (!this._overlayTarget) {
          this._overlayTarget = document.createElement('div');
          this._portalContainerNode = (0, _getContainer2.default)(this.props.container, (0, _ownerDocument2.default)(this).body);
          this._portalContainerNode.appendChild(this._overlayTarget);
        }
      },
      _unmountOverlayTarget: function _unmountOverlayTarget() {
        if (this._overlayTarget) {
          this._portalContainerNode.removeChild(this._overlayTarget);
          this._overlayTarget = null;
        }
        this._portalContainerNode = null;
      },
      _renderOverlay: function _renderOverlay() {

        var overlay = !this.props.children ? null : _react2.default.Children.only(this.props.children);

        // Save reference for future access.
        if (overlay !== null) {
          this._mountOverlayTarget();
          this._overlayInstance = _reactDom2.default.unstable_renderSubtreeIntoContainer(this, overlay, this._overlayTarget);
        } else {
          // Unrender if the component is null for transitions to null
          this._unrenderOverlay();
          this._unmountOverlayTarget();
        }
      },
      _unrenderOverlay: function _unrenderOverlay() {
        if (this._overlayTarget) {
          _reactDom2.default.unmountComponentAtNode(this._overlayTarget);
          this._overlayInstance = null;
        }
      },
      render: function render() {
        return null;
      },
      getMountNode: function getMountNode() {
        return this._overlayTarget;
      },
      getOverlayDOMNode: function getOverlayDOMNode() {
        if (!this.isMounted()) {
          throw new Error('getOverlayDOMNode(): A component must be mounted to have a DOM node.');
        }

        if (this._overlayInstance) {
          return _reactDom2.default.findDOMNode(this._overlayInstance);
        }

        return null;
      }
    });

    exports.default = Portal;
    module.exports = exports['default'];

    },{"./utils/getContainer":249,"./utils/ownerDocument":252,"react":618,"react-dom":262,"react-prop-types/lib/componentOrElement":254}],243:[function(require,module,exports){
    'use strict';

    Object.defineProperty(exports, "__esModule", {
      value: true
    });

    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 _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _reactDom = require('react-dom');

    var _reactDom2 = _interopRequireDefault(_reactDom);

    var _componentOrElement = require('react-prop-types/lib/componentOrElement');

    var _componentOrElement2 = _interopRequireDefault(_componentOrElement);

    var _calculatePosition = require('./utils/calculatePosition');

    var _calculatePosition2 = _interopRequireDefault(_calculatePosition);

    var _getContainer = require('./utils/getContainer');

    var _getContainer2 = _interopRequireDefault(_getContainer);

    var _ownerDocument = require('./utils/ownerDocument');

    var _ownerDocument2 = _interopRequireDefault(_ownerDocument);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }

    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; }

    /**
     * The Position component calculates the coordinates for its child, to position
     * it relative to a `target` component or node. Useful for creating callouts
     * and tooltips, the Position component injects a `style` props with `left` and
     * `top` values for positioning your component.
     *
     * It also injects "arrow" `left`, and `top` values for styling callout arrows
     * for giving your components a sense of directionality.
     */
    var Position = function (_React$Component) {
      _inherits(Position, _React$Component);

      function Position(props, context) {
        _classCallCheck(this, Position);

        var _this = _possibleConstructorReturn(this, (Position.__proto__ || Object.getPrototypeOf(Position)).call(this, props, context));

        _this.state = {
          positionLeft: 0,
          positionTop: 0,
          arrowOffsetLeft: null,
          arrowOffsetTop: null
        };

        _this._needsFlush = false;
        _this._lastTarget = null;
        return _this;
      }

      _createClass(Position, [{
        key: 'componentDidMount',
        value: function componentDidMount() {
          this.updatePosition(this.getTarget());
        }
      }, {
        key: 'componentWillReceiveProps',
        value: function componentWillReceiveProps() {
          this._needsFlush = true;
        }
      }, {
        key: 'componentDidUpdate',
        value: function componentDidUpdate(prevProps) {
          if (this._needsFlush) {
            this._needsFlush = false;
            this.maybeUpdatePosition(this.props.placement !== prevProps.placement);
          }
        }
      }, {
        key: 'render',
        value: function render() {
          var _props = this.props;
          var children = _props.children;
          var className = _props.className;

          var props = _objectWithoutProperties(_props, ['children', 'className']);

          var _state = this.state;
          var positionLeft = _state.positionLeft;
          var positionTop = _state.positionTop;

          var arrowPosition = _objectWithoutProperties(_state, ['positionLeft', 'positionTop']);

          // These should not be forwarded to the child.

          delete props.target;
          delete props.container;
          delete props.containerPadding;
          delete props.shouldUpdatePosition;

          var child = _react2.default.Children.only(children);
          return (0, _react.cloneElement)(child, _extends({}, props, arrowPosition, {
            // FIXME: Don't forward `positionLeft` and `positionTop` via both props
            // and `props.style`.
            positionLeft: positionLeft,
            positionTop: positionTop,
            className: (0, _classnames2.default)(className, child.props.className),
            style: _extends({}, child.props.style, {
              left: positionLeft,
              top: positionTop
            })
          }));
        }
      }, {
        key: 'getTarget',
        value: function getTarget() {
          var target = this.props.target;

          var targetElement = typeof target === 'function' ? target() : target;
          return targetElement && _reactDom2.default.findDOMNode(targetElement) || null;
        }
      }, {
        key: 'maybeUpdatePosition',
        value: function maybeUpdatePosition(placementChanged) {
          var target = this.getTarget();

          if (!this.props.shouldUpdatePosition && target === this._lastTarget && !placementChanged) {
            return;
          }

          this.updatePosition(target);
        }
      }, {
        key: 'updatePosition',
        value: function updatePosition(target) {
          this._lastTarget = target;

          if (!target) {
            this.setState({
              positionLeft: 0,
              positionTop: 0,
              arrowOffsetLeft: null,
              arrowOffsetTop: null
            });

            return;
          }

          var overlay = _reactDom2.default.findDOMNode(this);
          var container = (0, _getContainer2.default)(this.props.container, (0, _ownerDocument2.default)(this).body);

          this.setState((0, _calculatePosition2.default)(this.props.placement, overlay, target, container, this.props.containerPadding));
        }
      }]);

      return Position;
    }(_react2.default.Component);

    Position.propTypes = {
      /**
       * A node, element, or function that returns either. The child will be
       * be positioned next to the `target` specified.
       */
      target: _react2.default.PropTypes.oneOfType([_componentOrElement2.default, _react2.default.PropTypes.func]),

      /**
       * "offsetParent" of the component
       */
      container: _react2.default.PropTypes.oneOfType([_componentOrElement2.default, _react2.default.PropTypes.func]),
      /**
       * Minimum spacing in pixels between container border and component border
       */
      containerPadding: _react2.default.PropTypes.number,
      /**
       * How to position the component relative to the target
       */
      placement: _react2.default.PropTypes.oneOf(['top', 'right', 'bottom', 'left']),
      /**
       * Whether the position should be changed on each update
       */
      shouldUpdatePosition: _react2.default.PropTypes.bool
    };

    Position.displayName = 'Position';

    Position.defaultProps = {
      containerPadding: 0,
      placement: 'right',
      shouldUpdatePosition: false
    };

    exports.default = Position;
    module.exports = exports['default'];

    },{"./utils/calculatePosition":248,"./utils/getContainer":249,"./utils/ownerDocument":252,"classnames":207,"react":618,"react-dom":262,"react-prop-types/lib/componentOrElement":254}],244:[function(require,module,exports){
    '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; }; }();

    var _contains = require('dom-helpers/query/contains');

    var _contains2 = _interopRequireDefault(_contains);

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _reactDom = require('react-dom');

    var _reactDom2 = _interopRequireDefault(_reactDom);

    var _addEventListener = require('./utils/addEventListener');

    var _addEventListener2 = _interopRequireDefault(_addEventListener);

    var _ownerDocument = require('./utils/ownerDocument');

    var _ownerDocument2 = _interopRequireDefault(_ownerDocument);

    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; }

    function isLeftClickEvent(event) {
      return event.button === 0;
    }

    function isModifiedEvent(event) {
      return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);
    }

    var RootCloseWrapper = function (_React$Component) {
      _inherits(RootCloseWrapper, _React$Component);

      function RootCloseWrapper(props, context) {
        _classCallCheck(this, RootCloseWrapper);

        var _this = _possibleConstructorReturn(this, (RootCloseWrapper.__proto__ || Object.getPrototypeOf(RootCloseWrapper)).call(this, props, context));

        _this.handleMouseCapture = function (e) {
          _this.preventMouseRootClose = isModifiedEvent(e) || !isLeftClickEvent(e) || (0, _contains2.default)(_reactDom2.default.findDOMNode(_this), e.target);
        };

        _this.handleMouse = function () {
          if (!_this.preventMouseRootClose && _this.props.onRootClose) {
            _this.props.onRootClose();
          }
        };

        _this.handleKeyUp = function (e) {
          if (e.keyCode === 27 && _this.props.onRootClose) {
            _this.props.onRootClose();
          }
        };

        _this.preventMouseRootClose = false;
        return _this;
      }

      _createClass(RootCloseWrapper, [{
        key: 'componentDidMount',
        value: function componentDidMount() {
          if (!this.props.disabled) {
            this.addEventListeners();
          }
        }
      }, {
        key: 'componentDidUpdate',
        value: function componentDidUpdate(prevProps) {
          if (!this.props.disabled && prevProps.disabled) {
            this.addEventListeners();
          } else if (this.props.disabled && !prevProps.disabled) {
            this.removeEventListeners();
          }
        }
      }, {
        key: 'componentWillUnmount',
        value: function componentWillUnmount() {
          if (!this.props.disabled) {
            this.removeEventListeners();
          }
        }
      }, {
        key: 'addEventListeners',
        value: function addEventListeners() {
          var event = this.props.event;

          var doc = (0, _ownerDocument2.default)(this);

          // Use capture for this listener so it fires before React's listener, to
          // avoid false positives in the contains() check below if the target DOM
          // element is removed in the React mouse callback.
          this.documentMouseCaptureListener = (0, _addEventListener2.default)(doc, event, this.handleMouseCapture, true);

          this.documentMouseListener = (0, _addEventListener2.default)(doc, event, this.handleMouse);

          this.documentKeyupListener = (0, _addEventListener2.default)(doc, 'keyup', this.handleKeyUp);
        }
      }, {
        key: 'removeEventListeners',
        value: function removeEventListeners() {
          if (this.documentMouseCaptureListener) {
            this.documentMouseCaptureListener.remove();
          }

          if (this.documentMouseListener) {
            this.documentMouseListener.remove();
          }

          if (this.documentKeyupListener) {
            this.documentKeyupListener.remove();
          }
        }
      }, {
        key: 'render',
        value: function render() {
          return this.props.children;
        }
      }]);

      return RootCloseWrapper;
    }(_react2.default.Component);

    exports.default = RootCloseWrapper;

    RootCloseWrapper.displayName = 'RootCloseWrapper';

    RootCloseWrapper.propTypes = {
      onRootClose: _react2.default.PropTypes.func,
      children: _react2.default.PropTypes.element,

      /**
       * Disable the the RootCloseWrapper, preventing it from triggering
       * `onRootClose`.
       */
      disabled: _react2.default.PropTypes.bool,
      /**
       * Choose which document mouse event to bind to
       */
      event: _react2.default.PropTypes.oneOf(['click', 'mousedown'])
    };

    RootCloseWrapper.defaultProps = {
      event: 'click'
    };
    module.exports = exports['default'];

    },{"./utils/addEventListener":246,"./utils/ownerDocument":252,"dom-helpers/query/contains":218,"react":618,"react-dom":262}],245:[function(require,module,exports){
    'use strict';

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.EXITING = exports.ENTERED = exports.ENTERING = exports.EXITED = exports.UNMOUNTED = 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; };

    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 = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _reactDom = require('react-dom');

    var _reactDom2 = _interopRequireDefault(_reactDom);

    var _properties = require('dom-helpers/transition/properties');

    var _properties2 = _interopRequireDefault(_properties);

    var _on = require('dom-helpers/events/on');

    var _on2 = _interopRequireDefault(_on);

    var _classnames = require('classnames');

    var _classnames2 = _interopRequireDefault(_classnames);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }

    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; }

    var transitionEndEvent = _properties2.default.end;

    var UNMOUNTED = exports.UNMOUNTED = 0;
    var EXITED = exports.EXITED = 1;
    var ENTERING = exports.ENTERING = 2;
    var ENTERED = exports.ENTERED = 3;
    var EXITING = exports.EXITING = 4;

    /**
     * The Transition component lets you define and run css transitions with a simple declarative api.
     * It works similar to React's own [CSSTransitionGroup](http://facebook.github.io/react/docs/animation.html#high-level-api-reactcsstransitiongroup)
     * but is specifically optimized for transitioning a single child "in" or "out".
     *
     * You don't even need to use class based css transitions if you don't want to (but it is easiest).
     * The extensive set of lifecyle callbacks means you have control over
     * the transitioning now at each step of the way.
     */

    var Transition = function (_React$Component) {
      _inherits(Transition, _React$Component);

      function Transition(props, context) {
        _classCallCheck(this, Transition);

        var _this = _possibleConstructorReturn(this, (Transition.__proto__ || Object.getPrototypeOf(Transition)).call(this, props, context));

        var initialStatus = void 0;
        if (props.in) {
          // Start enter transition in componentDidMount.
          initialStatus = props.transitionAppear ? EXITED : ENTERED;
        } else {
          initialStatus = props.unmountOnExit ? UNMOUNTED : EXITED;
        }
        _this.state = { status: initialStatus };

        _this.nextCallback = null;
        return _this;
      }

      _createClass(Transition, [{
        key: 'componentDidMount',
        value: function componentDidMount() {
          if (this.props.transitionAppear && this.props.in) {
            this.performEnter(this.props);
          }
        }
      }, {
        key: 'componentWillReceiveProps',
        value: function componentWillReceiveProps(nextProps) {
          if (nextProps.in && this.props.unmountOnExit) {
            if (this.state.status === UNMOUNTED) {
              // Start enter transition in componentDidUpdate.
              this.setState({ status: EXITED });
            }
          } else {
            this._needsUpdate = true;
          }
        }
      }, {
        key: 'componentDidUpdate',
        value: function componentDidUpdate() {
          var status = this.state.status;

          if (this.props.unmountOnExit && status === EXITED) {
            // EXITED is always a transitional state to either ENTERING or UNMOUNTED
            // when using unmountOnExit.
            if (this.props.in) {
              this.performEnter(this.props);
            } else {
              this.setState({ status: UNMOUNTED });
            }

            return;
          }

          // guard ensures we are only responding to prop changes
          if (this._needsUpdate) {
            this._needsUpdate = false;

            if (this.props.in) {
              if (status === EXITING) {
                this.performEnter(this.props);
              } else if (status === EXITED) {
                this.performEnter(this.props);
              }
              // Otherwise we're already entering or entered.
            } else {
              if (status === ENTERING || status === ENTERED) {
                this.performExit(this.props);
              }
              // Otherwise we're already exited or exiting.
            }
          }
        }
      }, {
        key: 'componentWillUnmount',
        value: function componentWillUnmount() {
          this.cancelNextCallback();
        }
      }, {
        key: 'performEnter',
        value: function performEnter(props) {
          var _this2 = this;

          this.cancelNextCallback();
          var node = _reactDom2.default.findDOMNode(this);

          // Not this.props, because we might be about to receive new props.
          props.onEnter(node);

          this.safeSetState({ status: ENTERING }, function () {
            _this2.props.onEntering(node);

            _this2.onTransitionEnd(node, function () {
              _this2.safeSetState({ status: ENTERED }, function () {
                _this2.props.onEntered(node);
              });
            });
          });
        }
      }, {
        key: 'performExit',
        value: function performExit(props) {
          var _this3 = this;

          this.cancelNextCallback();
          var node = _reactDom2.default.findDOMNode(this);

          // Not this.props, because we might be about to receive new props.
          props.onExit(node);

          this.safeSetState({ status: EXITING }, function () {
            _this3.props.onExiting(node);

            _this3.onTransitionEnd(node, function () {
              _this3.safeSetState({ status: EXITED }, function () {
                _this3.props.onExited(node);
              });
            });
          });
        }
      }, {
        key: 'cancelNextCallback',
        value: function cancelNextCallback() {
          if (this.nextCallback !== null) {
            this.nextCallback.cancel();
            this.nextCallback = null;
          }
        }
      }, {
        key: 'safeSetState',
        value: function safeSetState(nextState, callback) {
          // This shouldn't be necessary, but there are weird race conditions with
          // setState callbacks and unmounting in testing, so always make sure that
          // we can cancel any pending setState callbacks after we unmount.
          this.setState(nextState, this.setNextCallback(callback));
        }
      }, {
        key: 'setNextCallback',
        value: function setNextCallback(callback) {
          var _this4 = this;

          var active = true;

          this.nextCallback = function (event) {
            if (active) {
              active = false;
              _this4.nextCallback = null;

              callback(event);
            }
          };

          this.nextCallback.cancel = function () {
            active = false;
          };

          return this.nextCallback;
        }
      }, {
        key: 'onTransitionEnd',
        value: function onTransitionEnd(node, handler) {
          this.setNextCallback(handler);

          if (node) {
            (0, _on2.default)(node, transitionEndEvent, this.nextCallback);
            setTimeout(this.nextCallback, this.props.timeout);
          } else {
            setTimeout(this.nextCallback, 0);
          }
        }
      }, {
        key: 'render',
        value: function render() {
          var status = this.state.status;
          if (status === UNMOUNTED) {
            return null;
          }

          var _props = this.props;
          var children = _props.children;
          var className = _props.className;

          var childProps = _objectWithoutProperties(_props, ['children', 'className']);

          Object.keys(Transition.propTypes).forEach(function (key) {
            return delete childProps[key];
          });

          var transitionClassName = void 0;
          if (status === EXITED) {
            transitionClassName = this.props.exitedClassName;
          } else if (status === ENTERING) {
            transitionClassName = this.props.enteringClassName;
          } else if (status === ENTERED) {
            transitionClassName = this.props.enteredClassName;
          } else if (status === EXITING) {
            transitionClassName = this.props.exitingClassName;
          }

          var child = _react2.default.Children.only(children);
          return _react2.default.cloneElement(child, _extends({}, childProps, {
            className: (0, _classnames2.default)(child.props.className, className, transitionClassName)
          }));
        }
      }]);

      return Transition;
    }(_react2.default.Component);

    Transition.propTypes = {
      /**
       * Show the component; triggers the enter or exit animation
       */
      in: _react2.default.PropTypes.bool,

      /**
       * Unmount the component (remove it from the DOM) when it is not shown
       */
      unmountOnExit: _react2.default.PropTypes.bool,

      /**
       * Run the enter animation when the component mounts, if it is initially
       * shown
       */
      transitionAppear: _react2.default.PropTypes.bool,

      /**
       * A Timeout for the animation, in milliseconds, to ensure that a node doesn't
       * transition indefinately if the browser transitionEnd events are
       * canceled or interrupted.
       *
       * By default this is set to a high number (5 seconds) as a failsafe. You should consider
       * setting this to the duration of your animation (or a bit above it).
       */
      timeout: _react2.default.PropTypes.number,

      /**
       * CSS class or classes applied when the component is exited
       */
      exitedClassName: _react2.default.PropTypes.string,
      /**
       * CSS class or classes applied while the component is exiting
       */
      exitingClassName: _react2.default.PropTypes.string,
      /**
       * CSS class or classes applied when the component is entered
       */
      enteredClassName: _react2.default.PropTypes.string,
      /**
       * CSS class or classes applied while the component is entering
       */
      enteringClassName: _react2.default.PropTypes.string,

      /**
       * Callback fired before the "entering" classes are applied
       */
      onEnter: _react2.default.PropTypes.func,
      /**
       * Callback fired after the "entering" classes are applied
       */
      onEntering: _react2.default.PropTypes.func,
      /**
       * Callback fired after the "enter" classes are applied
       */
      onEntered: _react2.default.PropTypes.func,
      /**
       * Callback fired before the "exiting" classes are applied
       */
      onExit: _react2.default.PropTypes.func,
      /**
       * Callback fired after the "exiting" classes are applied
       */
      onExiting: _react2.default.PropTypes.func,
      /**
       * Callback fired after the "exited" classes are applied
       */
      onExited: _react2.default.PropTypes.func
    };

    // Name the function so it is clearer in the documentation
    function noop() {}

    Transition.displayName = 'Transition';

    Transition.defaultProps = {
      in: false,
      unmountOnExit: false,
      transitionAppear: false,

      timeout: 5000,

      onEnter: noop,
      onEntering: noop,
      onEntered: noop,

      onExit: noop,
      onExiting: noop,
      onExited: noop
    };

    exports.default = Transition;

    },{"classnames":207,"dom-helpers/events/on":216,"dom-helpers/transition/properties":229,"react":618,"react-dom":262}],246:[function(require,module,exports){
    'use strict';

    Object.defineProperty(exports, "__esModule", {
      value: true
    });

    exports.default = function (node, event, handler, capture) {
      (0, _on2.default)(node, event, handler, capture);

      return {
        remove: function remove() {
          (0, _off2.default)(node, event, handler, capture);
        }
      };
    };

    var _on = require('dom-helpers/events/on');

    var _on2 = _interopRequireDefault(_on);

    var _off = require('dom-helpers/events/off');

    var _off2 = _interopRequireDefault(_off);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    module.exports = exports['default'];

    },{"dom-helpers/events/off":215,"dom-helpers/events/on":216}],247:[function(require,module,exports){
    'use strict';

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = addFocusListener;
    /**
     * Firefox doesn't have a focusin event so using capture is easiest way to get bubbling
     * IE8 can't do addEventListener, but does have onfocusin, so we use that in ie8
     *
     * We only allow one Listener at a time to avoid stack overflows
     */
    function addFocusListener(handler) {
      var useFocusin = !document.addEventListener;
      var remove = void 0;

      if (useFocusin) {
        document.attachEvent('onfocusin', handler);
        remove = function remove() {
          return document.detachEvent('onfocusin', handler);
        };
      } else {
        document.addEventListener('focus', handler, true);
        remove = function remove() {
          return document.removeEventListener('focus', handler, true);
        };
      }

      return { remove: remove };
    }
    module.exports = exports['default'];

    },{}],248:[function(require,module,exports){
    'use strict';

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = calculatePosition;

    var _offset = require('dom-helpers/query/offset');

    var _offset2 = _interopRequireDefault(_offset);

    var _position = require('dom-helpers/query/position');

    var _position2 = _interopRequireDefault(_position);

    var _scrollTop = require('dom-helpers/query/scrollTop');

    var _scrollTop2 = _interopRequireDefault(_scrollTop);

    var _ownerDocument = require('./ownerDocument');

    var _ownerDocument2 = _interopRequireDefault(_ownerDocument);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    function getContainerDimensions(containerNode) {
      var width = void 0,
          height = void 0,
          scroll = void 0;

      if (containerNode.tagName === 'BODY') {
        width = window.innerWidth;
        height = window.innerHeight;

        scroll = (0, _scrollTop2.default)((0, _ownerDocument2.default)(containerNode).documentElement) || (0, _scrollTop2.default)(containerNode);
      } else {
        var _getOffset = (0, _offset2.default)(containerNode);

        width = _getOffset.width;
        height = _getOffset.height;

        scroll = (0, _scrollTop2.default)(containerNode);
      }

      return { width: width, height: height, scroll: scroll };
    }

    function getTopDelta(top, overlayHeight, container, padding) {
      var containerDimensions = getContainerDimensions(container);
      var containerScroll = containerDimensions.scroll;
      var containerHeight = containerDimensions.height;

      var topEdgeOffset = top - padding - containerScroll;
      var bottomEdgeOffset = top + padding - containerScroll + overlayHeight;

      if (topEdgeOffset < 0) {
        return -topEdgeOffset;
      } else if (bottomEdgeOffset > containerHeight) {
        return containerHeight - bottomEdgeOffset;
      } else {
        return 0;
      }
    }

    function getLeftDelta(left, overlayWidth, container, padding) {
      var containerDimensions = getContainerDimensions(container);
      var containerWidth = containerDimensions.width;

      var leftEdgeOffset = left - padding;
      var rightEdgeOffset = left + padding + overlayWidth;

      if (leftEdgeOffset < 0) {
        return -leftEdgeOffset;
      } else if (rightEdgeOffset > containerWidth) {
        return containerWidth - rightEdgeOffset;
      }

      return 0;
    }

    function calculatePosition(placement, overlayNode, target, container, padding) {
      var childOffset = container.tagName === 'BODY' ? (0, _offset2.default)(target) : (0, _position2.default)(target, container);

      var _getOffset2 = (0, _offset2.default)(overlayNode);

      var overlayHeight = _getOffset2.height;
      var overlayWidth = _getOffset2.width;

      var positionLeft = void 0,
          positionTop = void 0,
          arrowOffsetLeft = void 0,
          arrowOffsetTop = void 0;

      if (placement === 'left' || placement === 'right') {
        positionTop = childOffset.top + (childOffset.height - overlayHeight) / 2;

        if (placement === 'left') {
          positionLeft = childOffset.left - overlayWidth;
        } else {
          positionLeft = childOffset.left + childOffset.width;
        }

        var topDelta = getTopDelta(positionTop, overlayHeight, container, padding);

        positionTop += topDelta;
        arrowOffsetTop = 50 * (1 - 2 * topDelta / overlayHeight) + '%';
        arrowOffsetLeft = void 0;
      } else if (placement === 'top' || placement === 'bottom') {
        positionLeft = childOffset.left + (childOffset.width - overlayWidth) / 2;

        if (placement === 'top') {
          positionTop = childOffset.top - overlayHeight;
        } else {
          positionTop = childOffset.top + childOffset.height;
        }

        var leftDelta = getLeftDelta(positionLeft, overlayWidth, container, padding);

        positionLeft += leftDelta;
        arrowOffsetLeft = 50 * (1 - 2 * leftDelta / overlayWidth) + '%';
        arrowOffsetTop = void 0;
      } else {
        throw new Error('calcOverlayPosition(): No such placement of "' + placement + '" found.');
      }

      return { positionLeft: positionLeft, positionTop: positionTop, arrowOffsetLeft: arrowOffsetLeft, arrowOffsetTop: arrowOffsetTop };
    }
    module.exports = exports['default'];

    },{"./ownerDocument":252,"dom-helpers/query/offset":220,"dom-helpers/query/position":222,"dom-helpers/query/scrollTop":225}],249:[function(require,module,exports){
    'use strict';

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = getContainer;

    var _reactDom = require('react-dom');

    var _reactDom2 = _interopRequireDefault(_reactDom);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    function getContainer(container, defaultContainer) {
      container = typeof container === 'function' ? container() : container;
      return _reactDom2.default.findDOMNode(container) || defaultContainer;
    }
    module.exports = exports['default'];

    },{"react-dom":262}],250:[function(require,module,exports){
    'use strict';

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.default = isOverflowing;

    var _isWindow = require('dom-helpers/query/isWindow');

    var _isWindow2 = _interopRequireDefault(_isWindow);

    var _ownerDocument = require('dom-helpers/ownerDocument');

    var _ownerDocument2 = _interopRequireDefault(_ownerDocument);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    function isBody(node) {
      return node && node.tagName.toLowerCase() === 'body';
    }

    function bodyIsOverflowing(node) {
      var doc = (0, _ownerDocument2.default)(node);
      var win = (0, _isWindow2.default)(doc);
      var fullWidth = win.innerWidth;

      // Support: ie8, no innerWidth
      if (!fullWidth) {
        var documentElementRect = doc.documentElement.getBoundingClientRect();
        fullWidth = documentElementRect.right - Math.abs(documentElementRect.left);
      }

      return doc.body.clientWidth < fullWidth;
    }

    function isOverflowing(container) {
      var win = (0, _isWindow2.default)(container);

      return win || isBody(container) ? bodyIsOverflowing(container) : container.scrollHeight > container.clientHeight;
    }
    module.exports = exports['default'];

    },{"dom-helpers/ownerDocument":217,"dom-helpers/query/isWindow":219}],251:[function(require,module,exports){
    'use strict';

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.ariaHidden = ariaHidden;
    exports.hideSiblings = hideSiblings;
    exports.showSiblings = showSiblings;

    var BLACKLIST = ['template', 'script', 'style'];

    var isHidable = function isHidable(_ref) {
      var nodeType = _ref.nodeType;
      var tagName = _ref.tagName;
      return nodeType === 1 && BLACKLIST.indexOf(tagName.toLowerCase()) === -1;
    };

    var siblings = function siblings(container, mount, cb) {
      mount = [].concat(mount);

      [].forEach.call(container.children, function (node) {
        if (mount.indexOf(node) === -1 && isHidable(node)) {
          cb(node);
        }
      });
    };

    function ariaHidden(show, node) {
      if (!node) {
        return;
      }
      if (show) {
        node.setAttribute('aria-hidden', 'true');
      } else {
        node.removeAttribute('aria-hidden');
      }
    }

    function hideSiblings(container, mountNode) {
      siblings(container, mountNode, function (node) {
        return ariaHidden(true, node);
      });
    }

    function showSiblings(container, mountNode) {
      siblings(container, mountNode, function (node) {
        return ariaHidden(false, node);
      });
    }

    },{}],252:[function(require,module,exports){
    'use strict';

    Object.defineProperty(exports, "__esModule", {
      value: true
    });

    exports.default = function (componentOrElement) {
      return (0, _ownerDocument2.default)(_reactDom2.default.findDOMNode(componentOrElement));
    };

    var _reactDom = require('react-dom');

    var _reactDom2 = _interopRequireDefault(_reactDom);

    var _ownerDocument = require('dom-helpers/ownerDocument');

    var _ownerDocument2 = _interopRequireDefault(_ownerDocument);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    module.exports = exports['default'];

    },{"dom-helpers/ownerDocument":217,"react-dom":262}],253:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;
    exports.default = all;

    var _createChainableTypeChecker = require('./utils/createChainableTypeChecker');

    var _createChainableTypeChecker2 = _interopRequireDefault(_createChainableTypeChecker);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    function all() {
      for (var _len = arguments.length, validators = Array(_len), _key = 0; _key < _len; _key++) {
        validators[_key] = arguments[_key];
      }

      function allPropTypes() {
        for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
          args[_key2] = arguments[_key2];
        }

        var error = null;

        validators.forEach(function (validator) {
          if (error != null) {
            return;
          }

          var result = validator.apply(undefined, args);
          if (result != null) {
            error = result;
          }
        });

        return error;
      }

      return (0, _createChainableTypeChecker2.default)(allPropTypes);
    }

    },{"./utils/createChainableTypeChecker":257}],254:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _createChainableTypeChecker = require('./utils/createChainableTypeChecker');

    var _createChainableTypeChecker2 = _interopRequireDefault(_createChainableTypeChecker);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    function validate(props, propName, componentName, location, propFullName) {
      var propValue = props[propName];
      var propType = typeof propValue === 'undefined' ? 'undefined' : _typeof(propValue);

      if (_react2.default.isValidElement(propValue)) {
        return new Error('Invalid ' + location + ' `' + propFullName + '` of type ReactElement ' + ('supplied to `' + componentName + '`, expected a ReactComponent or a ') + 'DOMElement. You can usually obtain a ReactComponent or DOMElement ' + 'from a ReactElement by attaching a ref to it.');
      }

      if ((propType !== 'object' || typeof propValue.render !== 'function') && propValue.nodeType !== 1) {
        return new Error('Invalid ' + location + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected a ReactComponent or a ') + 'DOMElement.');
      }

      return null;
    }

    exports.default = (0, _createChainableTypeChecker2.default)(validate);

    },{"./utils/createChainableTypeChecker":257,"react":618}],255:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _createChainableTypeChecker = require('./utils/createChainableTypeChecker');

    var _createChainableTypeChecker2 = _interopRequireDefault(_createChainableTypeChecker);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    function elementType(props, propName, componentName, location, propFullName) {
      var propValue = props[propName];
      var propType = typeof propValue === 'undefined' ? 'undefined' : _typeof(propValue);

      if (_react2.default.isValidElement(propValue)) {
        return new Error('Invalid ' + location + ' `' + propFullName + '` of type ReactElement ' + ('supplied to `' + componentName + '`, expected an element type (a string ') + 'or a ReactClass).');
      }

      if (propType !== 'function' && propType !== 'string') {
        return new Error('Invalid ' + location + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected an element type (a string ') + 'or a ReactClass).');
      }

      return null;
    }

    exports.default = (0, _createChainableTypeChecker2.default)(elementType);

    },{"./utils/createChainableTypeChecker":257,"react":618}],256:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;
    exports.default = isRequiredForA11y;
    function isRequiredForA11y(validator) {
      return function validate(props, propName, componentName, location, propFullName) {
        var componentNameSafe = componentName || '<<anonymous>>';
        var propFullNameSafe = propFullName || propName;

        if (props[propName] == null) {
          return new Error('The ' + location + ' `' + propFullNameSafe + '` is required to make ' + ('`' + componentNameSafe + '` accessible for users of assistive ') + 'technologies such as screen readers.');
        }

        for (var _len = arguments.length, args = Array(_len > 5 ? _len - 5 : 0), _key = 5; _key < _len; _key++) {
          args[_key - 5] = arguments[_key];
        }

        return validator.apply(undefined, [props, propName, componentName, location, propFullName].concat(args));
      };
    }

    },{}],257:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;
    exports.default = createChainableTypeChecker;
    /**
     * 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.
     */

    // Mostly taken from ReactPropTypes.

    function createChainableTypeChecker(validate) {
      function checkType(isRequired, props, propName, componentName, location, propFullName) {
        var componentNameSafe = componentName || '<<anonymous>>';
        var propFullNameSafe = propFullName || propName;

        if (props[propName] == null) {
          if (isRequired) {
            return new Error('Required ' + location + ' `' + propFullNameSafe + '` was not specified ' + ('in `' + componentNameSafe + '`.'));
          }

          return null;
        }

        for (var _len = arguments.length, args = Array(_len > 6 ? _len - 6 : 0), _key = 6; _key < _len; _key++) {
          args[_key - 6] = arguments[_key];
        }

        return validate.apply(undefined, [props, propName, componentNameSafe, location, propFullNameSafe].concat(args));
      }

      var chainedCheckType = checkType.bind(null, false);
      chainedCheckType.isRequired = checkType.bind(null, true);

      return chainedCheckType;
    }

    },{}],258:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    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.default = createUncontrollable;

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _invariant = require('invariant');

    var _invariant2 = _interopRequireDefault(_invariant);

    var _utils = require('./utils');

    var utils = _interopRequireWildcard(_utils);

    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 createUncontrollable(mixins, set) {

      return uncontrollable;

      function uncontrollable(Component, controlledValues) {
        var methods = arguments.length <= 2 || arguments[2] === undefined ? [] : arguments[2];

        var displayName = Component.displayName || Component.name || 'Component',
            basePropTypes = utils.getType(Component).propTypes,
            isCompositeComponent = utils.isReactComponent(Component),
            controlledProps = Object.keys(controlledValues),
            propTypes;

        var OMIT_PROPS = ['valueLink', 'checkedLink'].concat(controlledProps.map(utils.defaultKey));

        propTypes = utils.uncontrolledPropTypes(controlledValues, basePropTypes, displayName);

        (0, _invariant2.default)(isCompositeComponent || !methods.length, '[uncontrollable] stateless function components cannot pass through methods ' + 'because they have no associated instances. Check component: ' + displayName + ', ' + 'attempting to pass through methods: ' + methods.join(', '));

        methods = utils.transform(methods, function (obj, method) {
          obj[method] = function () {
            var _refs$inner;

            return (_refs$inner = this.refs.inner)[method].apply(_refs$inner, arguments);
          };
        }, {});

        var component = _react2.default.createClass(_extends({

          displayName: 'Uncontrolled(' + displayName + ')',

          mixins: mixins,

          propTypes: propTypes

        }, methods, {
          componentWillMount: function componentWillMount() {
            var _this = this;

            var props = this.props;

            this._values = {};

            controlledProps.forEach(function (key) {
              _this._values[key] = props[utils.defaultKey(key)];
            });
          },

          /**
           * If a prop switches from controlled to Uncontrolled
           * reset its value to the defaultValue
           */
          componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
            var _this2 = this;

            var props = this.props;

            controlledProps.forEach(function (key) {
              if (utils.getValue(nextProps, key) === undefined && utils.getValue(props, key) !== undefined) {
                _this2._values[key] = nextProps[utils.defaultKey(key)];
              }
            });
          },
          getControlledInstance: function getControlledInstance() {
            return this.refs.inner;
          },
          render: function render() {
            var _this3 = this;

            var newProps = {},
                props = omitProps(this.props);

            utils.each(controlledValues, function (handle, propName) {
              var linkPropName = utils.getLinkName(propName),
                  prop = _this3.props[propName];

              if (linkPropName && !isProp(_this3.props, propName) && isProp(_this3.props, linkPropName)) {
                prop = _this3.props[linkPropName].value;
              }

              newProps[propName] = prop !== undefined ? prop : _this3._values[propName];

              newProps[handle] = setAndNotify.bind(_this3, propName);
            });

            newProps = _extends({}, props, newProps, {
              ref: isCompositeComponent ? 'inner' : null
            });

            return _react2.default.createElement(Component, newProps);
          }
        }));

        component.ControlledComponent = Component;

        /**
         * useful when wrapping a Component and you want to control
         * everything
         */
        component.deferControlTo = function (newComponent) {
          var additions = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
          var nextMethods = arguments[2];

          return uncontrollable(newComponent, _extends({}, controlledValues, additions), nextMethods);
        };

        return component;

        function setAndNotify(propName, value) {
          var linkName = utils.getLinkName(propName),
              handler = this.props[controlledValues[propName]];

          if (linkName && isProp(this.props, linkName) && !handler) {
            handler = this.props[linkName].requestChange;
          }

          for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
            args[_key - 2] = arguments[_key];
          }

          set(this, propName, handler, value, args);
        }

        function isProp(props, prop) {
          return props[prop] !== undefined;
        }

        function omitProps(props) {
          var result = {};

          utils.each(props, function (value, key) {
            if (OMIT_PROPS.indexOf(key) === -1) result[key] = value;
          });

          return result;
        }
      }
    }
    module.exports = exports['default'];

    },{"./utils":260,"invariant":237,"react":618}],259:[function(require,module,exports){
    'use strict';

    exports.__esModule = true;

    var _createUncontrollable = require('./createUncontrollable');

    var _createUncontrollable2 = _interopRequireDefault(_createUncontrollable);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    var mixin = {
      shouldComponentUpdate: function shouldComponentUpdate() {
        //let the forceUpdate trigger the update
        return !this._notifying;
      }
    };

    function set(component, propName, handler, value, args) {
      if (handler) {
        component._notifying = true;
        handler.call.apply(handler, [component, value].concat(args));
        component._notifying = false;
      }

      component._values[propName] = value;

      if (component.isMounted()) component.forceUpdate();
    }

    exports.default = (0, _createUncontrollable2.default)([mixin], set);
    module.exports = exports['default'];

    },{"./createUncontrollable":258}],260:[function(require,module,exports){
    (function (process){
    'use strict';

    exports.__esModule = true;
    exports.version = undefined;
    exports.uncontrolledPropTypes = uncontrolledPropTypes;
    exports.getType = getType;
    exports.getValue = getValue;
    exports.getLinkName = getLinkName;
    exports.defaultKey = defaultKey;
    exports.chain = chain;
    exports.transform = transform;
    exports.each = each;
    exports.has = has;
    exports.isReactComponent = isReactComponent;

    var _react = require('react');

    var _react2 = _interopRequireDefault(_react);

    var _invariant = require('invariant');

    var _invariant2 = _interopRequireDefault(_invariant);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    function readOnlyPropType(handler, name) {
      return function (props, propName) {
        if (props[propName] !== undefined) {
          if (!props[handler]) {
            return new Error('You have provided a `' + propName + '` prop to ' + '`' + name + '` without an `' + handler + '` handler. This will render a read-only field. ' + 'If the field should be mutable use `' + defaultKey(propName) + '`. Otherwise, set `' + handler + '`');
          }
        }
      };
    }

    function uncontrolledPropTypes(controlledValues, basePropTypes, displayName) {
      var propTypes = {};

      if (process.env.NODE_ENV !== 'production' && basePropTypes) {
        transform(controlledValues, function (obj, handler, prop) {
          (0, _invariant2.default)(typeof handler === 'string' && handler.trim().length, 'Uncontrollable - [%s]: the prop `%s` needs a valid handler key name in order to make it uncontrollable', displayName, prop);

          obj[prop] = readOnlyPropType(handler, displayName);
        }, propTypes);
      }

      return propTypes;
    }

    var version = exports.version = _react2.default.version.split('.').map(parseFloat);

    function getType(component) {
      if (version[0] >= 15 || version[0] === 0 && version[1] >= 13) return component;

      return component.type;
    }

    function getValue(props, name) {
      var linkPropName = getLinkName(name);

      if (linkPropName && !isProp(props, name) && isProp(props, linkPropName)) return props[linkPropName].value;

      return props[name];
    }

    function isProp(props, prop) {
      return props[prop] !== undefined;
    }

    function getLinkName(name) {
      return name === 'value' ? 'valueLink' : name === 'checked' ? 'checkedLink' : null;
    }

    function defaultKey(key) {
      return 'default' + key.charAt(0).toUpperCase() + key.substr(1);
    }

    function chain(thisArg, a, b) {
      return function chainedFunction() {
        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        a && a.call.apply(a, [thisArg].concat(args));
        b && b.call.apply(b, [thisArg].concat(args));
      };
    }

    function transform(obj, cb, seed) {
      each(obj, cb.bind(null, seed = seed || (Array.isArray(obj) ? [] : {})));
      return seed;
    }

    function each(obj, cb, thisArg) {
      if (Array.isArray(obj)) return obj.forEach(cb, thisArg);

      for (var key in obj) {
        if (has(obj, key)) cb.call(thisArg, obj[key], key, obj);
      }
    }

    function has(o, k) {
      return o ? Object.prototype.hasOwnProperty.call(o, k) : false;
    }

    /**
     * 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 isReactComponent(component) {
      return !!(component && component.prototype && component.prototype.isReactComponent);
    }

    }).call(this,require('_process'))
    },{"_process":728,"invariant":237,"react":618}],261:[function(require,module,exports){
    (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';

    /**
     * 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 = function() {};

    if (process.env.NODE_ENV !== 'production') {
      warning = function(condition, format, args) {
        var len = arguments.length;
        args = new Array(len > 2 ? len - 2 : 0);
        for (var key = 2; key < len; key++) {
          args[key - 2] = arguments[key];
        }
        if (format === undefined) {
          throw new Error(
            '`warning(condition, format, ...args)` requires a warning ' +
            'message argument'
          );
        }

        if (format.length < 10 || (/^[s\W]*$/).test(format)) {
          throw new Error(
            'The warning format should be able to uniquely identify this ' +
            'warning. Please, use a more descriptive format than: ' + format
          );
        }

        if (!condition) {
          var argIndex = 0;
          var message = 'Warning: ' +
            format.replace(/%s/g, function() {
              return args[argIndex++];
            });
          if (typeof console !== 'undefined') {
            console.error(message);
          }
          try {
            // 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) {}
        }
      };
    }

    module.exports = warning;

    }).call(this,require('_process'))
    },{"_process":728}],262:[function(require,module,exports){
    'use strict';

    module.exports = require('./lib/ReactDOM');

    },{"./lib/ReactDOM":292}],263:[function(require,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;

    },{}],264:[function(require,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 ReactDOMComponentTree = require('./ReactDOMComponentTree');

    var focusNode = require('fbjs/lib/focusNode');

    var AutoFocusUtils = {
      focusDOMComponent: function () {
        focusNode(ReactDOMComponentTree.getNodeFromInstance(this));
      }
    };

    module.exports = AutoFocusUtils;

    },{"./ReactDOMComponentTree":295,"fbjs/lib/focusNode":398}],265:[function(require,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 EventPropagators = require('./EventPropagators');
    var ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');
    var FallbackCompositionState = require('./FallbackCompositionState');
    var SyntheticCompositionEvent = require('./SyntheticCompositionEvent');
    var SyntheticInputEvent = require('./SyntheticInputEvent');

    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;

    },{"./EventPropagators":281,"./FallbackCompositionState":282,"./SyntheticCompositionEvent":346,"./SyntheticInputEvent":350,"fbjs/lib/ExecutionEnvironment":390}],266:[function(require,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;

    },{}],267:[function(require,module,exports){
    (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 = require('./CSSProperty');
    var ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');
    var ReactInstrumentation = require('./ReactInstrumentation');

    var camelizeStyleName = require('fbjs/lib/camelizeStyleName');
    var dangerousStyleValue = require('./dangerousStyleValue');
    var hyphenateStyleName = require('fbjs/lib/hyphenateStyleName');
    var memoizeStringOnly = require('fbjs/lib/memoizeStringOnly');
    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"./CSSProperty":266,"./ReactInstrumentation":324,"./dangerousStyleValue":363,"_process":728,"fbjs/lib/ExecutionEnvironment":390,"fbjs/lib/camelizeStyleName":392,"fbjs/lib/hyphenateStyleName":403,"fbjs/lib/memoizeStringOnly":407,"fbjs/lib/warning":411}],268:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

    var PooledClass = require('./PooledClass');

    var invariant = require('fbjs/lib/invariant');

    /**
     * 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);

    }).call(this,require('_process'))
    },{"./PooledClass":286,"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404}],269:[function(require,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 EventPluginHub = require('./EventPluginHub');
    var EventPropagators = require('./EventPropagators');
    var ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');
    var ReactDOMComponentTree = require('./ReactDOMComponentTree');
    var ReactUpdates = require('./ReactUpdates');
    var SyntheticEvent = require('./SyntheticEvent');

    var getEventTarget = require('./getEventTarget');
    var isEventSupported = require('./isEventSupported');
    var isTextInputElement = require('./isTextInputElement');

    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;

    },{"./EventPluginHub":278,"./EventPropagators":281,"./ReactDOMComponentTree":295,"./ReactUpdates":339,"./SyntheticEvent":348,"./getEventTarget":371,"./isEventSupported":379,"./isTextInputElement":380,"fbjs/lib/ExecutionEnvironment":390}],270:[function(require,module,exports){
    (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 = require('./DOMLazyTree');
    var Danger = require('./Danger');
    var ReactDOMComponentTree = require('./ReactDOMComponentTree');
    var ReactInstrumentation = require('./ReactInstrumentation');

    var createMicrosoftUnsafeLocalFunction = require('./createMicrosoftUnsafeLocalFunction');
    var setInnerHTML = require('./setInnerHTML');
    var setTextContent = require('./setTextContent');

    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;

    }).call(this,require('_process'))
    },{"./DOMLazyTree":271,"./Danger":275,"./ReactDOMComponentTree":295,"./ReactInstrumentation":324,"./createMicrosoftUnsafeLocalFunction":362,"./setInnerHTML":384,"./setTextContent":385,"_process":728}],271:[function(require,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 DOMNamespaces = require('./DOMNamespaces');
    var setInnerHTML = require('./setInnerHTML');

    var createMicrosoftUnsafeLocalFunction = require('./createMicrosoftUnsafeLocalFunction');
    var setTextContent = require('./setTextContent');

    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;

    },{"./DOMNamespaces":272,"./createMicrosoftUnsafeLocalFunction":362,"./setInnerHTML":384,"./setTextContent":385}],272:[function(require,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;

    },{}],273:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var invariant = require('fbjs/lib/invariant');

    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;

    }).call(this,require('_process'))
    },{"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404}],274:[function(require,module,exports){
    (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 = require('./DOMProperty');
    var ReactDOMComponentTree = require('./ReactDOMComponentTree');
    var ReactInstrumentation = require('./ReactInstrumentation');

    var quoteAttributeValueForBrowser = require('./quoteAttributeValueForBrowser');
    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"./DOMProperty":273,"./ReactDOMComponentTree":295,"./ReactInstrumentation":324,"./quoteAttributeValueForBrowser":381,"_process":728,"fbjs/lib/warning":411}],275:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var DOMLazyTree = require('./DOMLazyTree');
    var ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');

    var createNodesFromMarkup = require('fbjs/lib/createNodesFromMarkup');
    var emptyFunction = require('fbjs/lib/emptyFunction');
    var invariant = require('fbjs/lib/invariant');

    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;

    }).call(this,require('_process'))
    },{"./DOMLazyTree":271,"./reactProdInvariant":382,"_process":728,"fbjs/lib/ExecutionEnvironment":390,"fbjs/lib/createNodesFromMarkup":395,"fbjs/lib/emptyFunction":396,"fbjs/lib/invariant":404}],276:[function(require,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;

    },{}],277:[function(require,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 EventPropagators = require('./EventPropagators');
    var ReactDOMComponentTree = require('./ReactDOMComponentTree');
    var SyntheticMouseEvent = require('./SyntheticMouseEvent');

    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;

    },{"./EventPropagators":281,"./ReactDOMComponentTree":295,"./SyntheticMouseEvent":352}],278:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var EventPluginRegistry = require('./EventPluginRegistry');
    var EventPluginUtils = require('./EventPluginUtils');
    var ReactErrorUtils = require('./ReactErrorUtils');

    var accumulateInto = require('./accumulateInto');
    var forEachAccumulated = require('./forEachAccumulated');
    var invariant = require('fbjs/lib/invariant');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./EventPluginRegistry":279,"./EventPluginUtils":280,"./ReactErrorUtils":315,"./accumulateInto":359,"./forEachAccumulated":367,"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404}],279:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var invariant = require('fbjs/lib/invariant');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404}],280:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var ReactErrorUtils = require('./ReactErrorUtils');

    var invariant = require('fbjs/lib/invariant');
    var warning = require('fbjs/lib/warning');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./ReactErrorUtils":315,"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404,"fbjs/lib/warning":411}],281:[function(require,module,exports){
    (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 = require('./EventPluginHub');
    var EventPluginUtils = require('./EventPluginUtils');

    var accumulateInto = require('./accumulateInto');
    var forEachAccumulated = require('./forEachAccumulated');
    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"./EventPluginHub":278,"./EventPluginUtils":280,"./accumulateInto":359,"./forEachAccumulated":367,"_process":728,"fbjs/lib/warning":411}],282:[function(require,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 _assign = require('object-assign');

    var PooledClass = require('./PooledClass');

    var getTextContentAccessor = require('./getTextContentAccessor');

    /**
     * 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;

    },{"./PooledClass":286,"./getTextContentAccessor":376,"object-assign":412}],283:[function(require,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 DOMProperty = require('./DOMProperty');

    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;

    },{"./DOMProperty":273}],284:[function(require,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;

    },{}],285:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var React = require('react/lib/React');
    var ReactPropTypesSecret = require('./ReactPropTypesSecret');

    var invariant = require('fbjs/lib/invariant');
    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"./ReactPropTypesSecret":332,"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404,"fbjs/lib/warning":411,"react/lib/React":588}],286:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var invariant = require('fbjs/lib/invariant');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404}],287:[function(require,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 _assign = require('object-assign');

    var EventPluginRegistry = require('./EventPluginRegistry');
    var ReactEventEmitterMixin = require('./ReactEventEmitterMixin');
    var ViewportMetrics = require('./ViewportMetrics');

    var getVendorPrefixedEventName = require('./getVendorPrefixedEventName');
    var isEventSupported = require('./isEventSupported');

    /**
     * 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;

    },{"./EventPluginRegistry":279,"./ReactEventEmitterMixin":316,"./ViewportMetrics":358,"./getVendorPrefixedEventName":377,"./isEventSupported":379,"object-assign":412}],288:[function(require,module,exports){
    (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 = require('./ReactReconciler');

    var instantiateReactComponent = require('./instantiateReactComponent');
    var KeyEscapeUtils = require('./KeyEscapeUtils');
    var shouldUpdateReactComponent = require('./shouldUpdateReactComponent');
    var traverseAllChildren = require('./traverseAllChildren');
    var warning = require('fbjs/lib/warning');

    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 = require('react/lib/ReactComponentTreeHook');
    }

    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 = require('react/lib/ReactComponentTreeHook');
        }
        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;

    }).call(this,require('_process'))
    },{"./KeyEscapeUtils":284,"./ReactReconciler":334,"./instantiateReactComponent":378,"./shouldUpdateReactComponent":386,"./traverseAllChildren":387,"_process":728,"fbjs/lib/warning":411,"react/lib/ReactComponentTreeHook":592}],289:[function(require,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 DOMChildrenOperations = require('./DOMChildrenOperations');
    var ReactDOMIDOperations = require('./ReactDOMIDOperations');

    /**
     * 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;

    },{"./DOMChildrenOperations":270,"./ReactDOMIDOperations":299}],290:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var invariant = require('fbjs/lib/invariant');

    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;

    }).call(this,require('_process'))
    },{"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404}],291:[function(require,module,exports){
    (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 = require('./reactProdInvariant'),
        _assign = require('object-assign');

    var React = require('react/lib/React');
    var ReactComponentEnvironment = require('./ReactComponentEnvironment');
    var ReactCurrentOwner = require('react/lib/ReactCurrentOwner');
    var ReactErrorUtils = require('./ReactErrorUtils');
    var ReactInstanceMap = require('./ReactInstanceMap');
    var ReactInstrumentation = require('./ReactInstrumentation');
    var ReactNodeTypes = require('./ReactNodeTypes');
    var ReactReconciler = require('./ReactReconciler');

    if (process.env.NODE_ENV !== 'production') {
      var checkReactTypeSpec = require('./checkReactTypeSpec');
    }

    var emptyObject = require('fbjs/lib/emptyObject');
    var invariant = require('fbjs/lib/invariant');
    var shallowEqual = require('fbjs/lib/shallowEqual');
    var shouldUpdateReactComponent = require('./shouldUpdateReactComponent');
    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"./ReactComponentEnvironment":290,"./ReactErrorUtils":315,"./ReactInstanceMap":323,"./ReactInstrumentation":324,"./ReactNodeTypes":329,"./ReactReconciler":334,"./checkReactTypeSpec":361,"./reactProdInvariant":382,"./shouldUpdateReactComponent":386,"_process":728,"fbjs/lib/emptyObject":397,"fbjs/lib/invariant":404,"fbjs/lib/shallowEqual":410,"fbjs/lib/warning":411,"object-assign":412,"react/lib/React":588,"react/lib/ReactCurrentOwner":593}],292:[function(require,module,exports){
    (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 = require('./ReactDOMComponentTree');
    var ReactDefaultInjection = require('./ReactDefaultInjection');
    var ReactMount = require('./ReactMount');
    var ReactReconciler = require('./ReactReconciler');
    var ReactUpdates = require('./ReactUpdates');
    var ReactVersion = require('./ReactVersion');

    var findDOMNode = require('./findDOMNode');
    var getHostComponentFromComposite = require('./getHostComponentFromComposite');
    var renderSubtreeIntoContainer = require('./renderSubtreeIntoContainer');
    var warning = require('fbjs/lib/warning');

    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 = require('fbjs/lib/ExecutionEnvironment');
      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 = require('./ReactInstrumentation');
      var ReactDOMUnknownPropertyHook = require('./ReactDOMUnknownPropertyHook');
      var ReactDOMNullInputValuePropHook = require('./ReactDOMNullInputValuePropHook');
      var ReactDOMInvalidARIAHook = require('./ReactDOMInvalidARIAHook');

      ReactInstrumentation.debugTool.addHook(ReactDOMUnknownPropertyHook);
      ReactInstrumentation.debugTool.addHook(ReactDOMNullInputValuePropHook);
      ReactInstrumentation.debugTool.addHook(ReactDOMInvalidARIAHook);
    }

    module.exports = ReactDOM;

    }).call(this,require('_process'))
    },{"./ReactDOMComponentTree":295,"./ReactDOMInvalidARIAHook":301,"./ReactDOMNullInputValuePropHook":302,"./ReactDOMUnknownPropertyHook":309,"./ReactDefaultInjection":312,"./ReactInstrumentation":324,"./ReactMount":327,"./ReactReconciler":334,"./ReactUpdates":339,"./ReactVersion":340,"./findDOMNode":365,"./getHostComponentFromComposite":372,"./renderSubtreeIntoContainer":383,"_process":728,"fbjs/lib/ExecutionEnvironment":390,"fbjs/lib/warning":411}],293:[function(require,module,exports){
    (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 = require('./reactProdInvariant'),
        _assign = require('object-assign');

    var AutoFocusUtils = require('./AutoFocusUtils');
    var CSSPropertyOperations = require('./CSSPropertyOperations');
    var DOMLazyTree = require('./DOMLazyTree');
    var DOMNamespaces = require('./DOMNamespaces');
    var DOMProperty = require('./DOMProperty');
    var DOMPropertyOperations = require('./DOMPropertyOperations');
    var EventPluginHub = require('./EventPluginHub');
    var EventPluginRegistry = require('./EventPluginRegistry');
    var ReactBrowserEventEmitter = require('./ReactBrowserEventEmitter');
    var ReactDOMComponentFlags = require('./ReactDOMComponentFlags');
    var ReactDOMComponentTree = require('./ReactDOMComponentTree');
    var ReactDOMInput = require('./ReactDOMInput');
    var ReactDOMOption = require('./ReactDOMOption');
    var ReactDOMSelect = require('./ReactDOMSelect');
    var ReactDOMTextarea = require('./ReactDOMTextarea');
    var ReactInstrumentation = require('./ReactInstrumentation');
    var ReactMultiChild = require('./ReactMultiChild');
    var ReactServerRenderingTransaction = require('./ReactServerRenderingTransaction');

    var emptyFunction = require('fbjs/lib/emptyFunction');
    var escapeTextContentForBrowser = require('./escapeTextContentForBrowser');
    var invariant = require('fbjs/lib/invariant');
    var isEventSupported = require('./isEventSupported');
    var shallowEqual = require('fbjs/lib/shallowEqual');
    var validateDOMNesting = require('./validateDOMNesting');
    var warning = require('fbjs/lib/warning');

    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.
             */
            !false ? 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;

    }).call(this,require('_process'))
    },{"./AutoFocusUtils":264,"./CSSPropertyOperations":267,"./DOMLazyTree":271,"./DOMNamespaces":272,"./DOMProperty":273,"./DOMPropertyOperations":274,"./EventPluginHub":278,"./EventPluginRegistry":279,"./ReactBrowserEventEmitter":287,"./ReactDOMComponentFlags":294,"./ReactDOMComponentTree":295,"./ReactDOMInput":300,"./ReactDOMOption":303,"./ReactDOMSelect":304,"./ReactDOMTextarea":307,"./ReactInstrumentation":324,"./ReactMultiChild":328,"./ReactServerRenderingTransaction":336,"./escapeTextContentForBrowser":364,"./isEventSupported":379,"./reactProdInvariant":382,"./validateDOMNesting":388,"_process":728,"fbjs/lib/emptyFunction":396,"fbjs/lib/invariant":404,"fbjs/lib/shallowEqual":410,"fbjs/lib/warning":411,"object-assign":412}],294:[function(require,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;

    },{}],295:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var DOMProperty = require('./DOMProperty');
    var ReactDOMComponentFlags = require('./ReactDOMComponentFlags');

    var invariant = require('fbjs/lib/invariant');

    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.
        !false ? 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;

    }).call(this,require('_process'))
    },{"./DOMProperty":273,"./ReactDOMComponentFlags":294,"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404}],296:[function(require,module,exports){
    (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 = require('./validateDOMNesting');

    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;

    }).call(this,require('_process'))
    },{"./validateDOMNesting":388,"_process":728}],297:[function(require,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 _assign = require('object-assign');

    var DOMLazyTree = require('./DOMLazyTree');
    var ReactDOMComponentTree = require('./ReactDOMComponentTree');

    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;

    },{"./DOMLazyTree":271,"./ReactDOMComponentTree":295,"object-assign":412}],298:[function(require,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;

    },{}],299:[function(require,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 DOMChildrenOperations = require('./DOMChildrenOperations');
    var ReactDOMComponentTree = require('./ReactDOMComponentTree');

    /**
     * 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;

    },{"./DOMChildrenOperations":270,"./ReactDOMComponentTree":295}],300:[function(require,module,exports){
    (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 = require('./reactProdInvariant'),
        _assign = require('object-assign');

    var DOMPropertyOperations = require('./DOMPropertyOperations');
    var LinkedValueUtils = require('./LinkedValueUtils');
    var ReactDOMComponentTree = require('./ReactDOMComponentTree');
    var ReactUpdates = require('./ReactUpdates');

    var invariant = require('fbjs/lib/invariant');
    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"./DOMPropertyOperations":274,"./LinkedValueUtils":285,"./ReactDOMComponentTree":295,"./ReactUpdates":339,"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404,"fbjs/lib/warning":411,"object-assign":412}],301:[function(require,module,exports){
    (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 = require('./DOMProperty');
    var ReactComponentTreeHook = require('react/lib/ReactComponentTreeHook');

    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"./DOMProperty":273,"_process":728,"fbjs/lib/warning":411,"react/lib/ReactComponentTreeHook":592}],302:[function(require,module,exports){
    (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 = require('react/lib/ReactComponentTreeHook');

    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"_process":728,"fbjs/lib/warning":411,"react/lib/ReactComponentTreeHook":592}],303:[function(require,module,exports){
    (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 = require('object-assign');

    var React = require('react/lib/React');
    var ReactDOMComponentTree = require('./ReactDOMComponentTree');
    var ReactDOMSelect = require('./ReactDOMSelect');

    var warning = require('fbjs/lib/warning');
    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;

    }).call(this,require('_process'))
    },{"./ReactDOMComponentTree":295,"./ReactDOMSelect":304,"_process":728,"fbjs/lib/warning":411,"object-assign":412,"react/lib/React":588}],304:[function(require,module,exports){
    (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 = require('object-assign');

    var LinkedValueUtils = require('./LinkedValueUtils');
    var ReactDOMComponentTree = require('./ReactDOMComponentTree');
    var ReactUpdates = require('./ReactUpdates');

    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"./LinkedValueUtils":285,"./ReactDOMComponentTree":295,"./ReactUpdates":339,"_process":728,"fbjs/lib/warning":411,"object-assign":412}],305:[function(require,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 ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');

    var getNodeForCharacterOffset = require('./getNodeForCharacterOffset');
    var getTextContentAccessor = require('./getTextContentAccessor');

    /**
     * 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;

    },{"./getNodeForCharacterOffset":375,"./getTextContentAccessor":376,"fbjs/lib/ExecutionEnvironment":390}],306:[function(require,module,exports){
    (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 = require('./reactProdInvariant'),
        _assign = require('object-assign');

    var DOMChildrenOperations = require('./DOMChildrenOperations');
    var DOMLazyTree = require('./DOMLazyTree');
    var ReactDOMComponentTree = require('./ReactDOMComponentTree');

    var escapeTextContentForBrowser = require('./escapeTextContentForBrowser');
    var invariant = require('fbjs/lib/invariant');
    var validateDOMNesting = require('./validateDOMNesting');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./DOMChildrenOperations":270,"./DOMLazyTree":271,"./ReactDOMComponentTree":295,"./escapeTextContentForBrowser":364,"./reactProdInvariant":382,"./validateDOMNesting":388,"_process":728,"fbjs/lib/invariant":404,"object-assign":412}],307:[function(require,module,exports){
    (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 = require('./reactProdInvariant'),
        _assign = require('object-assign');

    var LinkedValueUtils = require('./LinkedValueUtils');
    var ReactDOMComponentTree = require('./ReactDOMComponentTree');
    var ReactUpdates = require('./ReactUpdates');

    var invariant = require('fbjs/lib/invariant');
    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"./LinkedValueUtils":285,"./ReactDOMComponentTree":295,"./ReactUpdates":339,"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404,"fbjs/lib/warning":411,"object-assign":412}],308:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var invariant = require('fbjs/lib/invariant');

    /**
     * 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
    };

    }).call(this,require('_process'))
    },{"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404}],309:[function(require,module,exports){
    (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 = require('./DOMProperty');
    var EventPluginRegistry = require('./EventPluginRegistry');
    var ReactComponentTreeHook = require('react/lib/ReactComponentTreeHook');

    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"./DOMProperty":273,"./EventPluginRegistry":279,"_process":728,"fbjs/lib/warning":411,"react/lib/ReactComponentTreeHook":592}],310:[function(require,module,exports){
    (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 = require('./ReactInvalidSetStateWarningHook');
    var ReactHostOperationHistoryHook = require('./ReactHostOperationHistoryHook');
    var ReactComponentTreeHook = require('react/lib/ReactComponentTreeHook');
    var ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');

    var performanceNow = require('fbjs/lib/performanceNow');
    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"./ReactHostOperationHistoryHook":320,"./ReactInvalidSetStateWarningHook":325,"_process":728,"fbjs/lib/ExecutionEnvironment":390,"fbjs/lib/performanceNow":409,"fbjs/lib/warning":411,"react/lib/ReactComponentTreeHook":592}],311:[function(require,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 _assign = require('object-assign');

    var ReactUpdates = require('./ReactUpdates');
    var Transaction = require('./Transaction');

    var emptyFunction = require('fbjs/lib/emptyFunction');

    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;

    },{"./ReactUpdates":339,"./Transaction":357,"fbjs/lib/emptyFunction":396,"object-assign":412}],312:[function(require,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 = require('./ARIADOMPropertyConfig');
    var BeforeInputEventPlugin = require('./BeforeInputEventPlugin');
    var ChangeEventPlugin = require('./ChangeEventPlugin');
    var DefaultEventPluginOrder = require('./DefaultEventPluginOrder');
    var EnterLeaveEventPlugin = require('./EnterLeaveEventPlugin');
    var HTMLDOMPropertyConfig = require('./HTMLDOMPropertyConfig');
    var ReactComponentBrowserEnvironment = require('./ReactComponentBrowserEnvironment');
    var ReactDOMComponent = require('./ReactDOMComponent');
    var ReactDOMComponentTree = require('./ReactDOMComponentTree');
    var ReactDOMEmptyComponent = require('./ReactDOMEmptyComponent');
    var ReactDOMTreeTraversal = require('./ReactDOMTreeTraversal');
    var ReactDOMTextComponent = require('./ReactDOMTextComponent');
    var ReactDefaultBatchingStrategy = require('./ReactDefaultBatchingStrategy');
    var ReactEventListener = require('./ReactEventListener');
    var ReactInjection = require('./ReactInjection');
    var ReactReconcileTransaction = require('./ReactReconcileTransaction');
    var SVGDOMPropertyConfig = require('./SVGDOMPropertyConfig');
    var SelectEventPlugin = require('./SelectEventPlugin');
    var SimpleEventPlugin = require('./SimpleEventPlugin');

    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
    };

    },{"./ARIADOMPropertyConfig":263,"./BeforeInputEventPlugin":265,"./ChangeEventPlugin":269,"./DefaultEventPluginOrder":276,"./EnterLeaveEventPlugin":277,"./HTMLDOMPropertyConfig":283,"./ReactComponentBrowserEnvironment":289,"./ReactDOMComponent":293,"./ReactDOMComponentTree":295,"./ReactDOMEmptyComponent":297,"./ReactDOMTextComponent":306,"./ReactDOMTreeTraversal":308,"./ReactDefaultBatchingStrategy":311,"./ReactEventListener":317,"./ReactInjection":321,"./ReactReconcileTransaction":333,"./SVGDOMPropertyConfig":341,"./SelectEventPlugin":342,"./SimpleEventPlugin":343}],313:[function(require,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;

    },{}],314:[function(require,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;

    },{}],315:[function(require,module,exports){
    (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;

    }).call(this,require('_process'))
    },{"_process":728}],316:[function(require,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 EventPluginHub = require('./EventPluginHub');

    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;

    },{"./EventPluginHub":278}],317:[function(require,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 _assign = require('object-assign');

    var EventListener = require('fbjs/lib/EventListener');
    var ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');
    var PooledClass = require('./PooledClass');
    var ReactDOMComponentTree = require('./ReactDOMComponentTree');
    var ReactUpdates = require('./ReactUpdates');

    var getEventTarget = require('./getEventTarget');
    var getUnboundedScrollPosition = require('fbjs/lib/getUnboundedScrollPosition');

    /**
     * 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;

    },{"./PooledClass":286,"./ReactDOMComponentTree":295,"./ReactUpdates":339,"./getEventTarget":371,"fbjs/lib/EventListener":389,"fbjs/lib/ExecutionEnvironment":390,"fbjs/lib/getUnboundedScrollPosition":401,"object-assign":412}],318:[function(require,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;

    },{}],319:[function(require,module,exports){
    (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 = require('./reactProdInvariant'),
        _assign = require('object-assign');

    var invariant = require('fbjs/lib/invariant');

    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;

    }).call(this,require('_process'))
    },{"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404,"object-assign":412}],320:[function(require,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;

    },{}],321:[function(require,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 DOMProperty = require('./DOMProperty');
    var EventPluginHub = require('./EventPluginHub');
    var EventPluginUtils = require('./EventPluginUtils');
    var ReactComponentEnvironment = require('./ReactComponentEnvironment');
    var ReactEmptyComponent = require('./ReactEmptyComponent');
    var ReactBrowserEventEmitter = require('./ReactBrowserEventEmitter');
    var ReactHostComponent = require('./ReactHostComponent');
    var ReactUpdates = require('./ReactUpdates');

    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;

    },{"./DOMProperty":273,"./EventPluginHub":278,"./EventPluginUtils":280,"./ReactBrowserEventEmitter":287,"./ReactComponentEnvironment":290,"./ReactEmptyComponent":314,"./ReactHostComponent":319,"./ReactUpdates":339}],322:[function(require,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 ReactDOMSelection = require('./ReactDOMSelection');

    var containsNode = require('fbjs/lib/containsNode');
    var focusNode = require('fbjs/lib/focusNode');
    var getActiveElement = require('fbjs/lib/getActiveElement');

    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;

    },{"./ReactDOMSelection":305,"fbjs/lib/containsNode":393,"fbjs/lib/focusNode":398,"fbjs/lib/getActiveElement":399}],323:[function(require,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;

    },{}],324:[function(require,module,exports){
    (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 = require('./ReactDebugTool');
      debugTool = ReactDebugTool;
    }

    module.exports = { debugTool: debugTool };

    }).call(this,require('_process'))
    },{"./ReactDebugTool":310,"_process":728}],325:[function(require,module,exports){
    (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 = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"_process":728,"fbjs/lib/warning":411}],326:[function(require,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 adler32 = require('./adler32');

    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;

    },{"./adler32":360}],327:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var DOMLazyTree = require('./DOMLazyTree');
    var DOMProperty = require('./DOMProperty');
    var React = require('react/lib/React');
    var ReactBrowserEventEmitter = require('./ReactBrowserEventEmitter');
    var ReactCurrentOwner = require('react/lib/ReactCurrentOwner');
    var ReactDOMComponentTree = require('./ReactDOMComponentTree');
    var ReactDOMContainerInfo = require('./ReactDOMContainerInfo');
    var ReactDOMFeatureFlags = require('./ReactDOMFeatureFlags');
    var ReactFeatureFlags = require('./ReactFeatureFlags');
    var ReactInstanceMap = require('./ReactInstanceMap');
    var ReactInstrumentation = require('./ReactInstrumentation');
    var ReactMarkupChecksum = require('./ReactMarkupChecksum');
    var ReactReconciler = require('./ReactReconciler');
    var ReactUpdateQueue = require('./ReactUpdateQueue');
    var ReactUpdates = require('./ReactUpdates');

    var emptyObject = require('fbjs/lib/emptyObject');
    var instantiateReactComponent = require('./instantiateReactComponent');
    var invariant = require('fbjs/lib/invariant');
    var setInnerHTML = require('./setInnerHTML');
    var shouldUpdateReactComponent = require('./shouldUpdateReactComponent');
    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"./DOMLazyTree":271,"./DOMProperty":273,"./ReactBrowserEventEmitter":287,"./ReactDOMComponentTree":295,"./ReactDOMContainerInfo":296,"./ReactDOMFeatureFlags":298,"./ReactFeatureFlags":318,"./ReactInstanceMap":323,"./ReactInstrumentation":324,"./ReactMarkupChecksum":326,"./ReactReconciler":334,"./ReactUpdateQueue":338,"./ReactUpdates":339,"./instantiateReactComponent":378,"./reactProdInvariant":382,"./setInnerHTML":384,"./shouldUpdateReactComponent":386,"_process":728,"fbjs/lib/emptyObject":397,"fbjs/lib/invariant":404,"fbjs/lib/warning":411,"react/lib/React":588,"react/lib/ReactCurrentOwner":593}],328:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var ReactComponentEnvironment = require('./ReactComponentEnvironment');
    var ReactInstanceMap = require('./ReactInstanceMap');
    var ReactInstrumentation = require('./ReactInstrumentation');

    var ReactCurrentOwner = require('react/lib/ReactCurrentOwner');
    var ReactReconciler = require('./ReactReconciler');
    var ReactChildReconciler = require('./ReactChildReconciler');

    var emptyFunction = require('fbjs/lib/emptyFunction');
    var flattenChildren = require('./flattenChildren');
    var invariant = require('fbjs/lib/invariant');

    /**
     * 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)) {
              !false ? 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)) {
              !false ? 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;

    }).call(this,require('_process'))
    },{"./ReactChildReconciler":288,"./ReactComponentEnvironment":290,"./ReactInstanceMap":323,"./ReactInstrumentation":324,"./ReactReconciler":334,"./flattenChildren":366,"./reactProdInvariant":382,"_process":728,"fbjs/lib/emptyFunction":396,"fbjs/lib/invariant":404,"react/lib/ReactCurrentOwner":593}],329:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var React = require('react/lib/React');

    var invariant = require('fbjs/lib/invariant');

    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;
          }
        }
        !false ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Unexpected node: %s', node) : _prodInvariant('26', node) : void 0;
      }
    };

    module.exports = ReactNodeTypes;

    }).call(this,require('_process'))
    },{"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404,"react/lib/React":588}],330:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var invariant = require('fbjs/lib/invariant');

    /**
     * @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;

    }).call(this,require('_process'))
    },{"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404}],331:[function(require,module,exports){
    (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;

    }).call(this,require('_process'))
    },{"_process":728}],332:[function(require,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;

    },{}],333:[function(require,module,exports){
    (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 = require('object-assign');

    var CallbackQueue = require('./CallbackQueue');
    var PooledClass = require('./PooledClass');
    var ReactBrowserEventEmitter = require('./ReactBrowserEventEmitter');
    var ReactInputSelection = require('./ReactInputSelection');
    var ReactInstrumentation = require('./ReactInstrumentation');
    var Transaction = require('./Transaction');
    var ReactUpdateQueue = require('./ReactUpdateQueue');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./CallbackQueue":268,"./PooledClass":286,"./ReactBrowserEventEmitter":287,"./ReactInputSelection":322,"./ReactInstrumentation":324,"./ReactUpdateQueue":338,"./Transaction":357,"_process":728,"object-assign":412}],334:[function(require,module,exports){
    (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 = require('./ReactRef');
    var ReactInstrumentation = require('./ReactInstrumentation');

    var warning = require('fbjs/lib/warning');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./ReactInstrumentation":324,"./ReactRef":335,"_process":728,"fbjs/lib/warning":411}],335:[function(require,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 ReactOwner = require('./ReactOwner');

    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;

    },{"./ReactOwner":330}],336:[function(require,module,exports){
    (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 = require('object-assign');

    var PooledClass = require('./PooledClass');
    var Transaction = require('./Transaction');
    var ReactInstrumentation = require('./ReactInstrumentation');
    var ReactServerUpdateQueue = require('./ReactServerUpdateQueue');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./PooledClass":286,"./ReactInstrumentation":324,"./ReactServerUpdateQueue":337,"./Transaction":357,"_process":728,"object-assign":412}],337:[function(require,module,exports){
    (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 = require('./ReactUpdateQueue');

    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"./ReactUpdateQueue":338,"_process":728,"fbjs/lib/warning":411}],338:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var ReactCurrentOwner = require('react/lib/ReactCurrentOwner');
    var ReactInstanceMap = require('./ReactInstanceMap');
    var ReactInstrumentation = require('./ReactInstrumentation');
    var ReactUpdates = require('./ReactUpdates');

    var invariant = require('fbjs/lib/invariant');
    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"./ReactInstanceMap":323,"./ReactInstrumentation":324,"./ReactUpdates":339,"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404,"fbjs/lib/warning":411,"react/lib/ReactCurrentOwner":593}],339:[function(require,module,exports){
    (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 = require('./reactProdInvariant'),
        _assign = require('object-assign');

    var CallbackQueue = require('./CallbackQueue');
    var PooledClass = require('./PooledClass');
    var ReactFeatureFlags = require('./ReactFeatureFlags');
    var ReactReconciler = require('./ReactReconciler');
    var Transaction = require('./Transaction');

    var invariant = require('fbjs/lib/invariant');

    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;

    }).call(this,require('_process'))
    },{"./CallbackQueue":268,"./PooledClass":286,"./ReactFeatureFlags":318,"./ReactReconciler":334,"./Transaction":357,"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404,"object-assign":412}],340:[function(require,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';

    },{}],341:[function(require,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;

    },{}],342:[function(require,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 EventPropagators = require('./EventPropagators');
    var ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');
    var ReactDOMComponentTree = require('./ReactDOMComponentTree');
    var ReactInputSelection = require('./ReactInputSelection');
    var SyntheticEvent = require('./SyntheticEvent');

    var getActiveElement = require('fbjs/lib/getActiveElement');
    var isTextInputElement = require('./isTextInputElement');
    var shallowEqual = require('fbjs/lib/shallowEqual');

    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;

    },{"./EventPropagators":281,"./ReactDOMComponentTree":295,"./ReactInputSelection":322,"./SyntheticEvent":348,"./isTextInputElement":380,"fbjs/lib/ExecutionEnvironment":390,"fbjs/lib/getActiveElement":399,"fbjs/lib/shallowEqual":410}],343:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var EventListener = require('fbjs/lib/EventListener');
    var EventPropagators = require('./EventPropagators');
    var ReactDOMComponentTree = require('./ReactDOMComponentTree');
    var SyntheticAnimationEvent = require('./SyntheticAnimationEvent');
    var SyntheticClipboardEvent = require('./SyntheticClipboardEvent');
    var SyntheticEvent = require('./SyntheticEvent');
    var SyntheticFocusEvent = require('./SyntheticFocusEvent');
    var SyntheticKeyboardEvent = require('./SyntheticKeyboardEvent');
    var SyntheticMouseEvent = require('./SyntheticMouseEvent');
    var SyntheticDragEvent = require('./SyntheticDragEvent');
    var SyntheticTouchEvent = require('./SyntheticTouchEvent');
    var SyntheticTransitionEvent = require('./SyntheticTransitionEvent');
    var SyntheticUIEvent = require('./SyntheticUIEvent');
    var SyntheticWheelEvent = require('./SyntheticWheelEvent');

    var emptyFunction = require('fbjs/lib/emptyFunction');
    var getEventCharCode = require('./getEventCharCode');
    var invariant = require('fbjs/lib/invariant');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./EventPropagators":281,"./ReactDOMComponentTree":295,"./SyntheticAnimationEvent":344,"./SyntheticClipboardEvent":345,"./SyntheticDragEvent":347,"./SyntheticEvent":348,"./SyntheticFocusEvent":349,"./SyntheticKeyboardEvent":351,"./SyntheticMouseEvent":352,"./SyntheticTouchEvent":353,"./SyntheticTransitionEvent":354,"./SyntheticUIEvent":355,"./SyntheticWheelEvent":356,"./getEventCharCode":368,"./reactProdInvariant":382,"_process":728,"fbjs/lib/EventListener":389,"fbjs/lib/emptyFunction":396,"fbjs/lib/invariant":404}],344:[function(require,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 SyntheticEvent = require('./SyntheticEvent');

    /**
     * @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;

    },{"./SyntheticEvent":348}],345:[function(require,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 SyntheticEvent = require('./SyntheticEvent');

    /**
     * @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;

    },{"./SyntheticEvent":348}],346:[function(require,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 SyntheticEvent = require('./SyntheticEvent');

    /**
     * @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;

    },{"./SyntheticEvent":348}],347:[function(require,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 SyntheticMouseEvent = require('./SyntheticMouseEvent');

    /**
     * @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;

    },{"./SyntheticMouseEvent":352}],348:[function(require,module,exports){
    (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 = require('object-assign');

    var PooledClass = require('./PooledClass');

    var emptyFunction = require('fbjs/lib/emptyFunction');
    var warning = require('fbjs/lib/warning');

    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;
      }
    }

    }).call(this,require('_process'))
    },{"./PooledClass":286,"_process":728,"fbjs/lib/emptyFunction":396,"fbjs/lib/warning":411,"object-assign":412}],349:[function(require,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 SyntheticUIEvent = require('./SyntheticUIEvent');

    /**
     * @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;

    },{"./SyntheticUIEvent":355}],350:[function(require,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 SyntheticEvent = require('./SyntheticEvent');

    /**
     * @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;

    },{"./SyntheticEvent":348}],351:[function(require,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 SyntheticUIEvent = require('./SyntheticUIEvent');

    var getEventCharCode = require('./getEventCharCode');
    var getEventKey = require('./getEventKey');
    var getEventModifierState = require('./getEventModifierState');

    /**
     * @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;

    },{"./SyntheticUIEvent":355,"./getEventCharCode":368,"./getEventKey":369,"./getEventModifierState":370}],352:[function(require,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 SyntheticUIEvent = require('./SyntheticUIEvent');
    var ViewportMetrics = require('./ViewportMetrics');

    var getEventModifierState = require('./getEventModifierState');

    /**
     * @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;

    },{"./SyntheticUIEvent":355,"./ViewportMetrics":358,"./getEventModifierState":370}],353:[function(require,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 SyntheticUIEvent = require('./SyntheticUIEvent');

    var getEventModifierState = require('./getEventModifierState');

    /**
     * @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;

    },{"./SyntheticUIEvent":355,"./getEventModifierState":370}],354:[function(require,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 SyntheticEvent = require('./SyntheticEvent');

    /**
     * @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;

    },{"./SyntheticEvent":348}],355:[function(require,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 SyntheticEvent = require('./SyntheticEvent');

    var getEventTarget = require('./getEventTarget');

    /**
     * @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;

    },{"./SyntheticEvent":348,"./getEventTarget":371}],356:[function(require,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 SyntheticMouseEvent = require('./SyntheticMouseEvent');

    /**
     * @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;

    },{"./SyntheticMouseEvent":352}],357:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var invariant = require('fbjs/lib/invariant');

    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;

    }).call(this,require('_process'))
    },{"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404}],358:[function(require,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;

    },{}],359:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var invariant = require('fbjs/lib/invariant');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404}],360:[function(require,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;

    },{}],361:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var ReactPropTypeLocationNames = require('./ReactPropTypeLocationNames');
    var ReactPropTypesSecret = require('./ReactPropTypesSecret');

    var invariant = require('fbjs/lib/invariant');
    var warning = require('fbjs/lib/warning');

    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 = require('react/lib/ReactComponentTreeHook');
    }

    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 = require('react/lib/ReactComponentTreeHook');
              }
              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;

    }).call(this,require('_process'))
    },{"./ReactPropTypeLocationNames":331,"./ReactPropTypesSecret":332,"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404,"fbjs/lib/warning":411,"react/lib/ReactComponentTreeHook":592}],362:[function(require,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;

    },{}],363:[function(require,module,exports){
    (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 = require('./CSSProperty');
    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"./CSSProperty":266,"_process":728,"fbjs/lib/warning":411}],364:[function(require,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;

    },{}],365:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var ReactCurrentOwner = require('react/lib/ReactCurrentOwner');
    var ReactDOMComponentTree = require('./ReactDOMComponentTree');
    var ReactInstanceMap = require('./ReactInstanceMap');

    var getHostComponentFromComposite = require('./getHostComponentFromComposite');
    var invariant = require('fbjs/lib/invariant');
    var warning = require('fbjs/lib/warning');

    /**
     * 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') {
        !false ? process.env.NODE_ENV !== 'production' ? invariant(false, 'findDOMNode was called on an unmounted component.') : _prodInvariant('44') : void 0;
      } else {
        !false ? 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;

    }).call(this,require('_process'))
    },{"./ReactDOMComponentTree":295,"./ReactInstanceMap":323,"./getHostComponentFromComposite":372,"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404,"fbjs/lib/warning":411,"react/lib/ReactCurrentOwner":593}],366:[function(require,module,exports){
    (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 = require('./KeyEscapeUtils');
    var traverseAllChildren = require('./traverseAllChildren');
    var warning = require('fbjs/lib/warning');

    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 = require('react/lib/ReactComponentTreeHook');
    }

    /**
     * @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 = require('react/lib/ReactComponentTreeHook');
          }
          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;

    }).call(this,require('_process'))
    },{"./KeyEscapeUtils":284,"./traverseAllChildren":387,"_process":728,"fbjs/lib/warning":411,"react/lib/ReactComponentTreeHook":592}],367:[function(require,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;

    },{}],368:[function(require,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;

    },{}],369:[function(require,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 getEventCharCode = require('./getEventCharCode');

    /**
     * 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;

    },{"./getEventCharCode":368}],370:[function(require,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;

    },{}],371:[function(require,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;

    },{}],372:[function(require,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 ReactNodeTypes = require('./ReactNodeTypes');

    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;

    },{"./ReactNodeTypes":329}],373:[function(require,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;

    },{}],374:[function(require,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;

    },{}],375:[function(require,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;

    },{}],376:[function(require,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 ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');

    var contentKey = null;

    /**
     * Gets the key used to access text content on a DOM node.
     *
     * @return {?string} Key used to access text content.
     * @internal
     */
    function getTextContentAccessor() {
      if (!contentKey && ExecutionEnvironment.canUseDOM) {
        // 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;

    },{"fbjs/lib/ExecutionEnvironment":390}],377:[function(require,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 ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');

    /**
     * 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;

    },{"fbjs/lib/ExecutionEnvironment":390}],378:[function(require,module,exports){
    (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 = require('./reactProdInvariant'),
        _assign = require('object-assign');

    var ReactCompositeComponent = require('./ReactCompositeComponent');
    var ReactEmptyComponent = require('./ReactEmptyComponent');
    var ReactHostComponent = require('./ReactHostComponent');

    var getNextDebugID = require('./getNextDebugID');
    var invariant = require('fbjs/lib/invariant');
    var warning = require('fbjs/lib/warning');

    // 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 {
        !false ? 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;

    }).call(this,require('_process'))
    },{"./ReactCompositeComponent":291,"./ReactEmptyComponent":314,"./ReactHostComponent":319,"./getNextDebugID":374,"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404,"fbjs/lib/warning":411,"object-assign":412}],379:[function(require,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 ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');

    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;

    },{"fbjs/lib/ExecutionEnvironment":390}],380:[function(require,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;

    },{}],381:[function(require,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 escapeTextContentForBrowser = require('./escapeTextContentForBrowser');

    /**
     * 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;

    },{"./escapeTextContentForBrowser":364}],382:[function(require,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;

    },{}],383:[function(require,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 ReactMount = require('./ReactMount');

    module.exports = ReactMount.renderSubtreeIntoContainer;

    },{"./ReactMount":327}],384:[function(require,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 ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');
    var DOMNamespaces = require('./DOMNamespaces');

    var WHITESPACE_TEST = /^[ \r\n\t\f]/;
    var NONVISIBLE_TEST = /<(!--|link|noscript|meta|script|style)[ \r\n\t\f\/>]/;

    var createMicrosoftUnsafeLocalFunction = require('./createMicrosoftUnsafeLocalFunction');

    // 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;

    },{"./DOMNamespaces":272,"./createMicrosoftUnsafeLocalFunction":362,"fbjs/lib/ExecutionEnvironment":390}],385:[function(require,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 ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');
    var escapeTextContentForBrowser = require('./escapeTextContentForBrowser');
    var setInnerHTML = require('./setInnerHTML');

    /**
     * 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;

    },{"./escapeTextContentForBrowser":364,"./setInnerHTML":384,"fbjs/lib/ExecutionEnvironment":390}],386:[function(require,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;

    },{}],387:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var ReactCurrentOwner = require('react/lib/ReactCurrentOwner');
    var REACT_ELEMENT_TYPE = require('./ReactElementSymbol');

    var getIteratorFn = require('./getIteratorFn');
    var invariant = require('fbjs/lib/invariant');
    var KeyEscapeUtils = require('./KeyEscapeUtils');
    var warning = require('fbjs/lib/warning');

    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);
          !false ? 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;

    }).call(this,require('_process'))
    },{"./KeyEscapeUtils":284,"./ReactElementSymbol":313,"./getIteratorFn":373,"./reactProdInvariant":382,"_process":728,"fbjs/lib/invariant":404,"fbjs/lib/warning":411,"react/lib/ReactCurrentOwner":593}],388:[function(require,module,exports){
    (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 = require('object-assign');

    var emptyFunction = require('fbjs/lib/emptyFunction');
    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"_process":728,"fbjs/lib/emptyFunction":396,"fbjs/lib/warning":411,"object-assign":412}],389:[function(require,module,exports){
    (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 = require('./emptyFunction');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./emptyFunction":396,"_process":728}],390:[function(require,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;

    },{}],391:[function(require,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;

    },{}],392:[function(require,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';

    var camelize = require('./camelize');

    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;

    },{"./camelize":391}],393:[function(require,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.
     *
     *
     */

    var isTextNode = require('./isTextNode');

    /*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;

    },{"./isTextNode":406}],394:[function(require,module,exports){
    (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 = require('./invariant');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./invariant":404,"_process":728}],395:[function(require,module,exports){
    (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 = require('./ExecutionEnvironment');

    var createArrayFromMixed = require('./createArrayFromMixed');
    var getMarkupWrap = require('./getMarkupWrap');
    var invariant = require('./invariant');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./ExecutionEnvironment":390,"./createArrayFromMixed":394,"./getMarkupWrap":400,"./invariant":404,"_process":728}],396:[function(require,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;

    },{}],397:[function(require,module,exports){
    (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;

    }).call(this,require('_process'))
    },{"_process":728}],398:[function(require,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;

    },{}],399:[function(require,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;

    },{}],400:[function(require,module,exports){
    (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 = require('./ExecutionEnvironment');

    var invariant = require('./invariant');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./ExecutionEnvironment":390,"./invariant":404,"_process":728}],401:[function(require,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;

    },{}],402:[function(require,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;

    },{}],403:[function(require,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';

    var hyphenate = require('./hyphenate');

    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;

    },{"./hyphenate":402}],404:[function(require,module,exports){
    (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.
     */

    var validateFormat = function validateFormat(format) {};

    if (process.env.NODE_ENV !== 'production') {
      validateFormat = function validateFormat(format) {
        if (format === undefined) {
          throw new Error('invariant requires an error message argument');
        }
      };
    }

    function invariant(condition, format, a, b, c, d, e, f) {
      validateFormat(format);

      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;

    }).call(this,require('_process'))
    },{"_process":728}],405:[function(require,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;

    },{}],406:[function(require,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 isNode = require('./isNode');

    /**
     * @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;

    },{"./isNode":405}],407:[function(require,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;

    },{}],408:[function(require,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';

    var ExecutionEnvironment = require('./ExecutionEnvironment');

    var performance;

    if (ExecutionEnvironment.canUseDOM) {
      performance = window.performance || window.msPerformance || window.webkitPerformance;
    }

    module.exports = performance || {};

    },{"./ExecutionEnvironment":390}],409:[function(require,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 performance = require('./performance');

    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;

    },{"./performance":408}],410:[function(require,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;

    },{}],411:[function(require,module,exports){
    (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 = require('./emptyFunction');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./emptyFunction":396,"_process":728}],412:[function(require,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;
    };

    },{}],413:[function(require,module,exports){
    var React = require('react');
    var D = React.DOM;

    var Leaf = require('./lib/leaf');
    var leaf = React.createFactory(Leaf);
    var SearchBar = require('./lib/search-bar');
    var searchBar = React.createFactory(SearchBar);

    var filterer = require('./lib/filterer');
    var isEmpty = require('./lib/is-empty');
    var lens = require('./lib/lens');
    var noop = require('./lib/noop');

    module.exports = React.createClass({displayName: "exports",
        propTypes: {
            data: React.PropTypes.any.isRequired,
            // For now it expects a factory function, not element.
            search: React.PropTypes.oneOfType([
                React.PropTypes.func,
                React.PropTypes.bool
            ]),
            onClick: React.PropTypes.func,
            validateQuery: React.PropTypes.func,
            isExpanded: React.PropTypes.func,
            filterOptions: React.PropTypes.object,
            query: React.PropTypes.string
        },

        getDefaultProps: function() {
            return {
                data: null,
                search: searchBar,
                className: '',
                id: 'json-' + Date.now(),
                onClick: noop,
                filterOptions: {},
                validateQuery: function(query) {
                    return query.length >= 2;
                },
                /**
                 * Decide whether the leaf node at given `keypath` should be
                 * expanded initially.
                 * @param  {String} keypath
                 * @param  {Any} value
                 * @return {Boolean}
                 */
                isExpanded: function(keypath, value) {
                    return false;
                }
            };
        },
        getInitialState: function() {
            return {
                query: this.props.query || ''
            };
        },
        render: function() {
            var p = this.props;
            var s = this.state;

            var isQueryValid = (
                s.query !== '' &&
                p.validateQuery(s.query)
            );

            var data = (
                isQueryValid ?
                    s.filterer(s.query) :
                    p.data
            );

            var isNotFound = (
                isQueryValid &&
                isEmpty(data)
            );

            return D.div({ className: 'json-inspector ' + p.className },
                this.renderToolbar(),
                (
                    isNotFound ?
                        D.div({ className: 'json-inspector__not-found' }, 'Nothing found') :
                        leaf({
                            data: data,
                            onClick: p.onClick,
                            id: p.id,
                            getOriginal: this.getOriginal,
                            query: (
                                isQueryValid ?
                                    s.query :
                                    null
                            ),
                            label: 'root',
                            root: true,
                            isExpanded: p.isExpanded,
                            interactiveLabel: p.interactiveLabel
                        })
                )
            );
        },
        renderToolbar: function() {
            var search = this.props.search;

            if (search) {
                return D.div({ className: 'json-inspector__toolbar' },
                    search({
                        onChange: this.search,
                        data: this.props.data,
                        query: this.state.query
                    })
                );
            }
        },
        search: function(query) {
            this.setState({
                query: query
            });
        },
        componentWillMount: function() {
            this.createFilterer(this.props.data, this.props.filterOptions);
        },
        componentWillReceiveProps: function(p) {
            this.createFilterer(p.data, p.filterOptions);

            var isReceivingNewQuery = (
                typeof p.query === 'string' &&
                p.query !== this.state.query
            );

            if (isReceivingNewQuery) {
                this.setState({
                    query: p.query
                });
            }
        },
        shouldComponentUpdate: function (p, s) {
            return (
                p.query !== this.props.query ||
                s.query !== this.state.query ||
                p.data !== this.props.data ||
                p.onClick !== this.props.onClick
            );
        },
        createFilterer: function(data, options) {
            this.setState({
                filterer: filterer(data, options)
            });
        },
        getOriginal: function(path) {
            return lens(this.props.data, path);
        }
    });

    },{"./lib/filterer":414,"./lib/is-empty":416,"./lib/leaf":418,"./lib/lens":419,"./lib/noop":420,"./lib/search-bar":421,"react":618}],414:[function(require,module,exports){
    var assign = require('object-assign');
    var keys = Object.keys;

    var isPrimitive = require('./is-primitive');
    var isEmpty = require('./is-empty');

    module.exports = function(data, options) {
        options || (options = {});
        var cache = {};

        return function(query) {
            var subquery;

            if (!cache[query]) {
                for (var i = query.length - 1; i > 0; i -= 1) {
                    subquery = query.substr(0, i);

                    if (cache[subquery]) {
                        cache[query] = find(cache[subquery], query, options);
                        break;
                    }
                }
            }

            if (!cache[query]) {
                cache[query] = find(data, query, options);
            }

            return cache[query];
        };
    };

    function find(data, query, options) {
        return keys(data).reduce(function(acc, key) {
            var value = data[key];
            var matches;

            if (isPrimitive(value)) {
                if (contains(query, key, options) || contains(query, value, options)) {
                    acc[key] = value;
                }
            } else {
                if (contains(query, key, options)) {
                    acc[key] = value;
                } else {
                    matches = find(value, query, options);

                    if (!isEmpty(matches)) {
                        assign(acc, pair(key, matches));
                    }
                }
            }

            return acc;
        }, {});
    }

    function contains(query, string, options) {
        if (string) {
            var haystack = String(string);
            var needle = query;

            if (options.ignoreCase) {
                haystack = haystack.toLowerCase();
                needle = needle.toLowerCase();
            }

            return haystack.indexOf(needle) !== -1;
        }
    }

    function pair(key, value) {
        var p = {};
        p[key] = value;
        return p;
    }

    },{"./is-empty":416,"./is-primitive":417,"object-assign":427}],415:[function(require,module,exports){
    var React = require('react');
    var span = React.DOM.span;

    module.exports = React.createClass({displayName: "exports",
        getDefaultProps: function() {
            return {
                string: '',
                highlight: ''
            };
        },
        shouldComponentUpdate: function(p) {
            return p.highlight !== this.props.highlight;
        },
        render: function() {
            var p = this.props;

            if (!p.highlight || p.string.indexOf(p.highlight) === -1) {
                return span(null, p.string);
            }

            return span(null,
                p.string.split(p.highlight).map(function(part, index) {
                    return span({ key: index },
                        index > 0 ?
                            span({ className: 'json-inspector__hl' }, p.highlight) :
                            null,
                        part);
                }));
        }
    });

    },{"react":618}],416:[function(require,module,exports){
    module.exports = function(object) {
        return Object.keys(object).length === 0;
    };

    },{}],417:[function(require,module,exports){
    var type = require('./type');

    function isPrimitive(value) {
        var t = type(value);
        return t !== 'Object' && t !== 'Array';
    }

    module.exports = isPrimitive;

    },{"./type":422}],418:[function(require,module,exports){
    var React = require('react');
    var D = React.DOM;

    var md5omatic = require('md5-o-matic');

    var uid = require('./uid');
    var type = require('./type');
    var isPrimitive = require('./is-primitive');

    var Highlighter = require('./highlighter');
    var highlighter = React.createFactory(Highlighter);

    var PATH_PREFIX = '.root.';

    var Leaf = React.createClass({displayName: "Leaf",
        getInitialState: function() {
            return {
                expanded: this._isInitiallyExpanded(this.props)
            };
        },
        getDefaultProps: function() {
            return {
                root: false,
                prefix: ''
            };
        },
        render: function() {
            var id = 'id_' + uid();
            var p = this.props;

            var d = {
                path: this.keypath(),
                key: p.label.toString(),
                value: p.data
            };

            var onLabelClick = this._onClick.bind(this, d);

            return D.div({ className: this.getClassName(), id: 'leaf-' + this._rootPath() },
                D.input({ className: 'json-inspector__radio', type: 'radio', name: p.id, id: id, tabIndex: -1 }),
                D.label({ className: 'json-inspector__line', htmlFor: id, onClick: onLabelClick },
                    D.div({ className: 'json-inspector__flatpath' },
                        d.path),
                    D.span({ className: 'json-inspector__key' },
                        this.format(d.key),
                        ':',
                        this.renderInteractiveLabel(d.key, true)),
                    this.renderTitle(),
                    this.renderShowOriginalButton()),
                this.renderChildren());
        },
        renderTitle: function() {
            var data = this.data();
            var t = type(data);

            switch (t) {
                case 'Array':
                    return D.span({ className: 'json-inspector__value json-inspector__value_helper' },
                        '[] ' + items(data.length));
                case 'Object':
                    return D.span({ className: 'json-inspector__value json-inspector__value_helper' },
                        '{} ' + items(Object.keys(data).length));
                default:
                    return D.span({ className: 'json-inspector__value json-inspector__value_' + t.toLowerCase() },
                        this.format(String(data)),
                        this.renderInteractiveLabel(data, false));
            }
        },
        renderChildren: function() {
            var p = this.props;
            var childPrefix = this._rootPath();
            var data = this.data();

            if (this.state.expanded && !isPrimitive(data)) {
                return Object.keys(data).map(function(key) {
                    var value = data[key];

                    return leaf({
                        data: value,
                        label: key,
                        prefix: childPrefix,
                        onClick: p.onClick,
                        id: p.id,
                        query: p.query,
                        getOriginal: this.state.original ? null : p.getOriginal,
                        key: getLeafKey(key, value),
                        isExpanded: p.isExpanded,
                        interactiveLabel: p.interactiveLabel
                    });
                }, this);
            }

            return null;
        },
        renderShowOriginalButton: function() {
            var p = this.props;

            if (isPrimitive(p.data) || this.state.original || !p.getOriginal || !p.query || contains(this.keypath(), p.query)) {
                return null;
            }

            return D.span({
                className: 'json-inspector__show-original',
                onClick: this._onShowOriginalClick
            });
        },
        renderInteractiveLabel: function(originalValue, isKey) {
            if (typeof this.props.interactiveLabel === 'function') {
                return this.props.interactiveLabel({
                    // The distinction between `value` and `originalValue` is
                    // provided to have backwards compatibility.
                    value: String(originalValue),
                    originalValue: originalValue,
                    isKey: isKey,
                    keypath: this.keypath()
                });
            }

            return null;
        },
        componentWillReceiveProps: function(p) {
            if (p.query) {
                this.setState({
                    expanded: !contains(p.label, p.query)
                });
            }

            // Restore original expansion state when switching from search mode
            // to full browse mode.
            if (this.props.query && !p.query) {
                this.setState({
                    expanded: this._isInitiallyExpanded(p)
                });
            }
        },
        _rootPath: function() {
            return this.props.prefix + '.' + this.props.label;
        },
        keypath: function() {
            return this._rootPath().substr(PATH_PREFIX.length);
        },
        data: function() {
            return this.state.original || this.props.data;
        },
        format: function(string) {
            return highlighter({
                string: string,
                highlight: this.props.query
            });
        },
        getClassName: function() {
            var cn = 'json-inspector__leaf';

            if (this.props.root) {
                cn += ' json-inspector__leaf_root';
            }

            if (this.state.expanded) {
                cn += ' json-inspector__leaf_expanded';
            }

            if (!isPrimitive(this.props.data)) {
                cn += ' json-inspector__leaf_composite';
            }

            return cn;
        },
        toggle: function() {
            this.setState({
                expanded: !this.state.expanded
            });
        },
        _onClick: function(data, e) {
            this.toggle();
            this.props.onClick(data);

            e.stopPropagation();
        },
        _onShowOriginalClick: function(e) {
            this.setState({
                original: this.props.getOriginal(this.keypath())
            });

            e.stopPropagation();
        },
        _isInitiallyExpanded: function(p) {
            var keypath = this.keypath();

            if (p.root) {
                return true;
            }

            if (!p.query) {
                return p.isExpanded(keypath, p.data);
            } else {
                // When a search query is specified, first check if the keypath
                // contains the search query: if it does, then the current leaf
                // is itself a search result and there is no need to expand further.
                //
                // Having a `getOriginal` function passed signalizes that current
                // leaf only displays a subset of data, thus should be rendered
                // expanded to reveal the children that is being searched for.
                return !contains(keypath, p.query) && (typeof p.getOriginal === 'function');
            }
        }
    });

    // FIXME: There should be a better way to call a component factory from inside
    // component definition.
    var leaf = React.createFactory(Leaf);

    function items(count) {
        return count + (count === 1 ? ' item' : ' items');
    }

    function getLeafKey(key, value) {
        if (isPrimitive(value)) {
            // TODO: Sanitize `value` better.
            var hash = md5omatic(String(value));
            return key + ':' + hash;
        } else {
            return key + '[' + type(value) + ']';
        }
    }

    function contains(string, substring) {
        return string.indexOf(substring) !== -1;
    }

    module.exports = Leaf;

    },{"./highlighter":415,"./is-primitive":417,"./type":422,"./uid":423,"md5-o-matic":426,"react":618}],419:[function(require,module,exports){
    var type = require('./type');

    var PATH_DELIMITER = '.';

    function lens(data, path) {
        var p = path.split(PATH_DELIMITER);
        var segment = p.shift();

        if (!segment) {
            return data;
        }

        var t = type(data);

        if (t === 'Array' && data[integer(segment)]) {
            return lens(data[integer(segment)], p.join(PATH_DELIMITER));
        } else if (t === 'Object' && data[segment]) {
            return lens(data[segment], p.join(PATH_DELIMITER));
        }
    }

    function integer(string) {
        return parseInt(string, 10);
    }

    module.exports = lens;

    },{"./type":422}],420:[function(require,module,exports){
    module.exports = function() {};

    },{}],421:[function(require,module,exports){
    var debounce = require('debounce');
    var React = require('react');
    var input = React.DOM.input;

    var noop = require('./noop');

    module.exports = React.createClass({displayName: "exports",
        getDefaultProps: function() {
            return {
                onChange: noop
            };
        },
        render: function() {
            return input({
                className: 'json-inspector__search',
                type: 'search',
                placeholder: 'Search',
                value: this.props.query,
                onChange: this.onChange
            });
        },
        onChange: function(e) {
            this.props.onChange(e.target.value);
        }
    });

    },{"./noop":420,"debounce":424,"react":618}],422:[function(require,module,exports){
    module.exports = function(value) {
        return Object.prototype.toString.call(value).slice(8, -1);
    };

    },{}],423:[function(require,module,exports){
    var id = Math.ceil(Math.random() * 10);

    module.exports = function() {
        return ++id;
    };

    },{}],424:[function(require,module,exports){

    /**
     * Module dependencies.
     */

    var now = require('date-now');

    /**
     * Returns a function, that, as long as it continues to be invoked, will not
     * be triggered. The function will be called after it stops being called for
     * N milliseconds. If `immediate` is passed, trigger the function on the
     * leading edge, instead of the trailing.
     *
     * @source underscore.js
     * @see http://unscriptable.com/2009/03/20/debouncing-javascript-methods/
     * @param {Function} function to wrap
     * @param {Number} timeout in ms (`100`)
     * @param {Boolean} whether to execute at the beginning (`false`)
     * @api public
     */

    module.exports = function debounce(func, wait, immediate){
      var timeout, args, context, timestamp, result;
      if (null == wait) wait = 100;

      function later() {
        var last = now() - timestamp;

        if (last < wait && last > 0) {
          timeout = setTimeout(later, wait - last);
        } else {
          timeout = null;
          if (!immediate) {
            result = func.apply(context, args);
            if (!timeout) context = args = null;
          }
        }
      };

      return function debounced() {
        context = this;
        args = arguments;
        timestamp = now();
        var callNow = immediate && !timeout;
        if (!timeout) timeout = setTimeout(later, wait);
        if (callNow) {
          result = func.apply(context, args);
          context = args = null;
        }

        return result;
      };
    };

    },{"date-now":425}],425:[function(require,module,exports){
    module.exports = Date.now || now

    function now() {
        return new Date().getTime()
    }

    },{}],426:[function(require,module,exports){
    "use strict";

    /**
     * Expose `md5omatic(str)`.
     */

    module.exports = md5omatic;

    /**
     * Hash any string using message digest.
     *
     * @param {String} str
     * @return {String}
     * @api public
     */

    function md5omatic(str) {
        var x = str2blks_MD5(str);
        var a =  1732584193;
        var b = -271733879;
        var c = -1732584194;
        var d =  271733878;

        for(var i=0; i<x.length; i += 16)
        {
            var olda = a;
            var oldb = b;
            var oldc = c;
            var oldd = d;

            a = ff(a, b, c, d, x[i+ 0], 7 , -680876936);
            d = ff(d, a, b, c, x[i+ 1], 12, -389564586);
            c = ff(c, d, a, b, x[i+ 2], 17,  606105819);
            b = ff(b, c, d, a, x[i+ 3], 22, -1044525330);
            a = ff(a, b, c, d, x[i+ 4], 7 , -176418897);
            d = ff(d, a, b, c, x[i+ 5], 12,  1200080426);
            c = ff(c, d, a, b, x[i+ 6], 17, -1473231341);
            b = ff(b, c, d, a, x[i+ 7], 22, -45705983);
            a = ff(a, b, c, d, x[i+ 8], 7 ,  1770035416);
            d = ff(d, a, b, c, x[i+ 9], 12, -1958414417);
            c = ff(c, d, a, b, x[i+10], 17, -42063);
            b = ff(b, c, d, a, x[i+11], 22, -1990404162);
            a = ff(a, b, c, d, x[i+12], 7 ,  1804603682);
            d = ff(d, a, b, c, x[i+13], 12, -40341101);
            c = ff(c, d, a, b, x[i+14], 17, -1502002290);
            b = ff(b, c, d, a, x[i+15], 22,  1236535329);
            a = gg(a, b, c, d, x[i+ 1], 5 , -165796510);
            d = gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
            c = gg(c, d, a, b, x[i+11], 14,  643717713);
            b = gg(b, c, d, a, x[i+ 0], 20, -373897302);
            a = gg(a, b, c, d, x[i+ 5], 5 , -701558691);
            d = gg(d, a, b, c, x[i+10], 9 ,  38016083);
            c = gg(c, d, a, b, x[i+15], 14, -660478335);
            b = gg(b, c, d, a, x[i+ 4], 20, -405537848);
            a = gg(a, b, c, d, x[i+ 9], 5 ,  568446438);
            d = gg(d, a, b, c, x[i+14], 9 , -1019803690);
            c = gg(c, d, a, b, x[i+ 3], 14, -187363961);
            b = gg(b, c, d, a, x[i+ 8], 20,  1163531501);
            a = gg(a, b, c, d, x[i+13], 5 , -1444681467);
            d = gg(d, a, b, c, x[i+ 2], 9 , -51403784);
            c = gg(c, d, a, b, x[i+ 7], 14,  1735328473);
            b = gg(b, c, d, a, x[i+12], 20, -1926607734);
            a = hh(a, b, c, d, x[i+ 5], 4 , -378558);
            d = hh(d, a, b, c, x[i+ 8], 11, -2022574463);
            c = hh(c, d, a, b, x[i+11], 16,  1839030562);
            b = hh(b, c, d, a, x[i+14], 23, -35309556);
            a = hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
            d = hh(d, a, b, c, x[i+ 4], 11,  1272893353);
            c = hh(c, d, a, b, x[i+ 7], 16, -155497632);
            b = hh(b, c, d, a, x[i+10], 23, -1094730640);
            a = hh(a, b, c, d, x[i+13], 4 ,  681279174);
            d = hh(d, a, b, c, x[i+ 0], 11, -358537222);
            c = hh(c, d, a, b, x[i+ 3], 16, -722521979);
            b = hh(b, c, d, a, x[i+ 6], 23,  76029189);
            a = hh(a, b, c, d, x[i+ 9], 4 , -640364487);
            d = hh(d, a, b, c, x[i+12], 11, -421815835);
            c = hh(c, d, a, b, x[i+15], 16,  530742520);
            b = hh(b, c, d, a, x[i+ 2], 23, -995338651);
            a = ii(a, b, c, d, x[i+ 0], 6 , -198630844);
            d = ii(d, a, b, c, x[i+ 7], 10,  1126891415);
            c = ii(c, d, a, b, x[i+14], 15, -1416354905);
            b = ii(b, c, d, a, x[i+ 5], 21, -57434055);
            a = ii(a, b, c, d, x[i+12], 6 ,  1700485571);
            d = ii(d, a, b, c, x[i+ 3], 10, -1894986606);
            c = ii(c, d, a, b, x[i+10], 15, -1051523);
            b = ii(b, c, d, a, x[i+ 1], 21, -2054922799);
            a = ii(a, b, c, d, x[i+ 8], 6 ,  1873313359);
            d = ii(d, a, b, c, x[i+15], 10, -30611744);
            c = ii(c, d, a, b, x[i+ 6], 15, -1560198380);
            b = ii(b, c, d, a, x[i+13], 21,  1309151649);
            a = ii(a, b, c, d, x[i+ 4], 6 , -145523070);
            d = ii(d, a, b, c, x[i+11], 10, -1120210379);
            c = ii(c, d, a, b, x[i+ 2], 15,  718787259);
            b = ii(b, c, d, a, x[i+ 9], 21, -343485551);

            a = addme(a, olda);
            b = addme(b, oldb);
            c = addme(c, oldc);
            d = addme(d, oldd);
        }

        return rhex(a) + rhex(b) + rhex(c) + rhex(d);
    };

    var hex_chr = "0123456789abcdef";

    function bitOR(a, b)
    {
        var lsb = (a & 0x1) | (b & 0x1);
        var msb31 = (a >>> 1) | (b >>> 1);

        return (msb31 << 1) | lsb;
    }

    function bitXOR(a, b)
    {
        var lsb = (a & 0x1) ^ (b & 0x1);
        var msb31 = (a >>> 1) ^ (b >>> 1);

        return (msb31 << 1) | lsb;
    }

    function bitAND(a, b)
    {
        var lsb = (a & 0x1) & (b & 0x1);
        var msb31 = (a >>> 1) & (b >>> 1);

        return (msb31 << 1) | lsb;
    }

    function addme(x, y)
    {
        var lsw = (x & 0xFFFF)+(y & 0xFFFF);
        var msw = (x >> 16)+(y >> 16)+(lsw >> 16);

        return (msw << 16) | (lsw & 0xFFFF);
    }

    function rhex(num)
    {
        var str = "";
        var j;

        for(j=0; j<=3; j++)
            str += hex_chr.charAt((num >> (j * 8 + 4)) & 0x0F) + hex_chr.charAt((num >> (j * 8)) & 0x0F);

        return str;
    }

    function str2blks_MD5(str)
    {
        var nblk = ((str.length + 8) >> 6) + 1;
        var blks = new Array(nblk * 16);
        var i;

        for(i=0; i<nblk * 16; i++)
            blks[i] = 0;

        for(i=0; i<str.length; i++)
            blks[i >> 2] |= str.charCodeAt(i) << (((str.length * 8 + i) % 4) * 8);

        blks[i >> 2] |= 0x80 << (((str.length * 8 + i) % 4) * 8);

        var l = str.length * 8;
        blks[nblk * 16 - 2] = (l & 0xFF);
        blks[nblk * 16 - 2] |= ((l >>> 8) & 0xFF) << 8;
        blks[nblk * 16 - 2] |= ((l >>> 16) & 0xFF) << 16;
        blks[nblk * 16 - 2] |= ((l >>> 24) & 0xFF) << 24;

        return blks;
    }

    function rol(num, cnt)
    {
        return (num << cnt) | (num >>> (32 - cnt));
    }

    function cmn(q, a, b, x, s, t)
    {
        return addme(rol((addme(addme(a, q), addme(x, t))), s), b);
    }

    function ff(a, b, c, d, x, s, t)
    {
        return cmn(bitOR(bitAND(b, c), bitAND((~b), d)), a, b, x, s, t);
    }

    function gg(a, b, c, d, x, s, t)
    {
        return cmn(bitOR(bitAND(b, d), bitAND(c, (~d))), a, b, x, s, t);
    }

    function hh(a, b, c, d, x, s, t)
    {
        return cmn(bitXOR(bitXOR(b, c), d), a, b, x, s, t);
    }

    function ii(a, b, c, d, x, s, t)
    {
        return cmn(bitXOR(c, bitOR(b, (~d))), a, b, x, s, t);
    }

    },{}],427:[function(require,module,exports){
    'use strict';

    function ToObject(val) {
    	if (val == null) {
    		throw new TypeError('Object.assign cannot be called with null or undefined');
    	}

    	return Object(val);
    }

    module.exports = Object.assign || function (target, source) {
    	var from;
    	var keys;
    	var to = ToObject(target);

    	for (var s = 1; s < arguments.length; s++) {
    		from = arguments[s];
    		keys = Object.keys(Object(from));

    		for (var i = 0; i < keys.length; i++) {
    			to[keys[i]] = from[keys[i]];
    		}
    	}

    	return to;
    };

    },{}],428:[function(require,module,exports){
    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });

    var _omit2 = require("lodash/omit");

    var _omit3 = _interopRequireDefault(_omit2);

    var _includes2 = require("lodash/includes");

    var _includes3 = _interopRequireDefault(_includes2);

    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 = require("react");

    var _react2 = _interopRequireDefault(_react);

    var _reactAddonsUpdate = require("react-addons-update");

    var _reactAddonsUpdate2 = _interopRequireDefault(_reactAddonsUpdate);

    var _ToastMessage = require("./ToastMessage");

    var _ToastMessage2 = _interopRequireDefault(_ToastMessage);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return 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; }

    var ToastContainer = function (_Component) {
      _inherits(ToastContainer, _Component);

      function ToastContainer() {
        var _ref;

        var _temp, _this, _ret;

        _classCallCheck(this, ToastContainer);

        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = ToastContainer.__proto__ || Object.getPrototypeOf(ToastContainer)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
          toasts: [],
          toastId: 0,
          messageList: []
        }, _this._handle_toast_remove = _this._handle_toast_remove.bind(_this), _temp), _possibleConstructorReturn(_this, _ret);
      }

      _createClass(ToastContainer, [{
        key: "error",
        value: function error(message, title, optionsOverride) {
          this._notify(this.props.toastType.error, message, title, optionsOverride);
        }
      }, {
        key: "info",
        value: function info(message, title, optionsOverride) {
          this._notify(this.props.toastType.info, message, title, optionsOverride);
        }
      }, {
        key: "success",
        value: function success(message, title, optionsOverride) {
          this._notify(this.props.toastType.success, message, title, optionsOverride);
        }
      }, {
        key: "warning",
        value: function warning(message, title, optionsOverride) {
          this._notify(this.props.toastType.warning, message, title, optionsOverride);
        }
      }, {
        key: "clear",
        value: function clear() {
          var _this2 = this;

          Object.keys(this.refs).forEach(function (key) {
            _this2.refs[key].hideToast(false);
          });
        }
      }, {
        key: "_notify",
        value: function _notify(type, message, title) {
          var _this3 = this;

          var optionsOverride = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};

          if (this.props.preventDuplicates) {
            if ((0, _includes3.default)(this.state.messageList, message)) {
              return;
            }
          }
          var key = this.state.toastId++;
          var toastId = key;
          var newToast = (0, _reactAddonsUpdate2.default)(optionsOverride, {
            $merge: {
              type: type,
              title: title,
              message: message,
              toastId: toastId,
              key: key,
              ref: "toasts__" + key,
              handleOnClick: function handleOnClick(e) {
                if ("function" === typeof optionsOverride.handleOnClick) {
                  optionsOverride.handleOnClick();
                }
                return _this3._handle_toast_on_click(e);
              },
              handleRemove: this._handle_toast_remove
            }
          });
          var toastOperation = _defineProperty({}, "" + (this.props.newestOnTop ? "$unshift" : "$push"), [newToast]);

          var messageOperation = _defineProperty({}, "" + (this.props.newestOnTop ? "$unshift" : "$push"), [message]);

          var nextState = (0, _reactAddonsUpdate2.default)(this.state, {
            toasts: toastOperation,
            messageList: messageOperation
          });
          this.setState(nextState);
        }
      }, {
        key: "_handle_toast_on_click",
        value: function _handle_toast_on_click(event) {
          this.props.onClick(event);
          if (event.defaultPrevented) {
            return;
          }
          event.preventDefault();
          event.stopPropagation();
        }
      }, {
        key: "_handle_toast_remove",
        value: function _handle_toast_remove(toastId) {
          var _this4 = this;

          if (this.props.preventDuplicates) {
            this.state.previousMessage = "";
          }
          var operationName = "" + (this.props.newestOnTop ? "reduceRight" : "reduce");
          this.state.toasts[operationName](function (found, toast, index) {
            if (found || toast.toastId !== toastId) {
              return false;
            }
            _this4.setState((0, _reactAddonsUpdate2.default)(_this4.state, {
              toasts: { $splice: [[index, 1]] },
              messageList: { $splice: [[index, 1]] }
            }));
            return true;
          }, false);
        }
      }, {
        key: "render",
        value: function render() {
          var _this5 = this;

          var divProps = (0, _omit3.default)(this.props, ["toastType", "toastMessageFactory", "preventDuplicates", "newestOnTop"]);

          return _react2.default.createElement(
            "div",
            _extends({}, divProps, { "aria-live": "polite", role: "alert" }),
            this.state.toasts.map(function (toast) {
              return _this5.props.toastMessageFactory(toast);
            })
          );
        }
      }]);

      return ToastContainer;
    }(_react.Component);

    ToastContainer.propTypes = {
      toastType: _react.PropTypes.shape({
        error: _react.PropTypes.string,
        info: _react.PropTypes.string,
        success: _react.PropTypes.string,
        warning: _react.PropTypes.string
      }).isRequired,
      id: _react.PropTypes.string.isRequired,
      toastMessageFactory: _react.PropTypes.func.isRequired,
      preventDuplicates: _react.PropTypes.bool.isRequired,
      newestOnTop: _react.PropTypes.bool.isRequired,
      onClick: _react.PropTypes.func.isRequired
    };
    ToastContainer.defaultProps = {
      toastType: {
        error: "error",
        info: "info",
        success: "success",
        warning: "warning"
      },
      id: "toast-container",
      toastMessageFactory: _react2.default.createFactory(_ToastMessage2.default.animation),
      preventDuplicates: true,
      newestOnTop: true,
      onClick: function onClick() {}
    };
    exports.default = ToastContainer;

    },{"./ToastMessage":430,"lodash/includes":560,"lodash/omit":577,"react":618,"react-addons-update":585}],429:[function(require,module,exports){
    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });

    var _ReactTransitionEvents = require("react/lib/ReactTransitionEvents");

    var _ReactTransitionEvents2 = _interopRequireDefault(_ReactTransitionEvents);

    var _reactDom = require("react-dom");

    var _reactDom2 = _interopRequireDefault(_reactDom);

    var _elementClass = require("element-class");

    var _elementClass2 = _interopRequireDefault(_elementClass);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    var TICK = 17;
    var toString = Object.prototype.toString;
    exports.default = {
      getDefaultProps: function getDefaultProps() {
        return {
          transition: null, // some examples defined in index.scss (scale, fadeInOut, rotate)
          showAnimation: "animated bounceIn", // or other animations from animate.css
          hideAnimation: "animated bounceOut",
          timeOut: 5000,
          extendedTimeOut: 1000
        };
      },
      componentWillMount: function componentWillMount() {
        this.classNameQueue = [];
        this.isHiding = false;
        this.intervalId = null;
      },
      componentDidMount: function componentDidMount() {
        var _this = this;

        this._is_mounted = true;
        this._show();
        var node = _reactDom2.default.findDOMNode(this);

        var onHideComplete = function onHideComplete() {
          if (_this.isHiding) {
            _this._set_is_hiding(false);
            _ReactTransitionEvents2.default.removeEndEventListener(node, onHideComplete);
            _this._handle_remove();
          }
        };
        _ReactTransitionEvents2.default.addEndEventListener(node, onHideComplete);

        if (this.props.timeOut > 0) {
          this._set_interval_id(setTimeout(this.hideToast, this.props.timeOut));
        }
      },
      componentWillUnmount: function componentWillUnmount() {
        this._is_mounted = false;
        if (this.intervalId) {
          clearTimeout(this.intervalId);
        }
      },
      _set_transition: function _set_transition(hide) {
        var animationType = hide ? "leave" : "enter";
        var node = _reactDom2.default.findDOMNode(this);
        var className = this.props.transition + "-" + animationType;
        var activeClassName = className + "-active";

        var endListener = function endListener(e) {
          if (e && e.target !== node) {
            return;
          }

          var classList = (0, _elementClass2.default)(node);
          classList.remove(className);
          classList.remove(activeClassName);

          _ReactTransitionEvents2.default.removeEndEventListener(node, endListener);
        };

        _ReactTransitionEvents2.default.addEndEventListener(node, endListener);

        (0, _elementClass2.default)(node).add(className);

        // Need to do this to actually trigger a transition.
        this._queue_class(activeClassName);
      },
      _clear_transition: function _clear_transition(hide) {
        var node = _reactDom2.default.findDOMNode(this);
        var animationType = hide ? "leave" : "enter";
        var className = this.props.transition + "-" + animationType;
        var activeClassName = className + "-active";

        var classList = (0, _elementClass2.default)(node);
        classList.remove(className);
        classList.remove(activeClassName);
      },
      _set_animation: function _set_animation(hide) {
        var node = _reactDom2.default.findDOMNode(this);
        var animations = this._get_animation_classes(hide);
        var endListener = function endListener(e) {
          if (e && e.target !== node) {
            return;
          }

          animations.forEach(function (anim) {
            return (0, _elementClass2.default)(node).remove(anim);
          });

          _ReactTransitionEvents2.default.removeEndEventListener(node, endListener);
        };

        _ReactTransitionEvents2.default.addEndEventListener(node, endListener);

        animations.forEach(function (anim) {
          return (0, _elementClass2.default)(node).add(anim);
        });
      },
      _get_animation_classes: function _get_animation_classes(hide) {
        var animations = hide ? this.props.hideAnimation : this.props.showAnimation;
        if ("[object Array]" === toString.call(animations)) {
          return animations;
        } else if ("string" === typeof animations) {
          return animations.split(" ");
        }
      },
      _clear_animation: function _clear_animation(hide) {
        var node = _reactDom2.default.findDOMNode(this);
        var animations = this._get_animation_classes(hide);
        animations.forEach(function (animation) {
          return (0, _elementClass2.default)(node).remove(animation);
        });
      },
      _queue_class: function _queue_class(className) {
        this.classNameQueue.push(className);

        if (!this.timeout) {
          this.timeout = setTimeout(this._flush_class_name_queue, TICK);
        }
      },
      _flush_class_name_queue: function _flush_class_name_queue() {
        var _this2 = this;

        if (this._is_mounted) {
          (function () {
            var node = _reactDom2.default.findDOMNode(_this2);
            _this2.classNameQueue.forEach(function (className) {
              return (0, _elementClass2.default)(node).add(className);
            });
          })();
        }
        this.classNameQueue.length = 0;
        this.timeout = null;
      },
      _show: function _show() {
        if (this.props.transition) {
          this._set_transition();
        } else if (this.props.showAnimation) {
          this._set_animation();
        }
      },
      handleMouseEnter: function handleMouseEnter() {
        clearTimeout(this.intervalId);
        this._set_interval_id(null);
        if (this.isHiding) {
          this._set_is_hiding(false);

          if (this.props.hideAnimation) {
            this._clear_animation(true);
          } else if (this.props.transition) {
            this._clear_transition(true);
          }
        }
      },
      handleMouseLeave: function handleMouseLeave() {
        if (!this.isHiding && (this.props.timeOut > 0 || this.props.extendedTimeOut > 0)) {
          this._set_interval_id(setTimeout(this.hideToast, this.props.extendedTimeOut));
        }
      },
      hideToast: function hideToast(override) {
        if (this.isHiding || this.intervalId === null && !override) {
          return;
        }

        this._set_is_hiding(true);
        if (this.props.transition) {
          this._set_transition(true);
        } else if (this.props.hideAnimation) {
          this._set_animation(true);
        } else {
          this._handle_remove();
        }
      },
      _set_interval_id: function _set_interval_id(intervalId) {
        this.intervalId = intervalId;
      },
      _set_is_hiding: function _set_is_hiding(isHiding) {
        this.isHiding = isHiding;
      }
    };

    },{"element-class":434,"react-dom":262,"react/lib/ReactTransitionEvents":603}],430:[function(require,module,exports){
    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.jQuery = exports.animation = undefined;

    var _react = require("react");

    var _react2 = _interopRequireDefault(_react);

    var _reactAddonsUpdate = require("react-addons-update");

    var _reactAddonsUpdate2 = _interopRequireDefault(_reactAddonsUpdate);

    var _classnames = require("classnames");

    var _classnames2 = _interopRequireDefault(_classnames);

    var _animationMixin = require("./animationMixin");

    var _animationMixin2 = _interopRequireDefault(_animationMixin);

    var _jQueryMixin = require("./jQueryMixin");

    var _jQueryMixin2 = _interopRequireDefault(_jQueryMixin);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    function noop() {}

    var ToastMessageSpec = {
      displayName: "ToastMessage",

      getDefaultProps: function getDefaultProps() {
        var iconClassNames = {
          error: "toast-error",
          info: "toast-info",
          success: "toast-success",
          warning: "toast-warning"
        };

        return {
          className: "toast",
          iconClassNames: iconClassNames,
          titleClassName: "toast-title",
          messageClassName: "toast-message",
          tapToDismiss: true,
          closeButton: false
        };
      },
      handleOnClick: function handleOnClick(event) {
        this.props.handleOnClick(event);
        if (this.props.tapToDismiss) {
          this.hideToast(true);
        }
      },
      _handle_close_button_click: function _handle_close_button_click(event) {
        event.stopPropagation();
        this.hideToast(true);
      },
      _handle_remove: function _handle_remove() {
        this.props.handleRemove(this.props.toastId);
      },
      _render_close_button: function _render_close_button() {
        return this.props.closeButton ? _react2.default.createElement("button", {
          className: "toast-close-button", role: "button",
          onClick: this._handle_close_button_click,
          dangerouslySetInnerHTML: { __html: "&times;" }
        }) : false;
      },
      _render_title_element: function _render_title_element() {
        return this.props.title ? _react2.default.createElement(
          "div",
          { className: this.props.titleClassName },
          this.props.title
        ) : false;
      },
      _render_message_element: function _render_message_element() {
        return this.props.message ? _react2.default.createElement(
          "div",
          { className: this.props.messageClassName },
          this.props.message
        ) : false;
      },
      render: function render() {
        var iconClassName = this.props.iconClassName || this.props.iconClassNames[this.props.type];

        return _react2.default.createElement(
          "div",
          {
            className: (0, _classnames2.default)(this.props.className, iconClassName),
            style: this.props.style,
            onClick: this.handleOnClick,
            onMouseEnter: this.handleMouseEnter,
            onMouseLeave: this.handleMouseLeave
          },
          this._render_close_button(),
          this._render_title_element(),
          this._render_message_element()
        );
      }
    };

    var animation = exports.animation = _react2.default.createClass((0, _reactAddonsUpdate2.default)(ToastMessageSpec, {
      displayName: { $set: "ToastMessage.animation" },
      mixins: { $set: [_animationMixin2.default] }
    }));

    var jQuery = exports.jQuery = _react2.default.createClass((0, _reactAddonsUpdate2.default)(ToastMessageSpec, {
      displayName: { $set: "ToastMessage.jQuery" },
      mixins: { $set: [_jQueryMixin2.default] }
    }));

    /*
     * assign default noop functions
     */
    ToastMessageSpec.handleMouseEnter = noop;
    ToastMessageSpec.handleMouseLeave = noop;
    ToastMessageSpec.hideToast = noop;

    var ToastMessage = _react2.default.createClass(ToastMessageSpec);

    ToastMessage.animation = animation;
    ToastMessage.jQuery = jQuery;

    exports.default = ToastMessage;

    },{"./animationMixin":429,"./jQueryMixin":431,"classnames":433,"react":618,"react-addons-update":585}],431:[function(require,module,exports){
    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });

    var _reactDom = require("react-dom");

    var _reactDom2 = _interopRequireDefault(_reactDom);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    function call_show_method($node, props) {
      $node[props.showMethod]({
        duration: props.showDuration,
        easing: props.showEasing
      });
    }

    exports.default = {
      getDefaultProps: function getDefaultProps() {
        return {
          style: {
            display: "none" },
          showMethod: "fadeIn", // slideDown, and show are built into jQuery
          showDuration: 300,
          showEasing: "swing", // and linear are built into jQuery
          hideMethod: "fadeOut",
          hideDuration: 1000,
          hideEasing: "swing",
          //
          timeOut: 5000,
          extendedTimeOut: 1000
        };
      },
      getInitialState: function getInitialState() {
        return {
          intervalId: null,
          isHiding: false
        };
      },
      componentDidMount: function componentDidMount() {
        call_show_method(this._get_$_node(), this.props);
        if (this.props.timeOut > 0) {
          this._set_interval_id(setTimeout(this.hideToast, this.props.timeOut));
        }
      },
      handleMouseEnter: function handleMouseEnter() {
        clearTimeout(this.state.intervalId);
        this._set_interval_id(null);
        this._set_is_hiding(false);

        call_show_method(this._get_$_node().stop(true, true), this.props);
      },
      handleMouseLeave: function handleMouseLeave() {
        if (!this.state.isHiding && (this.props.timeOut > 0 || this.props.extendedTimeOut > 0)) {
          this._set_interval_id(setTimeout(this.hideToast, this.props.extendedTimeOut));
        }
      },
      hideToast: function hideToast(override) {
        if (this.state.isHiding || this.state.intervalId === null && !override) {
          return;
        }
        this.setState({ isHiding: true });

        this._get_$_node()[this.props.hideMethod]({
          duration: this.props.hideDuration,
          easing: this.props.hideEasing,
          complete: this._handle_remove
        });
      },
      _get_$_node: function _get_$_node() {
        /* eslint-disable no-undef */
        return jQuery(_reactDom2.default.findDOMNode(this));
        /* eslint-enable no-undef */
      },
      _set_interval_id: function _set_interval_id(intervalId) {
        this.setState({
          intervalId: intervalId
        });
      },
      _set_is_hiding: function _set_is_hiding(isHiding) {
        this.setState({
          isHiding: isHiding
        });
      }
    };

    },{"react-dom":262}],432:[function(require,module,exports){
    "use strict";

    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports.ToastMessage = exports.ToastContainer = undefined;

    var _ToastContainer = require("./ToastContainer");

    var _ToastContainer2 = _interopRequireDefault(_ToastContainer);

    var _ToastMessage = require("./ToastMessage");

    var _ToastMessage2 = _interopRequireDefault(_ToastMessage);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    exports.ToastContainer = _ToastContainer2.default;
    exports.ToastMessage = _ToastMessage2.default;

    },{"./ToastContainer":428,"./ToastMessage":430}],433:[function(require,module,exports){
    /*!
      Copyright (c) 2016 Jed Watson.
      Licensed under the MIT License (MIT), see
      http://jedwatson.github.io/classnames
    */
    /* global define */

    (function () {
    	'use strict';

    	var hasOwn = {}.hasOwnProperty;

    	function classNames () {
    		var classes = [];

    		for (var i = 0; i < arguments.length; i++) {
    			var arg = arguments[i];
    			if (!arg) continue;

    			var argType = typeof arg;

    			if (argType === 'string' || argType === 'number') {
    				classes.push(arg);
    			} else if (Array.isArray(arg)) {
    				classes.push(classNames.apply(null, arg));
    			} else if (argType === 'object') {
    				for (var key in arg) {
    					if (hasOwn.call(arg, key) && arg[key]) {
    						classes.push(key);
    					}
    				}
    			}
    		}

    		return classes.join(' ');
    	}

    	if (typeof module !== 'undefined' && module.exports) {
    		module.exports = classNames;
    	} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {
    		// register as 'classnames', consistent with npm package name
    		define('classnames', [], function () {
    			return classNames;
    		});
    	} else {
    		window.classNames = classNames;
    	}
    }());

    },{}],434:[function(require,module,exports){
    module.exports = function(opts) {
      return new ElementClass(opts)
    }

    function indexOf(arr, prop) {
      if (arr.indexOf) return arr.indexOf(prop)
      for (var i = 0, len = arr.length; i < len; i++)
        if (arr[i] === prop) return i
      return -1
    }

    function ElementClass(opts) {
      if (!(this instanceof ElementClass)) return new ElementClass(opts)
      var self = this
      if (!opts) opts = {}

      // similar doing instanceof HTMLElement but works in IE8
      if (opts.nodeType) opts = {el: opts}

      this.opts = opts
      this.el = opts.el || document.body
      if (typeof this.el !== 'object') this.el = document.querySelector(this.el)
    }

    ElementClass.prototype.add = function(className) {
      var el = this.el
      if (!el) return
      if (el.className === "") return el.className = className
      var classes = el.className.split(' ')
      if (indexOf(classes, className) > -1) return classes
      classes.push(className)
      el.className = classes.join(' ')
      return classes
    }

    ElementClass.prototype.remove = function(className) {
      var el = this.el
      if (!el) return
      if (el.className === "") return
      var classes = el.className.split(' ')
      var idx = indexOf(classes, className)
      if (idx > -1) classes.splice(idx, 1)
      el.className = classes.join(' ')
      return classes
    }

    ElementClass.prototype.has = function(className) {
      var el = this.el
      if (!el) return
      var classes = el.className.split(' ')
      return indexOf(classes, className) > -1
    }

    ElementClass.prototype.toggle = function(className) {
      var el = this.el
      if (!el) return
      if (this.has(className)) this.remove(className)
      else this.add(className)
    }

    },{}],435:[function(require,module,exports){
    var getNative = require('./_getNative'),
        root = require('./_root');

    /* Built-in method references that are verified to be native. */
    var DataView = getNative(root, 'DataView');

    module.exports = DataView;

    },{"./_getNative":502,"./_root":543}],436:[function(require,module,exports){
    var hashClear = require('./_hashClear'),
        hashDelete = require('./_hashDelete'),
        hashGet = require('./_hashGet'),
        hashHas = require('./_hashHas'),
        hashSet = require('./_hashSet');

    /**
     * Creates a hash object.
     *
     * @private
     * @constructor
     * @param {Array} [entries] The key-value pairs to cache.
     */
    function Hash(entries) {
      var index = -1,
          length = entries == null ? 0 : entries.length;

      this.clear();
      while (++index < length) {
        var entry = entries[index];
        this.set(entry[0], entry[1]);
      }
    }

    // Add methods to `Hash`.
    Hash.prototype.clear = hashClear;
    Hash.prototype['delete'] = hashDelete;
    Hash.prototype.get = hashGet;
    Hash.prototype.has = hashHas;
    Hash.prototype.set = hashSet;

    module.exports = Hash;

    },{"./_hashClear":509,"./_hashDelete":510,"./_hashGet":511,"./_hashHas":512,"./_hashSet":513}],437:[function(require,module,exports){
    var listCacheClear = require('./_listCacheClear'),
        listCacheDelete = require('./_listCacheDelete'),
        listCacheGet = require('./_listCacheGet'),
        listCacheHas = require('./_listCacheHas'),
        listCacheSet = require('./_listCacheSet');

    /**
     * Creates an list cache object.
     *
     * @private
     * @constructor
     * @param {Array} [entries] The key-value pairs to cache.
     */
    function ListCache(entries) {
      var index = -1,
          length = entries == null ? 0 : entries.length;

      this.clear();
      while (++index < length) {
        var entry = entries[index];
        this.set(entry[0], entry[1]);
      }
    }

    // Add methods to `ListCache`.
    ListCache.prototype.clear = listCacheClear;
    ListCache.prototype['delete'] = listCacheDelete;
    ListCache.prototype.get = listCacheGet;
    ListCache.prototype.has = listCacheHas;
    ListCache.prototype.set = listCacheSet;

    module.exports = ListCache;

    },{"./_listCacheClear":523,"./_listCacheDelete":524,"./_listCacheGet":525,"./_listCacheHas":526,"./_listCacheSet":527}],438:[function(require,module,exports){
    var getNative = require('./_getNative'),
        root = require('./_root');

    /* Built-in method references that are verified to be native. */
    var Map = getNative(root, 'Map');

    module.exports = Map;

    },{"./_getNative":502,"./_root":543}],439:[function(require,module,exports){
    var mapCacheClear = require('./_mapCacheClear'),
        mapCacheDelete = require('./_mapCacheDelete'),
        mapCacheGet = require('./_mapCacheGet'),
        mapCacheHas = require('./_mapCacheHas'),
        mapCacheSet = require('./_mapCacheSet');

    /**
     * Creates a map cache object to store key-value pairs.
     *
     * @private
     * @constructor
     * @param {Array} [entries] The key-value pairs to cache.
     */
    function MapCache(entries) {
      var index = -1,
          length = entries == null ? 0 : entries.length;

      this.clear();
      while (++index < length) {
        var entry = entries[index];
        this.set(entry[0], entry[1]);
      }
    }

    // Add methods to `MapCache`.
    MapCache.prototype.clear = mapCacheClear;
    MapCache.prototype['delete'] = mapCacheDelete;
    MapCache.prototype.get = mapCacheGet;
    MapCache.prototype.has = mapCacheHas;
    MapCache.prototype.set = mapCacheSet;

    module.exports = MapCache;

    },{"./_mapCacheClear":528,"./_mapCacheDelete":529,"./_mapCacheGet":530,"./_mapCacheHas":531,"./_mapCacheSet":532}],440:[function(require,module,exports){
    var getNative = require('./_getNative'),
        root = require('./_root');

    /* Built-in method references that are verified to be native. */
    var Promise = getNative(root, 'Promise');

    module.exports = Promise;

    },{"./_getNative":502,"./_root":543}],441:[function(require,module,exports){
    var getNative = require('./_getNative'),
        root = require('./_root');

    /* Built-in method references that are verified to be native. */
    var Set = getNative(root, 'Set');

    module.exports = Set;

    },{"./_getNative":502,"./_root":543}],442:[function(require,module,exports){
    var ListCache = require('./_ListCache'),
        stackClear = require('./_stackClear'),
        stackDelete = require('./_stackDelete'),
        stackGet = require('./_stackGet'),
        stackHas = require('./_stackHas'),
        stackSet = require('./_stackSet');

    /**
     * Creates a stack cache object to store key-value pairs.
     *
     * @private
     * @constructor
     * @param {Array} [entries] The key-value pairs to cache.
     */
    function Stack(entries) {
      var data = this.__data__ = new ListCache(entries);
      this.size = data.size;
    }

    // Add methods to `Stack`.
    Stack.prototype.clear = stackClear;
    Stack.prototype['delete'] = stackDelete;
    Stack.prototype.get = stackGet;
    Stack.prototype.has = stackHas;
    Stack.prototype.set = stackSet;

    module.exports = Stack;

    },{"./_ListCache":437,"./_stackClear":547,"./_stackDelete":548,"./_stackGet":549,"./_stackHas":550,"./_stackSet":551}],443:[function(require,module,exports){
    var root = require('./_root');

    /** Built-in value references. */
    var Symbol = root.Symbol;

    module.exports = Symbol;

    },{"./_root":543}],444:[function(require,module,exports){
    var root = require('./_root');

    /** Built-in value references. */
    var Uint8Array = root.Uint8Array;

    module.exports = Uint8Array;

    },{"./_root":543}],445:[function(require,module,exports){
    var getNative = require('./_getNative'),
        root = require('./_root');

    /* Built-in method references that are verified to be native. */
    var WeakMap = getNative(root, 'WeakMap');

    module.exports = WeakMap;

    },{"./_getNative":502,"./_root":543}],446:[function(require,module,exports){
    /**
     * Adds the key-value `pair` to `map`.
     *
     * @private
     * @param {Object} map The map to modify.
     * @param {Array} pair The key-value pair to add.
     * @returns {Object} Returns `map`.
     */
    function addMapEntry(map, pair) {
      // Don't return `map.set` because it's not chainable in IE 11.
      map.set(pair[0], pair[1]);
      return map;
    }

    module.exports = addMapEntry;

    },{}],447:[function(require,module,exports){
    /**
     * Adds `value` to `set`.
     *
     * @private
     * @param {Object} set The set to modify.
     * @param {*} value The value to add.
     * @returns {Object} Returns `set`.
     */
    function addSetEntry(set, value) {
      // Don't return `set.add` because it's not chainable in IE 11.
      set.add(value);
      return set;
    }

    module.exports = addSetEntry;

    },{}],448:[function(require,module,exports){
    /**
     * A faster alternative to `Function#apply`, this function invokes `func`
     * with the `this` binding of `thisArg` and the arguments of `args`.
     *
     * @private
     * @param {Function} func The function to invoke.
     * @param {*} thisArg The `this` binding of `func`.
     * @param {Array} args The arguments to invoke `func` with.
     * @returns {*} Returns the result of `func`.
     */
    function apply(func, thisArg, args) {
      switch (args.length) {
        case 0: return func.call(thisArg);
        case 1: return func.call(thisArg, args[0]);
        case 2: return func.call(thisArg, args[0], args[1]);
        case 3: return func.call(thisArg, args[0], args[1], args[2]);
      }
      return func.apply(thisArg, args);
    }

    module.exports = apply;

    },{}],449:[function(require,module,exports){
    /**
     * A specialized version of `_.forEach` for arrays without support for
     * iteratee shorthands.
     *
     * @private
     * @param {Array} [array] The array to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {Array} Returns `array`.
     */
    function arrayEach(array, iteratee) {
      var index = -1,
          length = array == null ? 0 : array.length;

      while (++index < length) {
        if (iteratee(array[index], index, array) === false) {
          break;
        }
      }
      return array;
    }

    module.exports = arrayEach;

    },{}],450:[function(require,module,exports){
    /**
     * A specialized version of `_.filter` for arrays without support for
     * iteratee shorthands.
     *
     * @private
     * @param {Array} [array] The array to iterate over.
     * @param {Function} predicate The function invoked per iteration.
     * @returns {Array} Returns the new filtered array.
     */
    function arrayFilter(array, predicate) {
      var index = -1,
          length = array == null ? 0 : array.length,
          resIndex = 0,
          result = [];

      while (++index < length) {
        var value = array[index];
        if (predicate(value, index, array)) {
          result[resIndex++] = value;
        }
      }
      return result;
    }

    module.exports = arrayFilter;

    },{}],451:[function(require,module,exports){
    var baseTimes = require('./_baseTimes'),
        isArguments = require('./isArguments'),
        isArray = require('./isArray'),
        isBuffer = require('./isBuffer'),
        isIndex = require('./_isIndex'),
        isTypedArray = require('./isTypedArray');

    /** Used for built-in method references. */
    var objectProto = Object.prototype;

    /** Used to check objects for own properties. */
    var hasOwnProperty = objectProto.hasOwnProperty;

    /**
     * Creates an array of the enumerable property names of the array-like `value`.
     *
     * @private
     * @param {*} value The value to query.
     * @param {boolean} inherited Specify returning inherited property names.
     * @returns {Array} Returns the array of property names.
     */
    function arrayLikeKeys(value, inherited) {
      var isArr = isArray(value),
          isArg = !isArr && isArguments(value),
          isBuff = !isArr && !isArg && isBuffer(value),
          isType = !isArr && !isArg && !isBuff && isTypedArray(value),
          skipIndexes = isArr || isArg || isBuff || isType,
          result = skipIndexes ? baseTimes(value.length, String) : [],
          length = result.length;

      for (var key in value) {
        if ((inherited || hasOwnProperty.call(value, key)) &&
            !(skipIndexes && (
               // Safari 9 has enumerable `arguments.length` in strict mode.
               key == 'length' ||
               // Node.js 0.10 has enumerable non-index properties on buffers.
               (isBuff && (key == 'offset' || key == 'parent')) ||
               // PhantomJS 2 has enumerable non-index properties on typed arrays.
               (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
               // Skip index properties.
               isIndex(key, length)
            ))) {
          result.push(key);
        }
      }
      return result;
    }

    module.exports = arrayLikeKeys;

    },{"./_baseTimes":476,"./_isIndex":518,"./isArguments":561,"./isArray":562,"./isBuffer":564,"./isTypedArray":572}],452:[function(require,module,exports){
    /**
     * A specialized version of `_.map` for arrays without support for iteratee
     * shorthands.
     *
     * @private
     * @param {Array} [array] The array to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {Array} Returns the new mapped array.
     */
    function arrayMap(array, iteratee) {
      var index = -1,
          length = array == null ? 0 : array.length,
          result = Array(length);

      while (++index < length) {
        result[index] = iteratee(array[index], index, array);
      }
      return result;
    }

    module.exports = arrayMap;

    },{}],453:[function(require,module,exports){
    /**
     * Appends the elements of `values` to `array`.
     *
     * @private
     * @param {Array} array The array to modify.
     * @param {Array} values The values to append.
     * @returns {Array} Returns `array`.
     */
    function arrayPush(array, values) {
      var index = -1,
          length = values.length,
          offset = array.length;

      while (++index < length) {
        array[offset + index] = values[index];
      }
      return array;
    }

    module.exports = arrayPush;

    },{}],454:[function(require,module,exports){
    /**
     * A specialized version of `_.reduce` for arrays without support for
     * iteratee shorthands.
     *
     * @private
     * @param {Array} [array] The array to iterate over.
     * @param {Function} iteratee The function invoked per iteration.
     * @param {*} [accumulator] The initial value.
     * @param {boolean} [initAccum] Specify using the first element of `array` as
     *  the initial value.
     * @returns {*} Returns the accumulated value.
     */
    function arrayReduce(array, iteratee, accumulator, initAccum) {
      var index = -1,
          length = array == null ? 0 : array.length;

      if (initAccum && length) {
        accumulator = array[++index];
      }
      while (++index < length) {
        accumulator = iteratee(accumulator, array[index], index, array);
      }
      return accumulator;
    }

    module.exports = arrayReduce;

    },{}],455:[function(require,module,exports){
    var baseAssignValue = require('./_baseAssignValue'),
        eq = require('./eq');

    /** Used for built-in method references. */
    var objectProto = Object.prototype;

    /** Used to check objects for own properties. */
    var hasOwnProperty = objectProto.hasOwnProperty;

    /**
     * Assigns `value` to `key` of `object` if the existing value is not equivalent
     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * for equality comparisons.
     *
     * @private
     * @param {Object} object The object to modify.
     * @param {string} key The key of the property to assign.
     * @param {*} value The value to assign.
     */
    function assignValue(object, key, value) {
      var objValue = object[key];
      if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
          (value === undefined && !(key in object))) {
        baseAssignValue(object, key, value);
      }
    }

    module.exports = assignValue;

    },{"./_baseAssignValue":459,"./eq":557}],456:[function(require,module,exports){
    var eq = require('./eq');

    /**
     * Gets the index at which the `key` is found in `array` of key-value pairs.
     *
     * @private
     * @param {Array} array The array to inspect.
     * @param {*} key The key to search for.
     * @returns {number} Returns the index of the matched value, else `-1`.
     */
    function assocIndexOf(array, key) {
      var length = array.length;
      while (length--) {
        if (eq(array[length][0], key)) {
          return length;
        }
      }
      return -1;
    }

    module.exports = assocIndexOf;

    },{"./eq":557}],457:[function(require,module,exports){
    var copyObject = require('./_copyObject'),
        keys = require('./keys');

    /**
     * The base implementation of `_.assign` without support for multiple sources
     * or `customizer` functions.
     *
     * @private
     * @param {Object} object The destination object.
     * @param {Object} source The source object.
     * @returns {Object} Returns `object`.
     */
    function baseAssign(object, source) {
      return object && copyObject(source, keys(source), object);
    }

    module.exports = baseAssign;

    },{"./_copyObject":491,"./keys":573}],458:[function(require,module,exports){
    var copyObject = require('./_copyObject'),
        keysIn = require('./keysIn');

    /**
     * The base implementation of `_.assignIn` without support for multiple sources
     * or `customizer` functions.
     *
     * @private
     * @param {Object} object The destination object.
     * @param {Object} source The source object.
     * @returns {Object} Returns `object`.
     */
    function baseAssignIn(object, source) {
      return object && copyObject(source, keysIn(source), object);
    }

    module.exports = baseAssignIn;

    },{"./_copyObject":491,"./keysIn":574}],459:[function(require,module,exports){
    var defineProperty = require('./_defineProperty');

    /**
     * The base implementation of `assignValue` and `assignMergeValue` without
     * value checks.
     *
     * @private
     * @param {Object} object The object to modify.
     * @param {string} key The key of the property to assign.
     * @param {*} value The value to assign.
     */
    function baseAssignValue(object, key, value) {
      if (key == '__proto__' && defineProperty) {
        defineProperty(object, key, {
          'configurable': true,
          'enumerable': true,
          'value': value,
          'writable': true
        });
      } else {
        object[key] = value;
      }
    }

    module.exports = baseAssignValue;

    },{"./_defineProperty":496}],460:[function(require,module,exports){
    var Stack = require('./_Stack'),
        arrayEach = require('./_arrayEach'),
        assignValue = require('./_assignValue'),
        baseAssign = require('./_baseAssign'),
        baseAssignIn = require('./_baseAssignIn'),
        cloneBuffer = require('./_cloneBuffer'),
        copyArray = require('./_copyArray'),
        copySymbols = require('./_copySymbols'),
        copySymbolsIn = require('./_copySymbolsIn'),
        getAllKeys = require('./_getAllKeys'),
        getAllKeysIn = require('./_getAllKeysIn'),
        getTag = require('./_getTag'),
        initCloneArray = require('./_initCloneArray'),
        initCloneByTag = require('./_initCloneByTag'),
        initCloneObject = require('./_initCloneObject'),
        isArray = require('./isArray'),
        isBuffer = require('./isBuffer'),
        isObject = require('./isObject'),
        keys = require('./keys');

    /** Used to compose bitmasks for cloning. */
    var CLONE_DEEP_FLAG = 1,
        CLONE_FLAT_FLAG = 2,
        CLONE_SYMBOLS_FLAG = 4;

    /** `Object#toString` result references. */
    var argsTag = '[object Arguments]',
        arrayTag = '[object Array]',
        boolTag = '[object Boolean]',
        dateTag = '[object Date]',
        errorTag = '[object Error]',
        funcTag = '[object Function]',
        genTag = '[object GeneratorFunction]',
        mapTag = '[object Map]',
        numberTag = '[object Number]',
        objectTag = '[object Object]',
        regexpTag = '[object RegExp]',
        setTag = '[object Set]',
        stringTag = '[object String]',
        symbolTag = '[object Symbol]',
        weakMapTag = '[object WeakMap]';

    var arrayBufferTag = '[object ArrayBuffer]',
        dataViewTag = '[object DataView]',
        float32Tag = '[object Float32Array]',
        float64Tag = '[object Float64Array]',
        int8Tag = '[object Int8Array]',
        int16Tag = '[object Int16Array]',
        int32Tag = '[object Int32Array]',
        uint8Tag = '[object Uint8Array]',
        uint8ClampedTag = '[object Uint8ClampedArray]',
        uint16Tag = '[object Uint16Array]',
        uint32Tag = '[object Uint32Array]';

    /** Used to identify `toStringTag` values supported by `_.clone`. */
    var cloneableTags = {};
    cloneableTags[argsTag] = cloneableTags[arrayTag] =
    cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
    cloneableTags[boolTag] = cloneableTags[dateTag] =
    cloneableTags[float32Tag] = cloneableTags[float64Tag] =
    cloneableTags[int8Tag] = cloneableTags[int16Tag] =
    cloneableTags[int32Tag] = cloneableTags[mapTag] =
    cloneableTags[numberTag] = cloneableTags[objectTag] =
    cloneableTags[regexpTag] = cloneableTags[setTag] =
    cloneableTags[stringTag] = cloneableTags[symbolTag] =
    cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
    cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
    cloneableTags[errorTag] = cloneableTags[funcTag] =
    cloneableTags[weakMapTag] = false;

    /**
     * The base implementation of `_.clone` and `_.cloneDeep` which tracks
     * traversed objects.
     *
     * @private
     * @param {*} value The value to clone.
     * @param {boolean} bitmask The bitmask flags.
     *  1 - Deep clone
     *  2 - Flatten inherited properties
     *  4 - Clone symbols
     * @param {Function} [customizer] The function to customize cloning.
     * @param {string} [key] The key of `value`.
     * @param {Object} [object] The parent object of `value`.
     * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
     * @returns {*} Returns the cloned value.
     */
    function baseClone(value, bitmask, customizer, key, object, stack) {
      var result,
          isDeep = bitmask & CLONE_DEEP_FLAG,
          isFlat = bitmask & CLONE_FLAT_FLAG,
          isFull = bitmask & CLONE_SYMBOLS_FLAG;

      if (customizer) {
        result = object ? customizer(value, key, object, stack) : customizer(value);
      }
      if (result !== undefined) {
        return result;
      }
      if (!isObject(value)) {
        return value;
      }
      var isArr = isArray(value);
      if (isArr) {
        result = initCloneArray(value);
        if (!isDeep) {
          return copyArray(value, result);
        }
      } else {
        var tag = getTag(value),
            isFunc = tag == funcTag || tag == genTag;

        if (isBuffer(value)) {
          return cloneBuffer(value, isDeep);
        }
        if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
          result = (isFlat || isFunc) ? {} : initCloneObject(value);
          if (!isDeep) {
            return isFlat
              ? copySymbolsIn(value, baseAssignIn(result, value))
              : copySymbols(value, baseAssign(result, value));
          }
        } else {
          if (!cloneableTags[tag]) {
            return object ? value : {};
          }
          result = initCloneByTag(value, tag, baseClone, isDeep);
        }
      }
      // Check for circular references and return its corresponding clone.
      stack || (stack = new Stack);
      var stacked = stack.get(value);
      if (stacked) {
        return stacked;
      }
      stack.set(value, result);

      var keysFunc = isFull
        ? (isFlat ? getAllKeysIn : getAllKeys)
        : (isFlat ? keysIn : keys);

      var props = isArr ? undefined : keysFunc(value);
      arrayEach(props || value, function(subValue, key) {
        if (props) {
          key = subValue;
          subValue = value[key];
        }
        // Recursively populate clone (susceptible to call stack limits).
        assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
      });
      return result;
    }

    module.exports = baseClone;

    },{"./_Stack":442,"./_arrayEach":449,"./_assignValue":455,"./_baseAssign":457,"./_baseAssignIn":458,"./_cloneBuffer":483,"./_copyArray":490,"./_copySymbols":492,"./_copySymbolsIn":493,"./_getAllKeys":499,"./_getAllKeysIn":500,"./_getTag":507,"./_initCloneArray":514,"./_initCloneByTag":515,"./_initCloneObject":516,"./isArray":562,"./isBuffer":564,"./isObject":567,"./keys":573}],461:[function(require,module,exports){
    var isObject = require('./isObject');

    /** Built-in value references. */
    var objectCreate = Object.create;

    /**
     * The base implementation of `_.create` without support for assigning
     * properties to the created object.
     *
     * @private
     * @param {Object} proto The object to inherit from.
     * @returns {Object} Returns the new object.
     */
    var baseCreate = (function() {
      function object() {}
      return function(proto) {
        if (!isObject(proto)) {
          return {};
        }
        if (objectCreate) {
          return objectCreate(proto);
        }
        object.prototype = proto;
        var result = new object;
        object.prototype = undefined;
        return result;
      };
    }());

    module.exports = baseCreate;

    },{"./isObject":567}],462:[function(require,module,exports){
    /**
     * The base implementation of `_.findIndex` and `_.findLastIndex` without
     * support for iteratee shorthands.
     *
     * @private
     * @param {Array} array The array to inspect.
     * @param {Function} predicate The function invoked per iteration.
     * @param {number} fromIndex The index to search from.
     * @param {boolean} [fromRight] Specify iterating from right to left.
     * @returns {number} Returns the index of the matched value, else `-1`.
     */
    function baseFindIndex(array, predicate, fromIndex, fromRight) {
      var length = array.length,
          index = fromIndex + (fromRight ? 1 : -1);

      while ((fromRight ? index-- : ++index < length)) {
        if (predicate(array[index], index, array)) {
          return index;
        }
      }
      return -1;
    }

    module.exports = baseFindIndex;

    },{}],463:[function(require,module,exports){
    var arrayPush = require('./_arrayPush'),
        isFlattenable = require('./_isFlattenable');

    /**
     * The base implementation of `_.flatten` with support for restricting flattening.
     *
     * @private
     * @param {Array} array The array to flatten.
     * @param {number} depth The maximum recursion depth.
     * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
     * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
     * @param {Array} [result=[]] The initial result value.
     * @returns {Array} Returns the new flattened array.
     */
    function baseFlatten(array, depth, predicate, isStrict, result) {
      var index = -1,
          length = array.length;

      predicate || (predicate = isFlattenable);
      result || (result = []);

      while (++index < length) {
        var value = array[index];
        if (depth > 0 && predicate(value)) {
          if (depth > 1) {
            // Recursively flatten arrays (susceptible to call stack limits).
            baseFlatten(value, depth - 1, predicate, isStrict, result);
          } else {
            arrayPush(result, value);
          }
        } else if (!isStrict) {
          result[result.length] = value;
        }
      }
      return result;
    }

    module.exports = baseFlatten;

    },{"./_arrayPush":453,"./_isFlattenable":517}],464:[function(require,module,exports){
    var castPath = require('./_castPath'),
        toKey = require('./_toKey');

    /**
     * The base implementation of `_.get` without support for default values.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {Array|string} path The path of the property to get.
     * @returns {*} Returns the resolved value.
     */
    function baseGet(object, path) {
      path = castPath(path, object);

      var index = 0,
          length = path.length;

      while (object != null && index < length) {
        object = object[toKey(path[index++])];
      }
      return (index && index == length) ? object : undefined;
    }

    module.exports = baseGet;

    },{"./_castPath":481,"./_toKey":554}],465:[function(require,module,exports){
    var arrayPush = require('./_arrayPush'),
        isArray = require('./isArray');

    /**
     * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
     * `keysFunc` and `symbolsFunc` to get the enumerable property names and
     * symbols of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {Function} keysFunc The function to get the keys of `object`.
     * @param {Function} symbolsFunc The function to get the symbols of `object`.
     * @returns {Array} Returns the array of property names and symbols.
     */
    function baseGetAllKeys(object, keysFunc, symbolsFunc) {
      var result = keysFunc(object);
      return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
    }

    module.exports = baseGetAllKeys;

    },{"./_arrayPush":453,"./isArray":562}],466:[function(require,module,exports){
    var Symbol = require('./_Symbol'),
        getRawTag = require('./_getRawTag'),
        objectToString = require('./_objectToString');

    /** `Object#toString` result references. */
    var nullTag = '[object Null]',
        undefinedTag = '[object Undefined]';

    /** Built-in value references. */
    var symToStringTag = Symbol ? Symbol.toStringTag : undefined;

    /**
     * The base implementation of `getTag` without fallbacks for buggy environments.
     *
     * @private
     * @param {*} value The value to query.
     * @returns {string} Returns the `toStringTag`.
     */
    function baseGetTag(value) {
      if (value == null) {
        return value === undefined ? undefinedTag : nullTag;
      }
      return (symToStringTag && symToStringTag in Object(value))
        ? getRawTag(value)
        : objectToString(value);
    }

    module.exports = baseGetTag;

    },{"./_Symbol":443,"./_getRawTag":504,"./_objectToString":539}],467:[function(require,module,exports){
    var baseFindIndex = require('./_baseFindIndex'),
        baseIsNaN = require('./_baseIsNaN'),
        strictIndexOf = require('./_strictIndexOf');

    /**
     * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
     *
     * @private
     * @param {Array} array The array to inspect.
     * @param {*} value The value to search for.
     * @param {number} fromIndex The index to search from.
     * @returns {number} Returns the index of the matched value, else `-1`.
     */
    function baseIndexOf(array, value, fromIndex) {
      return value === value
        ? strictIndexOf(array, value, fromIndex)
        : baseFindIndex(array, baseIsNaN, fromIndex);
    }

    module.exports = baseIndexOf;

    },{"./_baseFindIndex":462,"./_baseIsNaN":469,"./_strictIndexOf":552}],468:[function(require,module,exports){
    var baseGetTag = require('./_baseGetTag'),
        isObjectLike = require('./isObjectLike');

    /** `Object#toString` result references. */
    var argsTag = '[object Arguments]';

    /**
     * The base implementation of `_.isArguments`.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an `arguments` object,
     */
    function baseIsArguments(value) {
      return isObjectLike(value) && baseGetTag(value) == argsTag;
    }

    module.exports = baseIsArguments;

    },{"./_baseGetTag":466,"./isObjectLike":568}],469:[function(require,module,exports){
    /**
     * The base implementation of `_.isNaN` without support for number objects.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
     */
    function baseIsNaN(value) {
      return value !== value;
    }

    module.exports = baseIsNaN;

    },{}],470:[function(require,module,exports){
    var isFunction = require('./isFunction'),
        isMasked = require('./_isMasked'),
        isObject = require('./isObject'),
        toSource = require('./_toSource');

    /**
     * Used to match `RegExp`
     * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
     */
    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;

    /** Used to detect host constructors (Safari). */
    var reIsHostCtor = /^\[object .+?Constructor\]$/;

    /** Used for built-in method references. */
    var funcProto = Function.prototype,
        objectProto = Object.prototype;

    /** Used to resolve the decompiled source of functions. */
    var funcToString = funcProto.toString;

    /** Used to check objects for own properties. */
    var hasOwnProperty = objectProto.hasOwnProperty;

    /** Used to detect if a method is native. */
    var reIsNative = RegExp('^' +
      funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
      .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
    );

    /**
     * The base implementation of `_.isNative` without bad shim checks.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a native function,
     *  else `false`.
     */
    function baseIsNative(value) {
      if (!isObject(value) || isMasked(value)) {
        return false;
      }
      var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
      return pattern.test(toSource(value));
    }

    module.exports = baseIsNative;

    },{"./_isMasked":521,"./_toSource":555,"./isFunction":565,"./isObject":567}],471:[function(require,module,exports){
    var baseGetTag = require('./_baseGetTag'),
        isLength = require('./isLength'),
        isObjectLike = require('./isObjectLike');

    /** `Object#toString` result references. */
    var argsTag = '[object Arguments]',
        arrayTag = '[object Array]',
        boolTag = '[object Boolean]',
        dateTag = '[object Date]',
        errorTag = '[object Error]',
        funcTag = '[object Function]',
        mapTag = '[object Map]',
        numberTag = '[object Number]',
        objectTag = '[object Object]',
        regexpTag = '[object RegExp]',
        setTag = '[object Set]',
        stringTag = '[object String]',
        weakMapTag = '[object WeakMap]';

    var arrayBufferTag = '[object ArrayBuffer]',
        dataViewTag = '[object DataView]',
        float32Tag = '[object Float32Array]',
        float64Tag = '[object Float64Array]',
        int8Tag = '[object Int8Array]',
        int16Tag = '[object Int16Array]',
        int32Tag = '[object Int32Array]',
        uint8Tag = '[object Uint8Array]',
        uint8ClampedTag = '[object Uint8ClampedArray]',
        uint16Tag = '[object Uint16Array]',
        uint32Tag = '[object Uint32Array]';

    /** Used to identify `toStringTag` values of typed arrays. */
    var typedArrayTags = {};
    typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
    typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
    typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
    typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
    typedArrayTags[uint32Tag] = true;
    typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
    typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
    typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
    typedArrayTags[errorTag] = typedArrayTags[funcTag] =
    typedArrayTags[mapTag] = typedArrayTags[numberTag] =
    typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
    typedArrayTags[setTag] = typedArrayTags[stringTag] =
    typedArrayTags[weakMapTag] = false;

    /**
     * The base implementation of `_.isTypedArray` without Node.js optimizations.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
     */
    function baseIsTypedArray(value) {
      return isObjectLike(value) &&
        isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
    }

    module.exports = baseIsTypedArray;

    },{"./_baseGetTag":466,"./isLength":566,"./isObjectLike":568}],472:[function(require,module,exports){
    var isPrototype = require('./_isPrototype'),
        nativeKeys = require('./_nativeKeys');

    /** Used for built-in method references. */
    var objectProto = Object.prototype;

    /** Used to check objects for own properties. */
    var hasOwnProperty = objectProto.hasOwnProperty;

    /**
     * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names.
     */
    function baseKeys(object) {
      if (!isPrototype(object)) {
        return nativeKeys(object);
      }
      var result = [];
      for (var key in Object(object)) {
        if (hasOwnProperty.call(object, key) && key != 'constructor') {
          result.push(key);
        }
      }
      return result;
    }

    module.exports = baseKeys;

    },{"./_isPrototype":522,"./_nativeKeys":536}],473:[function(require,module,exports){
    var isObject = require('./isObject'),
        isPrototype = require('./_isPrototype'),
        nativeKeysIn = require('./_nativeKeysIn');

    /** Used for built-in method references. */
    var objectProto = Object.prototype;

    /** Used to check objects for own properties. */
    var hasOwnProperty = objectProto.hasOwnProperty;

    /**
     * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names.
     */
    function baseKeysIn(object) {
      if (!isObject(object)) {
        return nativeKeysIn(object);
      }
      var isProto = isPrototype(object),
          result = [];

      for (var key in object) {
        if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
          result.push(key);
        }
      }
      return result;
    }

    module.exports = baseKeysIn;

    },{"./_isPrototype":522,"./_nativeKeysIn":537,"./isObject":567}],474:[function(require,module,exports){
    var constant = require('./constant'),
        defineProperty = require('./_defineProperty'),
        identity = require('./identity');

    /**
     * The base implementation of `setToString` without support for hot loop shorting.
     *
     * @private
     * @param {Function} func The function to modify.
     * @param {Function} string The `toString` result.
     * @returns {Function} Returns `func`.
     */
    var baseSetToString = !defineProperty ? identity : function(func, string) {
      return defineProperty(func, 'toString', {
        'configurable': true,
        'enumerable': false,
        'value': constant(string),
        'writable': true
      });
    };

    module.exports = baseSetToString;

    },{"./_defineProperty":496,"./constant":556,"./identity":559}],475:[function(require,module,exports){
    /**
     * The base implementation of `_.slice` without an iteratee call guard.
     *
     * @private
     * @param {Array} array The array to slice.
     * @param {number} [start=0] The start position.
     * @param {number} [end=array.length] The end position.
     * @returns {Array} Returns the slice of `array`.
     */
    function baseSlice(array, start, end) {
      var index = -1,
          length = array.length;

      if (start < 0) {
        start = -start > length ? 0 : (length + start);
      }
      end = end > length ? length : end;
      if (end < 0) {
        end += length;
      }
      length = start > end ? 0 : ((end - start) >>> 0);
      start >>>= 0;

      var result = Array(length);
      while (++index < length) {
        result[index] = array[index + start];
      }
      return result;
    }

    module.exports = baseSlice;

    },{}],476:[function(require,module,exports){
    /**
     * The base implementation of `_.times` without support for iteratee shorthands
     * or max array length checks.
     *
     * @private
     * @param {number} n The number of times to invoke `iteratee`.
     * @param {Function} iteratee The function invoked per iteration.
     * @returns {Array} Returns the array of results.
     */
    function baseTimes(n, iteratee) {
      var index = -1,
          result = Array(n);

      while (++index < n) {
        result[index] = iteratee(index);
      }
      return result;
    }

    module.exports = baseTimes;

    },{}],477:[function(require,module,exports){
    var Symbol = require('./_Symbol'),
        arrayMap = require('./_arrayMap'),
        isArray = require('./isArray'),
        isSymbol = require('./isSymbol');

    /** Used as references for various `Number` constants. */
    var INFINITY = 1 / 0;

    /** Used to convert symbols to primitives and strings. */
    var symbolProto = Symbol ? Symbol.prototype : undefined,
        symbolToString = symbolProto ? symbolProto.toString : undefined;

    /**
     * The base implementation of `_.toString` which doesn't convert nullish
     * values to empty strings.
     *
     * @private
     * @param {*} value The value to process.
     * @returns {string} Returns the string.
     */
    function baseToString(value) {
      // Exit early for strings to avoid a performance hit in some environments.
      if (typeof value == 'string') {
        return value;
      }
      if (isArray(value)) {
        // Recursively convert values (susceptible to call stack limits).
        return arrayMap(value, baseToString) + '';
      }
      if (isSymbol(value)) {
        return symbolToString ? symbolToString.call(value) : '';
      }
      var result = (value + '');
      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
    }

    module.exports = baseToString;

    },{"./_Symbol":443,"./_arrayMap":452,"./isArray":562,"./isSymbol":571}],478:[function(require,module,exports){
    /**
     * The base implementation of `_.unary` without support for storing metadata.
     *
     * @private
     * @param {Function} func The function to cap arguments for.
     * @returns {Function} Returns the new capped function.
     */
    function baseUnary(func) {
      return function(value) {
        return func(value);
      };
    }

    module.exports = baseUnary;

    },{}],479:[function(require,module,exports){
    var castPath = require('./_castPath'),
        last = require('./last'),
        parent = require('./_parent'),
        toKey = require('./_toKey');

    /**
     * The base implementation of `_.unset`.
     *
     * @private
     * @param {Object} object The object to modify.
     * @param {Array|string} path The property path to unset.
     * @returns {boolean} Returns `true` if the property is deleted, else `false`.
     */
    function baseUnset(object, path) {
      path = castPath(path, object);
      object = parent(object, path);
      return object == null || delete object[toKey(last(path))];
    }

    module.exports = baseUnset;

    },{"./_castPath":481,"./_parent":542,"./_toKey":554,"./last":575}],480:[function(require,module,exports){
    var arrayMap = require('./_arrayMap');

    /**
     * The base implementation of `_.values` and `_.valuesIn` which creates an
     * array of `object` property values corresponding to the property names
     * of `props`.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {Array} props The property names to get values for.
     * @returns {Object} Returns the array of property values.
     */
    function baseValues(object, props) {
      return arrayMap(props, function(key) {
        return object[key];
      });
    }

    module.exports = baseValues;

    },{"./_arrayMap":452}],481:[function(require,module,exports){
    var isArray = require('./isArray'),
        isKey = require('./_isKey'),
        stringToPath = require('./_stringToPath'),
        toString = require('./toString');

    /**
     * Casts `value` to a path array if it's not one.
     *
     * @private
     * @param {*} value The value to inspect.
     * @param {Object} [object] The object to query keys on.
     * @returns {Array} Returns the cast property path array.
     */
    function castPath(value, object) {
      if (isArray(value)) {
        return value;
      }
      return isKey(value, object) ? [value] : stringToPath(toString(value));
    }

    module.exports = castPath;

    },{"./_isKey":519,"./_stringToPath":553,"./isArray":562,"./toString":583}],482:[function(require,module,exports){
    var Uint8Array = require('./_Uint8Array');

    /**
     * Creates a clone of `arrayBuffer`.
     *
     * @private
     * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
     * @returns {ArrayBuffer} Returns the cloned array buffer.
     */
    function cloneArrayBuffer(arrayBuffer) {
      var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
      new Uint8Array(result).set(new Uint8Array(arrayBuffer));
      return result;
    }

    module.exports = cloneArrayBuffer;

    },{"./_Uint8Array":444}],483:[function(require,module,exports){
    var root = require('./_root');

    /** Detect free variable `exports`. */
    var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;

    /** Detect free variable `module`. */
    var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;

    /** Detect the popular CommonJS extension `module.exports`. */
    var moduleExports = freeModule && freeModule.exports === freeExports;

    /** Built-in value references. */
    var Buffer = moduleExports ? root.Buffer : undefined,
        allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;

    /**
     * Creates a clone of  `buffer`.
     *
     * @private
     * @param {Buffer} buffer The buffer to clone.
     * @param {boolean} [isDeep] Specify a deep clone.
     * @returns {Buffer} Returns the cloned buffer.
     */
    function cloneBuffer(buffer, isDeep) {
      if (isDeep) {
        return buffer.slice();
      }
      var length = buffer.length,
          result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);

      buffer.copy(result);
      return result;
    }

    module.exports = cloneBuffer;

    },{"./_root":543}],484:[function(require,module,exports){
    var cloneArrayBuffer = require('./_cloneArrayBuffer');

    /**
     * Creates a clone of `dataView`.
     *
     * @private
     * @param {Object} dataView The data view to clone.
     * @param {boolean} [isDeep] Specify a deep clone.
     * @returns {Object} Returns the cloned data view.
     */
    function cloneDataView(dataView, isDeep) {
      var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
      return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
    }

    module.exports = cloneDataView;

    },{"./_cloneArrayBuffer":482}],485:[function(require,module,exports){
    var addMapEntry = require('./_addMapEntry'),
        arrayReduce = require('./_arrayReduce'),
        mapToArray = require('./_mapToArray');

    /** Used to compose bitmasks for cloning. */
    var CLONE_DEEP_FLAG = 1;

    /**
     * Creates a clone of `map`.
     *
     * @private
     * @param {Object} map The map to clone.
     * @param {Function} cloneFunc The function to clone values.
     * @param {boolean} [isDeep] Specify a deep clone.
     * @returns {Object} Returns the cloned map.
     */
    function cloneMap(map, isDeep, cloneFunc) {
      var array = isDeep ? cloneFunc(mapToArray(map), CLONE_DEEP_FLAG) : mapToArray(map);
      return arrayReduce(array, addMapEntry, new map.constructor);
    }

    module.exports = cloneMap;

    },{"./_addMapEntry":446,"./_arrayReduce":454,"./_mapToArray":533}],486:[function(require,module,exports){
    /** Used to match `RegExp` flags from their coerced string values. */
    var reFlags = /\w*$/;

    /**
     * Creates a clone of `regexp`.
     *
     * @private
     * @param {Object} regexp The regexp to clone.
     * @returns {Object} Returns the cloned regexp.
     */
    function cloneRegExp(regexp) {
      var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
      result.lastIndex = regexp.lastIndex;
      return result;
    }

    module.exports = cloneRegExp;

    },{}],487:[function(require,module,exports){
    var addSetEntry = require('./_addSetEntry'),
        arrayReduce = require('./_arrayReduce'),
        setToArray = require('./_setToArray');

    /** Used to compose bitmasks for cloning. */
    var CLONE_DEEP_FLAG = 1;

    /**
     * Creates a clone of `set`.
     *
     * @private
     * @param {Object} set The set to clone.
     * @param {Function} cloneFunc The function to clone values.
     * @param {boolean} [isDeep] Specify a deep clone.
     * @returns {Object} Returns the cloned set.
     */
    function cloneSet(set, isDeep, cloneFunc) {
      var array = isDeep ? cloneFunc(setToArray(set), CLONE_DEEP_FLAG) : setToArray(set);
      return arrayReduce(array, addSetEntry, new set.constructor);
    }

    module.exports = cloneSet;

    },{"./_addSetEntry":447,"./_arrayReduce":454,"./_setToArray":544}],488:[function(require,module,exports){
    var Symbol = require('./_Symbol');

    /** Used to convert symbols to primitives and strings. */
    var symbolProto = Symbol ? Symbol.prototype : undefined,
        symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;

    /**
     * Creates a clone of the `symbol` object.
     *
     * @private
     * @param {Object} symbol The symbol object to clone.
     * @returns {Object} Returns the cloned symbol object.
     */
    function cloneSymbol(symbol) {
      return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
    }

    module.exports = cloneSymbol;

    },{"./_Symbol":443}],489:[function(require,module,exports){
    var cloneArrayBuffer = require('./_cloneArrayBuffer');

    /**
     * Creates a clone of `typedArray`.
     *
     * @private
     * @param {Object} typedArray The typed array to clone.
     * @param {boolean} [isDeep] Specify a deep clone.
     * @returns {Object} Returns the cloned typed array.
     */
    function cloneTypedArray(typedArray, isDeep) {
      var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
      return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
    }

    module.exports = cloneTypedArray;

    },{"./_cloneArrayBuffer":482}],490:[function(require,module,exports){
    /**
     * Copies the values of `source` to `array`.
     *
     * @private
     * @param {Array} source The array to copy values from.
     * @param {Array} [array=[]] The array to copy values to.
     * @returns {Array} Returns `array`.
     */
    function copyArray(source, array) {
      var index = -1,
          length = source.length;

      array || (array = Array(length));
      while (++index < length) {
        array[index] = source[index];
      }
      return array;
    }

    module.exports = copyArray;

    },{}],491:[function(require,module,exports){
    var assignValue = require('./_assignValue'),
        baseAssignValue = require('./_baseAssignValue');

    /**
     * Copies properties of `source` to `object`.
     *
     * @private
     * @param {Object} source The object to copy properties from.
     * @param {Array} props The property identifiers to copy.
     * @param {Object} [object={}] The object to copy properties to.
     * @param {Function} [customizer] The function to customize copied values.
     * @returns {Object} Returns `object`.
     */
    function copyObject(source, props, object, customizer) {
      var isNew = !object;
      object || (object = {});

      var index = -1,
          length = props.length;

      while (++index < length) {
        var key = props[index];

        var newValue = customizer
          ? customizer(object[key], source[key], key, object, source)
          : undefined;

        if (newValue === undefined) {
          newValue = source[key];
        }
        if (isNew) {
          baseAssignValue(object, key, newValue);
        } else {
          assignValue(object, key, newValue);
        }
      }
      return object;
    }

    module.exports = copyObject;

    },{"./_assignValue":455,"./_baseAssignValue":459}],492:[function(require,module,exports){
    var copyObject = require('./_copyObject'),
        getSymbols = require('./_getSymbols');

    /**
     * Copies own symbols of `source` to `object`.
     *
     * @private
     * @param {Object} source The object to copy symbols from.
     * @param {Object} [object={}] The object to copy symbols to.
     * @returns {Object} Returns `object`.
     */
    function copySymbols(source, object) {
      return copyObject(source, getSymbols(source), object);
    }

    module.exports = copySymbols;

    },{"./_copyObject":491,"./_getSymbols":505}],493:[function(require,module,exports){
    var copyObject = require('./_copyObject'),
        getSymbolsIn = require('./_getSymbolsIn');

    /**
     * Copies own and inherited symbols of `source` to `object`.
     *
     * @private
     * @param {Object} source The object to copy symbols from.
     * @param {Object} [object={}] The object to copy symbols to.
     * @returns {Object} Returns `object`.
     */
    function copySymbolsIn(source, object) {
      return copyObject(source, getSymbolsIn(source), object);
    }

    module.exports = copySymbolsIn;

    },{"./_copyObject":491,"./_getSymbolsIn":506}],494:[function(require,module,exports){
    var root = require('./_root');

    /** Used to detect overreaching core-js shims. */
    var coreJsData = root['__core-js_shared__'];

    module.exports = coreJsData;

    },{"./_root":543}],495:[function(require,module,exports){
    var isPlainObject = require('./isPlainObject');

    /**
     * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain
     * objects.
     *
     * @private
     * @param {*} value The value to inspect.
     * @param {string} key The key of the property to inspect.
     * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.
     */
    function customOmitClone(value) {
      return isPlainObject(value) ? undefined : value;
    }

    module.exports = customOmitClone;

    },{"./isPlainObject":569}],496:[function(require,module,exports){
    var getNative = require('./_getNative');

    var defineProperty = (function() {
      try {
        var func = getNative(Object, 'defineProperty');
        func({}, '', {});
        return func;
      } catch (e) {}
    }());

    module.exports = defineProperty;

    },{"./_getNative":502}],497:[function(require,module,exports){
    var flatten = require('./flatten'),
        overRest = require('./_overRest'),
        setToString = require('./_setToString');

    /**
     * A specialized version of `baseRest` which flattens the rest array.
     *
     * @private
     * @param {Function} func The function to apply a rest parameter to.
     * @returns {Function} Returns the new function.
     */
    function flatRest(func) {
      return setToString(overRest(func, undefined, flatten), func + '');
    }

    module.exports = flatRest;

    },{"./_overRest":541,"./_setToString":545,"./flatten":558}],498:[function(require,module,exports){
    (function (global){
    /** Detect free variable `global` from Node.js. */
    var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

    module.exports = freeGlobal;

    }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{}],499:[function(require,module,exports){
    var baseGetAllKeys = require('./_baseGetAllKeys'),
        getSymbols = require('./_getSymbols'),
        keys = require('./keys');

    /**
     * Creates an array of own enumerable property names and symbols of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names and symbols.
     */
    function getAllKeys(object) {
      return baseGetAllKeys(object, keys, getSymbols);
    }

    module.exports = getAllKeys;

    },{"./_baseGetAllKeys":465,"./_getSymbols":505,"./keys":573}],500:[function(require,module,exports){
    var baseGetAllKeys = require('./_baseGetAllKeys'),
        getSymbolsIn = require('./_getSymbolsIn'),
        keysIn = require('./keysIn');

    /**
     * Creates an array of own and inherited enumerable property names and
     * symbols of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names and symbols.
     */
    function getAllKeysIn(object) {
      return baseGetAllKeys(object, keysIn, getSymbolsIn);
    }

    module.exports = getAllKeysIn;

    },{"./_baseGetAllKeys":465,"./_getSymbolsIn":506,"./keysIn":574}],501:[function(require,module,exports){
    var isKeyable = require('./_isKeyable');

    /**
     * Gets the data for `map`.
     *
     * @private
     * @param {Object} map The map to query.
     * @param {string} key The reference key.
     * @returns {*} Returns the map data.
     */
    function getMapData(map, key) {
      var data = map.__data__;
      return isKeyable(key)
        ? data[typeof key == 'string' ? 'string' : 'hash']
        : data.map;
    }

    module.exports = getMapData;

    },{"./_isKeyable":520}],502:[function(require,module,exports){
    var baseIsNative = require('./_baseIsNative'),
        getValue = require('./_getValue');

    /**
     * Gets the native function at `key` of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {string} key The key of the method to get.
     * @returns {*} Returns the function if it's native, else `undefined`.
     */
    function getNative(object, key) {
      var value = getValue(object, key);
      return baseIsNative(value) ? value : undefined;
    }

    module.exports = getNative;

    },{"./_baseIsNative":470,"./_getValue":508}],503:[function(require,module,exports){
    var overArg = require('./_overArg');

    /** Built-in value references. */
    var getPrototype = overArg(Object.getPrototypeOf, Object);

    module.exports = getPrototype;

    },{"./_overArg":540}],504:[function(require,module,exports){
    var Symbol = require('./_Symbol');

    /** Used for built-in method references. */
    var objectProto = Object.prototype;

    /** Used to check objects for own properties. */
    var hasOwnProperty = objectProto.hasOwnProperty;

    /**
     * Used to resolve the
     * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
     * of values.
     */
    var nativeObjectToString = objectProto.toString;

    /** Built-in value references. */
    var symToStringTag = Symbol ? Symbol.toStringTag : undefined;

    /**
     * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
     *
     * @private
     * @param {*} value The value to query.
     * @returns {string} Returns the raw `toStringTag`.
     */
    function getRawTag(value) {
      var isOwn = hasOwnProperty.call(value, symToStringTag),
          tag = value[symToStringTag];

      try {
        value[symToStringTag] = undefined;
        var unmasked = true;
      } catch (e) {}

      var result = nativeObjectToString.call(value);
      if (unmasked) {
        if (isOwn) {
          value[symToStringTag] = tag;
        } else {
          delete value[symToStringTag];
        }
      }
      return result;
    }

    module.exports = getRawTag;

    },{"./_Symbol":443}],505:[function(require,module,exports){
    var arrayFilter = require('./_arrayFilter'),
        stubArray = require('./stubArray');

    /** Used for built-in method references. */
    var objectProto = Object.prototype;

    /** Built-in value references. */
    var propertyIsEnumerable = objectProto.propertyIsEnumerable;

    /* Built-in method references for those with the same name as other `lodash` methods. */
    var nativeGetSymbols = Object.getOwnPropertySymbols;

    /**
     * Creates an array of the own enumerable symbols of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of symbols.
     */
    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
      if (object == null) {
        return [];
      }
      object = Object(object);
      return arrayFilter(nativeGetSymbols(object), function(symbol) {
        return propertyIsEnumerable.call(object, symbol);
      });
    };

    module.exports = getSymbols;

    },{"./_arrayFilter":450,"./stubArray":578}],506:[function(require,module,exports){
    var arrayPush = require('./_arrayPush'),
        getPrototype = require('./_getPrototype'),
        getSymbols = require('./_getSymbols'),
        stubArray = require('./stubArray');

    /* Built-in method references for those with the same name as other `lodash` methods. */
    var nativeGetSymbols = Object.getOwnPropertySymbols;

    /**
     * Creates an array of the own and inherited enumerable symbols of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of symbols.
     */
    var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
      var result = [];
      while (object) {
        arrayPush(result, getSymbols(object));
        object = getPrototype(object);
      }
      return result;
    };

    module.exports = getSymbolsIn;

    },{"./_arrayPush":453,"./_getPrototype":503,"./_getSymbols":505,"./stubArray":578}],507:[function(require,module,exports){
    var DataView = require('./_DataView'),
        Map = require('./_Map'),
        Promise = require('./_Promise'),
        Set = require('./_Set'),
        WeakMap = require('./_WeakMap'),
        baseGetTag = require('./_baseGetTag'),
        toSource = require('./_toSource');

    /** `Object#toString` result references. */
    var mapTag = '[object Map]',
        objectTag = '[object Object]',
        promiseTag = '[object Promise]',
        setTag = '[object Set]',
        weakMapTag = '[object WeakMap]';

    var dataViewTag = '[object DataView]';

    /** Used to detect maps, sets, and weakmaps. */
    var dataViewCtorString = toSource(DataView),
        mapCtorString = toSource(Map),
        promiseCtorString = toSource(Promise),
        setCtorString = toSource(Set),
        weakMapCtorString = toSource(WeakMap);

    /**
     * Gets the `toStringTag` of `value`.
     *
     * @private
     * @param {*} value The value to query.
     * @returns {string} Returns the `toStringTag`.
     */
    var getTag = baseGetTag;

    // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
    if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
        (Map && getTag(new Map) != mapTag) ||
        (Promise && getTag(Promise.resolve()) != promiseTag) ||
        (Set && getTag(new Set) != setTag) ||
        (WeakMap && getTag(new WeakMap) != weakMapTag)) {
      getTag = function(value) {
        var result = baseGetTag(value),
            Ctor = result == objectTag ? value.constructor : undefined,
            ctorString = Ctor ? toSource(Ctor) : '';

        if (ctorString) {
          switch (ctorString) {
            case dataViewCtorString: return dataViewTag;
            case mapCtorString: return mapTag;
            case promiseCtorString: return promiseTag;
            case setCtorString: return setTag;
            case weakMapCtorString: return weakMapTag;
          }
        }
        return result;
      };
    }

    module.exports = getTag;

    },{"./_DataView":435,"./_Map":438,"./_Promise":440,"./_Set":441,"./_WeakMap":445,"./_baseGetTag":466,"./_toSource":555}],508:[function(require,module,exports){
    /**
     * Gets the value at `key` of `object`.
     *
     * @private
     * @param {Object} [object] The object to query.
     * @param {string} key The key of the property to get.
     * @returns {*} Returns the property value.
     */
    function getValue(object, key) {
      return object == null ? undefined : object[key];
    }

    module.exports = getValue;

    },{}],509:[function(require,module,exports){
    var nativeCreate = require('./_nativeCreate');

    /**
     * Removes all key-value entries from the hash.
     *
     * @private
     * @name clear
     * @memberOf Hash
     */
    function hashClear() {
      this.__data__ = nativeCreate ? nativeCreate(null) : {};
      this.size = 0;
    }

    module.exports = hashClear;

    },{"./_nativeCreate":535}],510:[function(require,module,exports){
    /**
     * Removes `key` and its value from the hash.
     *
     * @private
     * @name delete
     * @memberOf Hash
     * @param {Object} hash The hash to modify.
     * @param {string} key The key of the value to remove.
     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
     */
    function hashDelete(key) {
      var result = this.has(key) && delete this.__data__[key];
      this.size -= result ? 1 : 0;
      return result;
    }

    module.exports = hashDelete;

    },{}],511:[function(require,module,exports){
    var nativeCreate = require('./_nativeCreate');

    /** Used to stand-in for `undefined` hash values. */
    var HASH_UNDEFINED = '__lodash_hash_undefined__';

    /** Used for built-in method references. */
    var objectProto = Object.prototype;

    /** Used to check objects for own properties. */
    var hasOwnProperty = objectProto.hasOwnProperty;

    /**
     * Gets the hash value for `key`.
     *
     * @private
     * @name get
     * @memberOf Hash
     * @param {string} key The key of the value to get.
     * @returns {*} Returns the entry value.
     */
    function hashGet(key) {
      var data = this.__data__;
      if (nativeCreate) {
        var result = data[key];
        return result === HASH_UNDEFINED ? undefined : result;
      }
      return hasOwnProperty.call(data, key) ? data[key] : undefined;
    }

    module.exports = hashGet;

    },{"./_nativeCreate":535}],512:[function(require,module,exports){
    var nativeCreate = require('./_nativeCreate');

    /** Used for built-in method references. */
    var objectProto = Object.prototype;

    /** Used to check objects for own properties. */
    var hasOwnProperty = objectProto.hasOwnProperty;

    /**
     * Checks if a hash value for `key` exists.
     *
     * @private
     * @name has
     * @memberOf Hash
     * @param {string} key The key of the entry to check.
     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
     */
    function hashHas(key) {
      var data = this.__data__;
      return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
    }

    module.exports = hashHas;

    },{"./_nativeCreate":535}],513:[function(require,module,exports){
    var nativeCreate = require('./_nativeCreate');

    /** Used to stand-in for `undefined` hash values. */
    var HASH_UNDEFINED = '__lodash_hash_undefined__';

    /**
     * Sets the hash `key` to `value`.
     *
     * @private
     * @name set
     * @memberOf Hash
     * @param {string} key The key of the value to set.
     * @param {*} value The value to set.
     * @returns {Object} Returns the hash instance.
     */
    function hashSet(key, value) {
      var data = this.__data__;
      this.size += this.has(key) ? 0 : 1;
      data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
      return this;
    }

    module.exports = hashSet;

    },{"./_nativeCreate":535}],514:[function(require,module,exports){
    /** Used for built-in method references. */
    var objectProto = Object.prototype;

    /** Used to check objects for own properties. */
    var hasOwnProperty = objectProto.hasOwnProperty;

    /**
     * Initializes an array clone.
     *
     * @private
     * @param {Array} array The array to clone.
     * @returns {Array} Returns the initialized clone.
     */
    function initCloneArray(array) {
      var length = array.length,
          result = array.constructor(length);

      // Add properties assigned by `RegExp#exec`.
      if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
        result.index = array.index;
        result.input = array.input;
      }
      return result;
    }

    module.exports = initCloneArray;

    },{}],515:[function(require,module,exports){
    var cloneArrayBuffer = require('./_cloneArrayBuffer'),
        cloneDataView = require('./_cloneDataView'),
        cloneMap = require('./_cloneMap'),
        cloneRegExp = require('./_cloneRegExp'),
        cloneSet = require('./_cloneSet'),
        cloneSymbol = require('./_cloneSymbol'),
        cloneTypedArray = require('./_cloneTypedArray');

    /** `Object#toString` result references. */
    var boolTag = '[object Boolean]',
        dateTag = '[object Date]',
        mapTag = '[object Map]',
        numberTag = '[object Number]',
        regexpTag = '[object RegExp]',
        setTag = '[object Set]',
        stringTag = '[object String]',
        symbolTag = '[object Symbol]';

    var arrayBufferTag = '[object ArrayBuffer]',
        dataViewTag = '[object DataView]',
        float32Tag = '[object Float32Array]',
        float64Tag = '[object Float64Array]',
        int8Tag = '[object Int8Array]',
        int16Tag = '[object Int16Array]',
        int32Tag = '[object Int32Array]',
        uint8Tag = '[object Uint8Array]',
        uint8ClampedTag = '[object Uint8ClampedArray]',
        uint16Tag = '[object Uint16Array]',
        uint32Tag = '[object Uint32Array]';

    /**
     * Initializes an object clone based on its `toStringTag`.
     *
     * **Note:** This function only supports cloning values with tags of
     * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
     *
     * @private
     * @param {Object} object The object to clone.
     * @param {string} tag The `toStringTag` of the object to clone.
     * @param {Function} cloneFunc The function to clone values.
     * @param {boolean} [isDeep] Specify a deep clone.
     * @returns {Object} Returns the initialized clone.
     */
    function initCloneByTag(object, tag, cloneFunc, isDeep) {
      var Ctor = object.constructor;
      switch (tag) {
        case arrayBufferTag:
          return cloneArrayBuffer(object);

        case boolTag:
        case dateTag:
          return new Ctor(+object);

        case dataViewTag:
          return cloneDataView(object, isDeep);

        case float32Tag: case float64Tag:
        case int8Tag: case int16Tag: case int32Tag:
        case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
          return cloneTypedArray(object, isDeep);

        case mapTag:
          return cloneMap(object, isDeep, cloneFunc);

        case numberTag:
        case stringTag:
          return new Ctor(object);

        case regexpTag:
          return cloneRegExp(object);

        case setTag:
          return cloneSet(object, isDeep, cloneFunc);

        case symbolTag:
          return cloneSymbol(object);
      }
    }

    module.exports = initCloneByTag;

    },{"./_cloneArrayBuffer":482,"./_cloneDataView":484,"./_cloneMap":485,"./_cloneRegExp":486,"./_cloneSet":487,"./_cloneSymbol":488,"./_cloneTypedArray":489}],516:[function(require,module,exports){
    var baseCreate = require('./_baseCreate'),
        getPrototype = require('./_getPrototype'),
        isPrototype = require('./_isPrototype');

    /**
     * Initializes an object clone.
     *
     * @private
     * @param {Object} object The object to clone.
     * @returns {Object} Returns the initialized clone.
     */
    function initCloneObject(object) {
      return (typeof object.constructor == 'function' && !isPrototype(object))
        ? baseCreate(getPrototype(object))
        : {};
    }

    module.exports = initCloneObject;

    },{"./_baseCreate":461,"./_getPrototype":503,"./_isPrototype":522}],517:[function(require,module,exports){
    var Symbol = require('./_Symbol'),
        isArguments = require('./isArguments'),
        isArray = require('./isArray');

    /** Built-in value references. */
    var spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;

    /**
     * Checks if `value` is a flattenable `arguments` object or array.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
     */
    function isFlattenable(value) {
      return isArray(value) || isArguments(value) ||
        !!(spreadableSymbol && value && value[spreadableSymbol]);
    }

    module.exports = isFlattenable;

    },{"./_Symbol":443,"./isArguments":561,"./isArray":562}],518:[function(require,module,exports){
    /** Used as references for various `Number` constants. */
    var MAX_SAFE_INTEGER = 9007199254740991;

    /** Used to detect unsigned integer values. */
    var reIsUint = /^(?:0|[1-9]\d*)$/;

    /**
     * Checks if `value` is a valid array-like index.
     *
     * @private
     * @param {*} value The value to check.
     * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
     * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
     */
    function isIndex(value, length) {
      length = length == null ? MAX_SAFE_INTEGER : length;
      return !!length &&
        (typeof value == 'number' || reIsUint.test(value)) &&
        (value > -1 && value % 1 == 0 && value < length);
    }

    module.exports = isIndex;

    },{}],519:[function(require,module,exports){
    var isArray = require('./isArray'),
        isSymbol = require('./isSymbol');

    /** Used to match property names within property paths. */
    var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
        reIsPlainProp = /^\w*$/;

    /**
     * Checks if `value` is a property name and not a property path.
     *
     * @private
     * @param {*} value The value to check.
     * @param {Object} [object] The object to query keys on.
     * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
     */
    function isKey(value, object) {
      if (isArray(value)) {
        return false;
      }
      var type = typeof value;
      if (type == 'number' || type == 'symbol' || type == 'boolean' ||
          value == null || isSymbol(value)) {
        return true;
      }
      return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
        (object != null && value in Object(object));
    }

    module.exports = isKey;

    },{"./isArray":562,"./isSymbol":571}],520:[function(require,module,exports){
    /**
     * Checks if `value` is suitable for use as unique object key.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
     */
    function isKeyable(value) {
      var type = typeof value;
      return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
        ? (value !== '__proto__')
        : (value === null);
    }

    module.exports = isKeyable;

    },{}],521:[function(require,module,exports){
    var coreJsData = require('./_coreJsData');

    /** Used to detect methods masquerading as native. */
    var maskSrcKey = (function() {
      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
      return uid ? ('Symbol(src)_1.' + uid) : '';
    }());

    /**
     * Checks if `func` has its source masked.
     *
     * @private
     * @param {Function} func The function to check.
     * @returns {boolean} Returns `true` if `func` is masked, else `false`.
     */
    function isMasked(func) {
      return !!maskSrcKey && (maskSrcKey in func);
    }

    module.exports = isMasked;

    },{"./_coreJsData":494}],522:[function(require,module,exports){
    /** Used for built-in method references. */
    var objectProto = Object.prototype;

    /**
     * Checks if `value` is likely a prototype object.
     *
     * @private
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
     */
    function isPrototype(value) {
      var Ctor = value && value.constructor,
          proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;

      return value === proto;
    }

    module.exports = isPrototype;

    },{}],523:[function(require,module,exports){
    /**
     * Removes all key-value entries from the list cache.
     *
     * @private
     * @name clear
     * @memberOf ListCache
     */
    function listCacheClear() {
      this.__data__ = [];
      this.size = 0;
    }

    module.exports = listCacheClear;

    },{}],524:[function(require,module,exports){
    var assocIndexOf = require('./_assocIndexOf');

    /** Used for built-in method references. */
    var arrayProto = Array.prototype;

    /** Built-in value references. */
    var splice = arrayProto.splice;

    /**
     * Removes `key` and its value from the list cache.
     *
     * @private
     * @name delete
     * @memberOf ListCache
     * @param {string} key The key of the value to remove.
     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
     */
    function listCacheDelete(key) {
      var data = this.__data__,
          index = assocIndexOf(data, key);

      if (index < 0) {
        return false;
      }
      var lastIndex = data.length - 1;
      if (index == lastIndex) {
        data.pop();
      } else {
        splice.call(data, index, 1);
      }
      --this.size;
      return true;
    }

    module.exports = listCacheDelete;

    },{"./_assocIndexOf":456}],525:[function(require,module,exports){
    var assocIndexOf = require('./_assocIndexOf');

    /**
     * Gets the list cache value for `key`.
     *
     * @private
     * @name get
     * @memberOf ListCache
     * @param {string} key The key of the value to get.
     * @returns {*} Returns the entry value.
     */
    function listCacheGet(key) {
      var data = this.__data__,
          index = assocIndexOf(data, key);

      return index < 0 ? undefined : data[index][1];
    }

    module.exports = listCacheGet;

    },{"./_assocIndexOf":456}],526:[function(require,module,exports){
    var assocIndexOf = require('./_assocIndexOf');

    /**
     * Checks if a list cache value for `key` exists.
     *
     * @private
     * @name has
     * @memberOf ListCache
     * @param {string} key The key of the entry to check.
     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
     */
    function listCacheHas(key) {
      return assocIndexOf(this.__data__, key) > -1;
    }

    module.exports = listCacheHas;

    },{"./_assocIndexOf":456}],527:[function(require,module,exports){
    var assocIndexOf = require('./_assocIndexOf');

    /**
     * Sets the list cache `key` to `value`.
     *
     * @private
     * @name set
     * @memberOf ListCache
     * @param {string} key The key of the value to set.
     * @param {*} value The value to set.
     * @returns {Object} Returns the list cache instance.
     */
    function listCacheSet(key, value) {
      var data = this.__data__,
          index = assocIndexOf(data, key);

      if (index < 0) {
        ++this.size;
        data.push([key, value]);
      } else {
        data[index][1] = value;
      }
      return this;
    }

    module.exports = listCacheSet;

    },{"./_assocIndexOf":456}],528:[function(require,module,exports){
    var Hash = require('./_Hash'),
        ListCache = require('./_ListCache'),
        Map = require('./_Map');

    /**
     * Removes all key-value entries from the map.
     *
     * @private
     * @name clear
     * @memberOf MapCache
     */
    function mapCacheClear() {
      this.size = 0;
      this.__data__ = {
        'hash': new Hash,
        'map': new (Map || ListCache),
        'string': new Hash
      };
    }

    module.exports = mapCacheClear;

    },{"./_Hash":436,"./_ListCache":437,"./_Map":438}],529:[function(require,module,exports){
    var getMapData = require('./_getMapData');

    /**
     * Removes `key` and its value from the map.
     *
     * @private
     * @name delete
     * @memberOf MapCache
     * @param {string} key The key of the value to remove.
     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
     */
    function mapCacheDelete(key) {
      var result = getMapData(this, key)['delete'](key);
      this.size -= result ? 1 : 0;
      return result;
    }

    module.exports = mapCacheDelete;

    },{"./_getMapData":501}],530:[function(require,module,exports){
    var getMapData = require('./_getMapData');

    /**
     * Gets the map value for `key`.
     *
     * @private
     * @name get
     * @memberOf MapCache
     * @param {string} key The key of the value to get.
     * @returns {*} Returns the entry value.
     */
    function mapCacheGet(key) {
      return getMapData(this, key).get(key);
    }

    module.exports = mapCacheGet;

    },{"./_getMapData":501}],531:[function(require,module,exports){
    var getMapData = require('./_getMapData');

    /**
     * Checks if a map value for `key` exists.
     *
     * @private
     * @name has
     * @memberOf MapCache
     * @param {string} key The key of the entry to check.
     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
     */
    function mapCacheHas(key) {
      return getMapData(this, key).has(key);
    }

    module.exports = mapCacheHas;

    },{"./_getMapData":501}],532:[function(require,module,exports){
    var getMapData = require('./_getMapData');

    /**
     * Sets the map `key` to `value`.
     *
     * @private
     * @name set
     * @memberOf MapCache
     * @param {string} key The key of the value to set.
     * @param {*} value The value to set.
     * @returns {Object} Returns the map cache instance.
     */
    function mapCacheSet(key, value) {
      var data = getMapData(this, key),
          size = data.size;

      data.set(key, value);
      this.size += data.size == size ? 0 : 1;
      return this;
    }

    module.exports = mapCacheSet;

    },{"./_getMapData":501}],533:[function(require,module,exports){
    /**
     * Converts `map` to its key-value pairs.
     *
     * @private
     * @param {Object} map The map to convert.
     * @returns {Array} Returns the key-value pairs.
     */
    function mapToArray(map) {
      var index = -1,
          result = Array(map.size);

      map.forEach(function(value, key) {
        result[++index] = [key, value];
      });
      return result;
    }

    module.exports = mapToArray;

    },{}],534:[function(require,module,exports){
    var memoize = require('./memoize');

    /** Used as the maximum memoize cache size. */
    var MAX_MEMOIZE_SIZE = 500;

    /**
     * A specialized version of `_.memoize` which clears the memoized function's
     * cache when it exceeds `MAX_MEMOIZE_SIZE`.
     *
     * @private
     * @param {Function} func The function to have its output memoized.
     * @returns {Function} Returns the new memoized function.
     */
    function memoizeCapped(func) {
      var result = memoize(func, function(key) {
        if (cache.size === MAX_MEMOIZE_SIZE) {
          cache.clear();
        }
        return key;
      });

      var cache = result.cache;
      return result;
    }

    module.exports = memoizeCapped;

    },{"./memoize":576}],535:[function(require,module,exports){
    var getNative = require('./_getNative');

    /* Built-in method references that are verified to be native. */
    var nativeCreate = getNative(Object, 'create');

    module.exports = nativeCreate;

    },{"./_getNative":502}],536:[function(require,module,exports){
    var overArg = require('./_overArg');

    /* Built-in method references for those with the same name as other `lodash` methods. */
    var nativeKeys = overArg(Object.keys, Object);

    module.exports = nativeKeys;

    },{"./_overArg":540}],537:[function(require,module,exports){
    /**
     * This function is like
     * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
     * except that it includes inherited enumerable properties.
     *
     * @private
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names.
     */
    function nativeKeysIn(object) {
      var result = [];
      if (object != null) {
        for (var key in Object(object)) {
          result.push(key);
        }
      }
      return result;
    }

    module.exports = nativeKeysIn;

    },{}],538:[function(require,module,exports){
    var freeGlobal = require('./_freeGlobal');

    /** Detect free variable `exports`. */
    var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;

    /** Detect free variable `module`. */
    var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;

    /** Detect the popular CommonJS extension `module.exports`. */
    var moduleExports = freeModule && freeModule.exports === freeExports;

    /** Detect free variable `process` from Node.js. */
    var freeProcess = moduleExports && freeGlobal.process;

    /** Used to access faster Node.js helpers. */
    var nodeUtil = (function() {
      try {
        return freeProcess && freeProcess.binding && freeProcess.binding('util');
      } catch (e) {}
    }());

    module.exports = nodeUtil;

    },{"./_freeGlobal":498}],539:[function(require,module,exports){
    /** Used for built-in method references. */
    var objectProto = Object.prototype;

    /**
     * Used to resolve the
     * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
     * of values.
     */
    var nativeObjectToString = objectProto.toString;

    /**
     * Converts `value` to a string using `Object.prototype.toString`.
     *
     * @private
     * @param {*} value The value to convert.
     * @returns {string} Returns the converted string.
     */
    function objectToString(value) {
      return nativeObjectToString.call(value);
    }

    module.exports = objectToString;

    },{}],540:[function(require,module,exports){
    /**
     * Creates a unary function that invokes `func` with its argument transformed.
     *
     * @private
     * @param {Function} func The function to wrap.
     * @param {Function} transform The argument transform.
     * @returns {Function} Returns the new function.
     */
    function overArg(func, transform) {
      return function(arg) {
        return func(transform(arg));
      };
    }

    module.exports = overArg;

    },{}],541:[function(require,module,exports){
    var apply = require('./_apply');

    /* Built-in method references for those with the same name as other `lodash` methods. */
    var nativeMax = Math.max;

    /**
     * A specialized version of `baseRest` which transforms the rest array.
     *
     * @private
     * @param {Function} func The function to apply a rest parameter to.
     * @param {number} [start=func.length-1] The start position of the rest parameter.
     * @param {Function} transform The rest array transform.
     * @returns {Function} Returns the new function.
     */
    function overRest(func, start, transform) {
      start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
      return function() {
        var args = arguments,
            index = -1,
            length = nativeMax(args.length - start, 0),
            array = Array(length);

        while (++index < length) {
          array[index] = args[start + index];
        }
        index = -1;
        var otherArgs = Array(start + 1);
        while (++index < start) {
          otherArgs[index] = args[index];
        }
        otherArgs[start] = transform(array);
        return apply(func, this, otherArgs);
      };
    }

    module.exports = overRest;

    },{"./_apply":448}],542:[function(require,module,exports){
    var baseGet = require('./_baseGet'),
        baseSlice = require('./_baseSlice');

    /**
     * Gets the parent value at `path` of `object`.
     *
     * @private
     * @param {Object} object The object to query.
     * @param {Array} path The path to get the parent value of.
     * @returns {*} Returns the parent value.
     */
    function parent(object, path) {
      return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
    }

    module.exports = parent;

    },{"./_baseGet":464,"./_baseSlice":475}],543:[function(require,module,exports){
    var freeGlobal = require('./_freeGlobal');

    /** Detect free variable `self`. */
    var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

    /** Used as a reference to the global object. */
    var root = freeGlobal || freeSelf || Function('return this')();

    module.exports = root;

    },{"./_freeGlobal":498}],544:[function(require,module,exports){
    /**
     * Converts `set` to an array of its values.
     *
     * @private
     * @param {Object} set The set to convert.
     * @returns {Array} Returns the values.
     */
    function setToArray(set) {
      var index = -1,
          result = Array(set.size);

      set.forEach(function(value) {
        result[++index] = value;
      });
      return result;
    }

    module.exports = setToArray;

    },{}],545:[function(require,module,exports){
    var baseSetToString = require('./_baseSetToString'),
        shortOut = require('./_shortOut');

    /**
     * Sets the `toString` method of `func` to return `string`.
     *
     * @private
     * @param {Function} func The function to modify.
     * @param {Function} string The `toString` result.
     * @returns {Function} Returns `func`.
     */
    var setToString = shortOut(baseSetToString);

    module.exports = setToString;

    },{"./_baseSetToString":474,"./_shortOut":546}],546:[function(require,module,exports){
    /** Used to detect hot functions by number of calls within a span of milliseconds. */
    var HOT_COUNT = 800,
        HOT_SPAN = 16;

    /* Built-in method references for those with the same name as other `lodash` methods. */
    var nativeNow = Date.now;

    /**
     * Creates a function that'll short out and invoke `identity` instead
     * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
     * milliseconds.
     *
     * @private
     * @param {Function} func The function to restrict.
     * @returns {Function} Returns the new shortable function.
     */
    function shortOut(func) {
      var count = 0,
          lastCalled = 0;

      return function() {
        var stamp = nativeNow(),
            remaining = HOT_SPAN - (stamp - lastCalled);

        lastCalled = stamp;
        if (remaining > 0) {
          if (++count >= HOT_COUNT) {
            return arguments[0];
          }
        } else {
          count = 0;
        }
        return func.apply(undefined, arguments);
      };
    }

    module.exports = shortOut;

    },{}],547:[function(require,module,exports){
    var ListCache = require('./_ListCache');

    /**
     * Removes all key-value entries from the stack.
     *
     * @private
     * @name clear
     * @memberOf Stack
     */
    function stackClear() {
      this.__data__ = new ListCache;
      this.size = 0;
    }

    module.exports = stackClear;

    },{"./_ListCache":437}],548:[function(require,module,exports){
    /**
     * Removes `key` and its value from the stack.
     *
     * @private
     * @name delete
     * @memberOf Stack
     * @param {string} key The key of the value to remove.
     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
     */
    function stackDelete(key) {
      var data = this.__data__,
          result = data['delete'](key);

      this.size = data.size;
      return result;
    }

    module.exports = stackDelete;

    },{}],549:[function(require,module,exports){
    /**
     * Gets the stack value for `key`.
     *
     * @private
     * @name get
     * @memberOf Stack
     * @param {string} key The key of the value to get.
     * @returns {*} Returns the entry value.
     */
    function stackGet(key) {
      return this.__data__.get(key);
    }

    module.exports = stackGet;

    },{}],550:[function(require,module,exports){
    /**
     * Checks if a stack value for `key` exists.
     *
     * @private
     * @name has
     * @memberOf Stack
     * @param {string} key The key of the entry to check.
     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
     */
    function stackHas(key) {
      return this.__data__.has(key);
    }

    module.exports = stackHas;

    },{}],551:[function(require,module,exports){
    var ListCache = require('./_ListCache'),
        Map = require('./_Map'),
        MapCache = require('./_MapCache');

    /** Used as the size to enable large array optimizations. */
    var LARGE_ARRAY_SIZE = 200;

    /**
     * Sets the stack `key` to `value`.
     *
     * @private
     * @name set
     * @memberOf Stack
     * @param {string} key The key of the value to set.
     * @param {*} value The value to set.
     * @returns {Object} Returns the stack cache instance.
     */
    function stackSet(key, value) {
      var data = this.__data__;
      if (data instanceof ListCache) {
        var pairs = data.__data__;
        if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
          pairs.push([key, value]);
          this.size = ++data.size;
          return this;
        }
        data = this.__data__ = new MapCache(pairs);
      }
      data.set(key, value);
      this.size = data.size;
      return this;
    }

    module.exports = stackSet;

    },{"./_ListCache":437,"./_Map":438,"./_MapCache":439}],552:[function(require,module,exports){
    /**
     * A specialized version of `_.indexOf` which performs strict equality
     * comparisons of values, i.e. `===`.
     *
     * @private
     * @param {Array} array The array to inspect.
     * @param {*} value The value to search for.
     * @param {number} fromIndex The index to search from.
     * @returns {number} Returns the index of the matched value, else `-1`.
     */
    function strictIndexOf(array, value, fromIndex) {
      var index = fromIndex - 1,
          length = array.length;

      while (++index < length) {
        if (array[index] === value) {
          return index;
        }
      }
      return -1;
    }

    module.exports = strictIndexOf;

    },{}],553:[function(require,module,exports){
    var memoizeCapped = require('./_memoizeCapped');

    /** Used to match property names within property paths. */
    var reLeadingDot = /^\./,
        rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;

    /** Used to match backslashes in property paths. */
    var reEscapeChar = /\\(\\)?/g;

    /**
     * Converts `string` to a property path array.
     *
     * @private
     * @param {string} string The string to convert.
     * @returns {Array} Returns the property path array.
     */
    var stringToPath = memoizeCapped(function(string) {
      var result = [];
      if (reLeadingDot.test(string)) {
        result.push('');
      }
      string.replace(rePropName, function(match, number, quote, string) {
        result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
      });
      return result;
    });

    module.exports = stringToPath;

    },{"./_memoizeCapped":534}],554:[function(require,module,exports){
    var isSymbol = require('./isSymbol');

    /** Used as references for various `Number` constants. */
    var INFINITY = 1 / 0;

    /**
     * Converts `value` to a string key if it's not a string or symbol.
     *
     * @private
     * @param {*} value The value to inspect.
     * @returns {string|symbol} Returns the key.
     */
    function toKey(value) {
      if (typeof value == 'string' || isSymbol(value)) {
        return value;
      }
      var result = (value + '');
      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
    }

    module.exports = toKey;

    },{"./isSymbol":571}],555:[function(require,module,exports){
    /** Used for built-in method references. */
    var funcProto = Function.prototype;

    /** Used to resolve the decompiled source of functions. */
    var funcToString = funcProto.toString;

    /**
     * Converts `func` to its source code.
     *
     * @private
     * @param {Function} func The function to convert.
     * @returns {string} Returns the source code.
     */
    function toSource(func) {
      if (func != null) {
        try {
          return funcToString.call(func);
        } catch (e) {}
        try {
          return (func + '');
        } catch (e) {}
      }
      return '';
    }

    module.exports = toSource;

    },{}],556:[function(require,module,exports){
    /**
     * Creates a function that returns `value`.
     *
     * @static
     * @memberOf _
     * @since 2.4.0
     * @category Util
     * @param {*} value The value to return from the new function.
     * @returns {Function} Returns the new constant function.
     * @example
     *
     * var objects = _.times(2, _.constant({ 'a': 1 }));
     *
     * console.log(objects);
     * // => [{ 'a': 1 }, { 'a': 1 }]
     *
     * console.log(objects[0] === objects[1]);
     * // => true
     */
    function constant(value) {
      return function() {
        return value;
      };
    }

    module.exports = constant;

    },{}],557:[function(require,module,exports){
    /**
     * Performs a
     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * comparison between two values to determine if they are equivalent.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to compare.
     * @param {*} other The other value to compare.
     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
     * @example
     *
     * var object = { 'a': 1 };
     * var other = { 'a': 1 };
     *
     * _.eq(object, object);
     * // => true
     *
     * _.eq(object, other);
     * // => false
     *
     * _.eq('a', 'a');
     * // => true
     *
     * _.eq('a', Object('a'));
     * // => false
     *
     * _.eq(NaN, NaN);
     * // => true
     */
    function eq(value, other) {
      return value === other || (value !== value && other !== other);
    }

    module.exports = eq;

    },{}],558:[function(require,module,exports){
    var baseFlatten = require('./_baseFlatten');

    /**
     * Flattens `array` a single level deep.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to flatten.
     * @returns {Array} Returns the new flattened array.
     * @example
     *
     * _.flatten([1, [2, [3, [4]], 5]]);
     * // => [1, 2, [3, [4]], 5]
     */
    function flatten(array) {
      var length = array == null ? 0 : array.length;
      return length ? baseFlatten(array, 1) : [];
    }

    module.exports = flatten;

    },{"./_baseFlatten":463}],559:[function(require,module,exports){
    /**
     * This method returns the first argument it receives.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Util
     * @param {*} value Any value.
     * @returns {*} Returns `value`.
     * @example
     *
     * var object = { 'a': 1 };
     *
     * console.log(_.identity(object) === object);
     * // => true
     */
    function identity(value) {
      return value;
    }

    module.exports = identity;

    },{}],560:[function(require,module,exports){
    var baseIndexOf = require('./_baseIndexOf'),
        isArrayLike = require('./isArrayLike'),
        isString = require('./isString'),
        toInteger = require('./toInteger'),
        values = require('./values');

    /* Built-in method references for those with the same name as other `lodash` methods. */
    var nativeMax = Math.max;

    /**
     * Checks if `value` is in `collection`. If `collection` is a string, it's
     * checked for a substring of `value`, otherwise
     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
     * is used for equality comparisons. If `fromIndex` is negative, it's used as
     * the offset from the end of `collection`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Collection
     * @param {Array|Object|string} collection The collection to inspect.
     * @param {*} value The value to search for.
     * @param {number} [fromIndex=0] The index to search from.
     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
     * @returns {boolean} Returns `true` if `value` is found, else `false`.
     * @example
     *
     * _.includes([1, 2, 3], 1);
     * // => true
     *
     * _.includes([1, 2, 3], 1, 2);
     * // => false
     *
     * _.includes({ 'a': 1, 'b': 2 }, 1);
     * // => true
     *
     * _.includes('abcd', 'bc');
     * // => true
     */
    function includes(collection, value, fromIndex, guard) {
      collection = isArrayLike(collection) ? collection : values(collection);
      fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;

      var length = collection.length;
      if (fromIndex < 0) {
        fromIndex = nativeMax(length + fromIndex, 0);
      }
      return isString(collection)
        ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)
        : (!!length && baseIndexOf(collection, value, fromIndex) > -1);
    }

    module.exports = includes;

    },{"./_baseIndexOf":467,"./isArrayLike":563,"./isString":570,"./toInteger":581,"./values":584}],561:[function(require,module,exports){
    var baseIsArguments = require('./_baseIsArguments'),
        isObjectLike = require('./isObjectLike');

    /** Used for built-in method references. */
    var objectProto = Object.prototype;

    /** Used to check objects for own properties. */
    var hasOwnProperty = objectProto.hasOwnProperty;

    /** Built-in value references. */
    var propertyIsEnumerable = objectProto.propertyIsEnumerable;

    /**
     * Checks if `value` is likely an `arguments` object.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an `arguments` object,
     *  else `false`.
     * @example
     *
     * _.isArguments(function() { return arguments; }());
     * // => true
     *
     * _.isArguments([1, 2, 3]);
     * // => false
     */
    var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
      return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
        !propertyIsEnumerable.call(value, 'callee');
    };

    module.exports = isArguments;

    },{"./_baseIsArguments":468,"./isObjectLike":568}],562:[function(require,module,exports){
    /**
     * Checks if `value` is classified as an `Array` object.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an array, else `false`.
     * @example
     *
     * _.isArray([1, 2, 3]);
     * // => true
     *
     * _.isArray(document.body.children);
     * // => false
     *
     * _.isArray('abc');
     * // => false
     *
     * _.isArray(_.noop);
     * // => false
     */
    var isArray = Array.isArray;

    module.exports = isArray;

    },{}],563:[function(require,module,exports){
    var isFunction = require('./isFunction'),
        isLength = require('./isLength');

    /**
     * Checks if `value` is array-like. A value is considered array-like if it's
     * not a function and has a `value.length` that's an integer greater than or
     * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
     * @example
     *
     * _.isArrayLike([1, 2, 3]);
     * // => true
     *
     * _.isArrayLike(document.body.children);
     * // => true
     *
     * _.isArrayLike('abc');
     * // => true
     *
     * _.isArrayLike(_.noop);
     * // => false
     */
    function isArrayLike(value) {
      return value != null && isLength(value.length) && !isFunction(value);
    }

    module.exports = isArrayLike;

    },{"./isFunction":565,"./isLength":566}],564:[function(require,module,exports){
    var root = require('./_root'),
        stubFalse = require('./stubFalse');

    /** Detect free variable `exports`. */
    var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;

    /** Detect free variable `module`. */
    var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;

    /** Detect the popular CommonJS extension `module.exports`. */
    var moduleExports = freeModule && freeModule.exports === freeExports;

    /** Built-in value references. */
    var Buffer = moduleExports ? root.Buffer : undefined;

    /* Built-in method references for those with the same name as other `lodash` methods. */
    var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;

    /**
     * Checks if `value` is a buffer.
     *
     * @static
     * @memberOf _
     * @since 4.3.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
     * @example
     *
     * _.isBuffer(new Buffer(2));
     * // => true
     *
     * _.isBuffer(new Uint8Array(2));
     * // => false
     */
    var isBuffer = nativeIsBuffer || stubFalse;

    module.exports = isBuffer;

    },{"./_root":543,"./stubFalse":579}],565:[function(require,module,exports){
    var baseGetTag = require('./_baseGetTag'),
        isObject = require('./isObject');

    /** `Object#toString` result references. */
    var asyncTag = '[object AsyncFunction]',
        funcTag = '[object Function]',
        genTag = '[object GeneratorFunction]',
        proxyTag = '[object Proxy]';

    /**
     * Checks if `value` is classified as a `Function` object.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a function, else `false`.
     * @example
     *
     * _.isFunction(_);
     * // => true
     *
     * _.isFunction(/abc/);
     * // => false
     */
    function isFunction(value) {
      if (!isObject(value)) {
        return false;
      }
      // The use of `Object#toString` avoids issues with the `typeof` operator
      // in Safari 9 which returns 'object' for typed arrays and other constructors.
      var tag = baseGetTag(value);
      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
    }

    module.exports = isFunction;

    },{"./_baseGetTag":466,"./isObject":567}],566:[function(require,module,exports){
    /** Used as references for various `Number` constants. */
    var MAX_SAFE_INTEGER = 9007199254740991;

    /**
     * Checks if `value` is a valid array-like length.
     *
     * **Note:** This method is loosely based on
     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
     * @example
     *
     * _.isLength(3);
     * // => true
     *
     * _.isLength(Number.MIN_VALUE);
     * // => false
     *
     * _.isLength(Infinity);
     * // => false
     *
     * _.isLength('3');
     * // => false
     */
    function isLength(value) {
      return typeof value == 'number' &&
        value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
    }

    module.exports = isLength;

    },{}],567:[function(require,module,exports){
    /**
     * Checks if `value` is the
     * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
     * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is an object, else `false`.
     * @example
     *
     * _.isObject({});
     * // => true
     *
     * _.isObject([1, 2, 3]);
     * // => true
     *
     * _.isObject(_.noop);
     * // => true
     *
     * _.isObject(null);
     * // => false
     */
    function isObject(value) {
      var type = typeof value;
      return value != null && (type == 'object' || type == 'function');
    }

    module.exports = isObject;

    },{}],568:[function(require,module,exports){
    /**
     * Checks if `value` is object-like. A value is object-like if it's not `null`
     * and has a `typeof` result of "object".
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
     * @example
     *
     * _.isObjectLike({});
     * // => true
     *
     * _.isObjectLike([1, 2, 3]);
     * // => true
     *
     * _.isObjectLike(_.noop);
     * // => false
     *
     * _.isObjectLike(null);
     * // => false
     */
    function isObjectLike(value) {
      return value != null && typeof value == 'object';
    }

    module.exports = isObjectLike;

    },{}],569:[function(require,module,exports){
    var baseGetTag = require('./_baseGetTag'),
        getPrototype = require('./_getPrototype'),
        isObjectLike = require('./isObjectLike');

    /** `Object#toString` result references. */
    var objectTag = '[object Object]';

    /** Used for built-in method references. */
    var funcProto = Function.prototype,
        objectProto = Object.prototype;

    /** Used to resolve the decompiled source of functions. */
    var funcToString = funcProto.toString;

    /** Used to check objects for own properties. */
    var hasOwnProperty = objectProto.hasOwnProperty;

    /** Used to infer the `Object` constructor. */
    var objectCtorString = funcToString.call(Object);

    /**
     * Checks if `value` is a plain object, that is, an object created by the
     * `Object` constructor or one with a `[[Prototype]]` of `null`.
     *
     * @static
     * @memberOf _
     * @since 0.8.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     * }
     *
     * _.isPlainObject(new Foo);
     * // => false
     *
     * _.isPlainObject([1, 2, 3]);
     * // => false
     *
     * _.isPlainObject({ 'x': 0, 'y': 0 });
     * // => true
     *
     * _.isPlainObject(Object.create(null));
     * // => true
     */
    function isPlainObject(value) {
      if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
        return false;
      }
      var proto = getPrototype(value);
      if (proto === null) {
        return true;
      }
      var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
      return typeof Ctor == 'function' && Ctor instanceof Ctor &&
        funcToString.call(Ctor) == objectCtorString;
    }

    module.exports = isPlainObject;

    },{"./_baseGetTag":466,"./_getPrototype":503,"./isObjectLike":568}],570:[function(require,module,exports){
    var baseGetTag = require('./_baseGetTag'),
        isArray = require('./isArray'),
        isObjectLike = require('./isObjectLike');

    /** `Object#toString` result references. */
    var stringTag = '[object String]';

    /**
     * Checks if `value` is classified as a `String` primitive or object.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a string, else `false`.
     * @example
     *
     * _.isString('abc');
     * // => true
     *
     * _.isString(1);
     * // => false
     */
    function isString(value) {
      return typeof value == 'string' ||
        (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);
    }

    module.exports = isString;

    },{"./_baseGetTag":466,"./isArray":562,"./isObjectLike":568}],571:[function(require,module,exports){
    var baseGetTag = require('./_baseGetTag'),
        isObjectLike = require('./isObjectLike');

    /** `Object#toString` result references. */
    var symbolTag = '[object Symbol]';

    /**
     * Checks if `value` is classified as a `Symbol` primitive or object.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
     * @example
     *
     * _.isSymbol(Symbol.iterator);
     * // => true
     *
     * _.isSymbol('abc');
     * // => false
     */
    function isSymbol(value) {
      return typeof value == 'symbol' ||
        (isObjectLike(value) && baseGetTag(value) == symbolTag);
    }

    module.exports = isSymbol;

    },{"./_baseGetTag":466,"./isObjectLike":568}],572:[function(require,module,exports){
    var baseIsTypedArray = require('./_baseIsTypedArray'),
        baseUnary = require('./_baseUnary'),
        nodeUtil = require('./_nodeUtil');

    /* Node.js helper references. */
    var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;

    /**
     * Checks if `value` is classified as a typed array.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Lang
     * @param {*} value The value to check.
     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
     * @example
     *
     * _.isTypedArray(new Uint8Array);
     * // => true
     *
     * _.isTypedArray([]);
     * // => false
     */
    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;

    module.exports = isTypedArray;

    },{"./_baseIsTypedArray":471,"./_baseUnary":478,"./_nodeUtil":538}],573:[function(require,module,exports){
    var arrayLikeKeys = require('./_arrayLikeKeys'),
        baseKeys = require('./_baseKeys'),
        isArrayLike = require('./isArrayLike');

    /**
     * Creates an array of the own enumerable property names of `object`.
     *
     * **Note:** Non-object values are coerced to objects. See the
     * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
     * for more details.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names.
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.keys(new Foo);
     * // => ['a', 'b'] (iteration order is not guaranteed)
     *
     * _.keys('hi');
     * // => ['0', '1']
     */
    function keys(object) {
      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
    }

    module.exports = keys;

    },{"./_arrayLikeKeys":451,"./_baseKeys":472,"./isArrayLike":563}],574:[function(require,module,exports){
    var arrayLikeKeys = require('./_arrayLikeKeys'),
        baseKeysIn = require('./_baseKeysIn'),
        isArrayLike = require('./isArrayLike');

    /**
     * Creates an array of the own and inherited enumerable property names of `object`.
     *
     * **Note:** Non-object values are coerced to objects.
     *
     * @static
     * @memberOf _
     * @since 3.0.0
     * @category Object
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property names.
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.keysIn(new Foo);
     * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
     */
    function keysIn(object) {
      return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
    }

    module.exports = keysIn;

    },{"./_arrayLikeKeys":451,"./_baseKeysIn":473,"./isArrayLike":563}],575:[function(require,module,exports){
    /**
     * Gets the last element of `array`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Array
     * @param {Array} array The array to query.
     * @returns {*} Returns the last element of `array`.
     * @example
     *
     * _.last([1, 2, 3]);
     * // => 3
     */
    function last(array) {
      var length = array == null ? 0 : array.length;
      return length ? array[length - 1] : undefined;
    }

    module.exports = last;

    },{}],576:[function(require,module,exports){
    var MapCache = require('./_MapCache');

    /** Error message constants. */
    var FUNC_ERROR_TEXT = 'Expected a function';

    /**
     * Creates a function that memoizes the result of `func`. If `resolver` is
     * provided, it determines the cache key for storing the result based on the
     * arguments provided to the memoized function. By default, the first argument
     * provided to the memoized function is used as the map cache key. The `func`
     * is invoked with the `this` binding of the memoized function.
     *
     * **Note:** The cache is exposed as the `cache` property on the memoized
     * function. Its creation may be customized by replacing the `_.memoize.Cache`
     * constructor with one whose instances implement the
     * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
     * method interface of `clear`, `delete`, `get`, `has`, and `set`.
     *
     * @static
     * @memberOf _
     * @since 0.1.0
     * @category Function
     * @param {Function} func The function to have its output memoized.
     * @param {Function} [resolver] The function to resolve the cache key.
     * @returns {Function} Returns the new memoized function.
     * @example
     *
     * var object = { 'a': 1, 'b': 2 };
     * var other = { 'c': 3, 'd': 4 };
     *
     * var values = _.memoize(_.values);
     * values(object);
     * // => [1, 2]
     *
     * values(other);
     * // => [3, 4]
     *
     * object.a = 2;
     * values(object);
     * // => [1, 2]
     *
     * // Modify the result cache.
     * values.cache.set(object, ['a', 'b']);
     * values(object);
     * // => ['a', 'b']
     *
     * // Replace `_.memoize.Cache`.
     * _.memoize.Cache = WeakMap;
     */
    function memoize(func, resolver) {
      if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
        throw new TypeError(FUNC_ERROR_TEXT);
      }
      var memoized = function() {
        var args = arguments,
            key = resolver ? resolver.apply(this, args) : args[0],
            cache = memoized.cache;

        if (cache.has(key)) {
          return cache.get(key);
        }
        var result = func.apply(this, args);
        memoized.cache = cache.set(key, result) || cache;
        return result;
      };
      memoized.cache = new (memoize.Cache || MapCache);
      return memoized;
    }

    // Expose `MapCache`.
    memoize.Cache = MapCache;

    module.exports = memoize;

    },{"./_MapCache":439}],577:[function(require,module,exports){
    var arrayMap = require('./_arrayMap'),
        baseClone = require('./_baseClone'),
        baseUnset = require('./_baseUnset'),
        castPath = require('./_castPath'),
        copyObject = require('./_copyObject'),
        customOmitClone = require('./_customOmitClone'),
        flatRest = require('./_flatRest'),
        getAllKeysIn = require('./_getAllKeysIn');

    /** Used to compose bitmasks for cloning. */
    var CLONE_DEEP_FLAG = 1,
        CLONE_FLAT_FLAG = 2,
        CLONE_SYMBOLS_FLAG = 4;

    /**
     * The opposite of `_.pick`; this method creates an object composed of the
     * own and inherited enumerable property paths of `object` that are not omitted.
     *
     * **Note:** This method is considerably slower than `_.pick`.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The source object.
     * @param {...(string|string[])} [paths] The property paths to omit.
     * @returns {Object} Returns the new object.
     * @example
     *
     * var object = { 'a': 1, 'b': '2', 'c': 3 };
     *
     * _.omit(object, ['a', 'c']);
     * // => { 'b': '2' }
     */
    var omit = flatRest(function(object, paths) {
      var result = {};
      if (object == null) {
        return result;
      }
      var isDeep = false;
      paths = arrayMap(paths, function(path) {
        path = castPath(path, object);
        isDeep || (isDeep = path.length > 1);
        return path;
      });
      copyObject(object, getAllKeysIn(object), result);
      if (isDeep) {
        result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
      }
      var length = paths.length;
      while (length--) {
        baseUnset(result, paths[length]);
      }
      return result;
    });

    module.exports = omit;

    },{"./_arrayMap":452,"./_baseClone":460,"./_baseUnset":479,"./_castPath":481,"./_copyObject":491,"./_customOmitClone":495,"./_flatRest":497,"./_getAllKeysIn":500}],578:[function(require,module,exports){
    /**
     * This method returns a new empty array.
     *
     * @static
     * @memberOf _
     * @since 4.13.0
     * @category Util
     * @returns {Array} Returns the new empty array.
     * @example
     *
     * var arrays = _.times(2, _.stubArray);
     *
     * console.log(arrays);
     * // => [[], []]
     *
     * console.log(arrays[0] === arrays[1]);
     * // => false
     */
    function stubArray() {
      return [];
    }

    module.exports = stubArray;

    },{}],579:[function(require,module,exports){
    /**
     * This method returns `false`.
     *
     * @static
     * @memberOf _
     * @since 4.13.0
     * @category Util
     * @returns {boolean} Returns `false`.
     * @example
     *
     * _.times(2, _.stubFalse);
     * // => [false, false]
     */
    function stubFalse() {
      return false;
    }

    module.exports = stubFalse;

    },{}],580:[function(require,module,exports){
    var toNumber = require('./toNumber');

    /** Used as references for various `Number` constants. */
    var INFINITY = 1 / 0,
        MAX_INTEGER = 1.7976931348623157e+308;

    /**
     * Converts `value` to a finite number.
     *
     * @static
     * @memberOf _
     * @since 4.12.0
     * @category Lang
     * @param {*} value The value to convert.
     * @returns {number} Returns the converted number.
     * @example
     *
     * _.toFinite(3.2);
     * // => 3.2
     *
     * _.toFinite(Number.MIN_VALUE);
     * // => 5e-324
     *
     * _.toFinite(Infinity);
     * // => 1.7976931348623157e+308
     *
     * _.toFinite('3.2');
     * // => 3.2
     */
    function toFinite(value) {
      if (!value) {
        return value === 0 ? value : 0;
      }
      value = toNumber(value);
      if (value === INFINITY || value === -INFINITY) {
        var sign = (value < 0 ? -1 : 1);
        return sign * MAX_INTEGER;
      }
      return value === value ? value : 0;
    }

    module.exports = toFinite;

    },{"./toNumber":582}],581:[function(require,module,exports){
    var toFinite = require('./toFinite');

    /**
     * Converts `value` to an integer.
     *
     * **Note:** This method is loosely based on
     * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to convert.
     * @returns {number} Returns the converted integer.
     * @example
     *
     * _.toInteger(3.2);
     * // => 3
     *
     * _.toInteger(Number.MIN_VALUE);
     * // => 0
     *
     * _.toInteger(Infinity);
     * // => 1.7976931348623157e+308
     *
     * _.toInteger('3.2');
     * // => 3
     */
    function toInteger(value) {
      var result = toFinite(value),
          remainder = result % 1;

      return result === result ? (remainder ? result - remainder : result) : 0;
    }

    module.exports = toInteger;

    },{"./toFinite":580}],582:[function(require,module,exports){
    var isObject = require('./isObject'),
        isSymbol = require('./isSymbol');

    /** Used as references for various `Number` constants. */
    var NAN = 0 / 0;

    /** Used to match leading and trailing whitespace. */
    var reTrim = /^\s+|\s+$/g;

    /** Used to detect bad signed hexadecimal string values. */
    var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;

    /** Used to detect binary string values. */
    var reIsBinary = /^0b[01]+$/i;

    /** Used to detect octal string values. */
    var reIsOctal = /^0o[0-7]+$/i;

    /** Built-in method references without a dependency on `root`. */
    var freeParseInt = parseInt;

    /**
     * Converts `value` to a number.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to process.
     * @returns {number} Returns the number.
     * @example
     *
     * _.toNumber(3.2);
     * // => 3.2
     *
     * _.toNumber(Number.MIN_VALUE);
     * // => 5e-324
     *
     * _.toNumber(Infinity);
     * // => Infinity
     *
     * _.toNumber('3.2');
     * // => 3.2
     */
    function toNumber(value) {
      if (typeof value == 'number') {
        return value;
      }
      if (isSymbol(value)) {
        return NAN;
      }
      if (isObject(value)) {
        var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
        value = isObject(other) ? (other + '') : other;
      }
      if (typeof value != 'string') {
        return value === 0 ? value : +value;
      }
      value = value.replace(reTrim, '');
      var isBinary = reIsBinary.test(value);
      return (isBinary || reIsOctal.test(value))
        ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
        : (reIsBadHex.test(value) ? NAN : +value);
    }

    module.exports = toNumber;

    },{"./isObject":567,"./isSymbol":571}],583:[function(require,module,exports){
    var baseToString = require('./_baseToString');

    /**
     * Converts `value` to a string. An empty string is returned for `null`
     * and `undefined` values. The sign of `-0` is preserved.
     *
     * @static
     * @memberOf _
     * @since 4.0.0
     * @category Lang
     * @param {*} value The value to convert.
     * @returns {string} Returns the converted string.
     * @example
     *
     * _.toString(null);
     * // => ''
     *
     * _.toString(-0);
     * // => '-0'
     *
     * _.toString([1, 2, 3]);
     * // => '1,2,3'
     */
    function toString(value) {
      return value == null ? '' : baseToString(value);
    }

    module.exports = toString;

    },{"./_baseToString":477}],584:[function(require,module,exports){
    var baseValues = require('./_baseValues'),
        keys = require('./keys');

    /**
     * Creates an array of the own enumerable string keyed property values of `object`.
     *
     * **Note:** Non-object values are coerced to objects.
     *
     * @static
     * @since 0.1.0
     * @memberOf _
     * @category Object
     * @param {Object} object The object to query.
     * @returns {Array} Returns the array of property values.
     * @example
     *
     * function Foo() {
     *   this.a = 1;
     *   this.b = 2;
     * }
     *
     * Foo.prototype.c = 3;
     *
     * _.values(new Foo);
     * // => [1, 2] (iteration order is not guaranteed)
     *
     * _.values('hi');
     * // => ['h', 'i']
     */
    function values(object) {
      return object == null ? [] : baseValues(object, keys(object));
    }

    module.exports = values;

    },{"./_baseValues":480,"./keys":573}],585:[function(require,module,exports){
    module.exports = require('react/lib/update');

    },{"react/lib/update":611}],586:[function(require,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;

    },{}],587:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var invariant = require('fbjs/lib/invariant');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./reactProdInvariant":609,"_process":728,"fbjs/lib/invariant":615}],588:[function(require,module,exports){
    (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 = require('object-assign');

    var ReactChildren = require('./ReactChildren');
    var ReactComponent = require('./ReactComponent');
    var ReactPureComponent = require('./ReactPureComponent');
    var ReactClass = require('./ReactClass');
    var ReactDOMFactories = require('./ReactDOMFactories');
    var ReactElement = require('./ReactElement');
    var ReactPropTypes = require('./ReactPropTypes');
    var ReactVersion = require('./ReactVersion');

    var onlyChild = require('./onlyChild');
    var warning = require('fbjs/lib/warning');

    var createElement = ReactElement.createElement;
    var createFactory = ReactElement.createFactory;
    var cloneElement = ReactElement.cloneElement;

    if (process.env.NODE_ENV !== 'production') {
      var ReactElementValidator = require('./ReactElementValidator');
      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;

    }).call(this,require('_process'))
    },{"./ReactChildren":589,"./ReactClass":590,"./ReactComponent":591,"./ReactDOMFactories":594,"./ReactElement":595,"./ReactElementValidator":597,"./ReactPropTypes":600,"./ReactPureComponent":602,"./ReactVersion":604,"./onlyChild":608,"_process":728,"fbjs/lib/warning":616,"object-assign":617}],589:[function(require,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 PooledClass = require('./PooledClass');
    var ReactElement = require('./ReactElement');

    var emptyFunction = require('fbjs/lib/emptyFunction');
    var traverseAllChildren = require('./traverseAllChildren');

    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;

    },{"./PooledClass":587,"./ReactElement":595,"./traverseAllChildren":610,"fbjs/lib/emptyFunction":613}],590:[function(require,module,exports){
    (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 = require('./reactProdInvariant'),
        _assign = require('object-assign');

    var ReactComponent = require('./ReactComponent');
    var ReactElement = require('./ReactElement');
    var ReactPropTypeLocationNames = require('./ReactPropTypeLocationNames');
    var ReactNoopUpdateQueue = require('./ReactNoopUpdateQueue');

    var emptyObject = require('fbjs/lib/emptyObject');
    var invariant = require('fbjs/lib/invariant');
    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"./ReactComponent":591,"./ReactElement":595,"./ReactNoopUpdateQueue":598,"./ReactPropTypeLocationNames":599,"./reactProdInvariant":609,"_process":728,"fbjs/lib/emptyObject":614,"fbjs/lib/invariant":615,"fbjs/lib/warning":616,"object-assign":617}],591:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var ReactNoopUpdateQueue = require('./ReactNoopUpdateQueue');

    var canDefineProperty = require('./canDefineProperty');
    var emptyObject = require('fbjs/lib/emptyObject');
    var invariant = require('fbjs/lib/invariant');
    var warning = require('fbjs/lib/warning');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./ReactNoopUpdateQueue":598,"./canDefineProperty":605,"./reactProdInvariant":609,"_process":728,"fbjs/lib/emptyObject":614,"fbjs/lib/invariant":615,"fbjs/lib/warning":616}],592:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var ReactCurrentOwner = require('./ReactCurrentOwner');

    var invariant = require('fbjs/lib/invariant');
    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"./ReactCurrentOwner":593,"./reactProdInvariant":609,"_process":728,"fbjs/lib/invariant":615,"fbjs/lib/warning":616}],593:[function(require,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;

    },{}],594:[function(require,module,exports){
    (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 = require('./ReactElement');

    /**
     * Create a factory that creates HTML tag elements.
     *
     * @private
     */
    var createDOMFactory = ReactElement.createFactory;
    if (process.env.NODE_ENV !== 'production') {
      var ReactElementValidator = require('./ReactElementValidator');
      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;

    }).call(this,require('_process'))
    },{"./ReactElement":595,"./ReactElementValidator":597,"_process":728}],595:[function(require,module,exports){
    (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 = require('object-assign');

    var ReactCurrentOwner = require('./ReactCurrentOwner');

    var warning = require('fbjs/lib/warning');
    var canDefineProperty = require('./canDefineProperty');
    var hasOwnProperty = Object.prototype.hasOwnProperty;

    var REACT_ELEMENT_TYPE = require('./ReactElementSymbol');

    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;

    }).call(this,require('_process'))
    },{"./ReactCurrentOwner":593,"./ReactElementSymbol":596,"./canDefineProperty":605,"_process":728,"fbjs/lib/warning":616,"object-assign":617}],596:[function(require,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;

    },{}],597:[function(require,module,exports){
    (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 = require('./ReactCurrentOwner');
    var ReactComponentTreeHook = require('./ReactComponentTreeHook');
    var ReactElement = require('./ReactElement');

    var checkReactTypeSpec = require('./checkReactTypeSpec');

    var canDefineProperty = require('./canDefineProperty');
    var getIteratorFn = require('./getIteratorFn');
    var warning = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"./ReactComponentTreeHook":592,"./ReactCurrentOwner":593,"./ReactElement":595,"./canDefineProperty":605,"./checkReactTypeSpec":606,"./getIteratorFn":607,"_process":728,"fbjs/lib/warning":616}],598:[function(require,module,exports){
    (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 = require('fbjs/lib/warning');

    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;

    }).call(this,require('_process'))
    },{"_process":728,"fbjs/lib/warning":616}],599:[function(require,module,exports){
    (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;

    }).call(this,require('_process'))
    },{"_process":728}],600:[function(require,module,exports){
    (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 = require('./ReactElement');
    var ReactPropTypeLocationNames = require('./ReactPropTypeLocationNames');
    var ReactPropTypesSecret = require('./ReactPropTypesSecret');

    var emptyFunction = require('fbjs/lib/emptyFunction');
    var getIteratorFn = require('./getIteratorFn');
    var warning = require('fbjs/lib/warning');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./ReactElement":595,"./ReactPropTypeLocationNames":599,"./ReactPropTypesSecret":601,"./getIteratorFn":607,"_process":728,"fbjs/lib/emptyFunction":613,"fbjs/lib/warning":616}],601:[function(require,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;

    },{}],602:[function(require,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 _assign = require('object-assign');

    var ReactComponent = require('./ReactComponent');
    var ReactNoopUpdateQueue = require('./ReactNoopUpdateQueue');

    var emptyObject = require('fbjs/lib/emptyObject');

    /**
     * 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;

    },{"./ReactComponent":591,"./ReactNoopUpdateQueue":598,"fbjs/lib/emptyObject":614,"object-assign":617}],603:[function(require,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 ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');

    var getVendorPrefixedEventName = require('react-dom/lib/getVendorPrefixedEventName');

    var endEvents = [];

    function detectEvents() {
      var animEnd = getVendorPrefixedEventName('animationend');
      var transEnd = getVendorPrefixedEventName('transitionend');

      if (animEnd) {
        endEvents.push(animEnd);
      }

      if (transEnd) {
        endEvents.push(transEnd);
      }
    }

    if (ExecutionEnvironment.canUseDOM) {
      detectEvents();
    }

    // We use the raw {add|remove}EventListener() call because EventListener
    // does not know how to remove event listeners and we really should
    // clean up. Also, these events are not triggered in older browsers
    // so we should be A-OK here.

    function addEventListener(node, eventName, eventListener) {
      node.addEventListener(eventName, eventListener, false);
    }

    function removeEventListener(node, eventName, eventListener) {
      node.removeEventListener(eventName, eventListener, false);
    }

    var ReactTransitionEvents = {
      addEndEventListener: function (node, eventListener) {
        if (endEvents.length === 0) {
          // If CSS transitions are not supported, trigger an "end animation"
          // event immediately.
          window.setTimeout(eventListener, 0);
          return;
        }
        endEvents.forEach(function (endEvent) {
          addEventListener(node, endEvent, eventListener);
        });
      },

      removeEndEventListener: function (node, eventListener) {
        if (endEvents.length === 0) {
          return;
        }
        endEvents.forEach(function (endEvent) {
          removeEventListener(node, endEvent, eventListener);
        });
      }
    };

    module.exports = ReactTransitionEvents;

    },{"fbjs/lib/ExecutionEnvironment":612,"react-dom/lib/getVendorPrefixedEventName":377}],604:[function(require,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';

    },{}],605:[function(require,module,exports){
    (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;

    }).call(this,require('_process'))
    },{"_process":728}],606:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var ReactPropTypeLocationNames = require('./ReactPropTypeLocationNames');
    var ReactPropTypesSecret = require('./ReactPropTypesSecret');

    var invariant = require('fbjs/lib/invariant');
    var warning = require('fbjs/lib/warning');

    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 = require('./ReactComponentTreeHook');
    }

    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 = require('./ReactComponentTreeHook');
              }
              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;

    }).call(this,require('_process'))
    },{"./ReactComponentTreeHook":592,"./ReactPropTypeLocationNames":599,"./ReactPropTypesSecret":601,"./reactProdInvariant":609,"_process":728,"fbjs/lib/invariant":615,"fbjs/lib/warning":616}],607:[function(require,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;

    },{}],608:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var ReactElement = require('./ReactElement');

    var invariant = require('fbjs/lib/invariant');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./ReactElement":595,"./reactProdInvariant":609,"_process":728,"fbjs/lib/invariant":615}],609:[function(require,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;

    },{}],610:[function(require,module,exports){
    (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 = require('./reactProdInvariant');

    var ReactCurrentOwner = require('./ReactCurrentOwner');
    var REACT_ELEMENT_TYPE = require('./ReactElementSymbol');

    var getIteratorFn = require('./getIteratorFn');
    var invariant = require('fbjs/lib/invariant');
    var KeyEscapeUtils = require('./KeyEscapeUtils');
    var warning = require('fbjs/lib/warning');

    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);
          !false ? 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;

    }).call(this,require('_process'))
    },{"./KeyEscapeUtils":586,"./ReactCurrentOwner":593,"./ReactElementSymbol":596,"./getIteratorFn":607,"./reactProdInvariant":609,"_process":728,"fbjs/lib/invariant":615,"fbjs/lib/warning":616}],611:[function(require,module,exports){
    (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 = require('./reactProdInvariant'),
        _assign = require('object-assign');

    var invariant = require('fbjs/lib/invariant');
    var hasOwnProperty = {}.hasOwnProperty;

    function shallowCopy(x) {
      if (Array.isArray(x)) {
        return x.concat();
      } else if (x && typeof x === 'object') {
        return _assign(new x.constructor(), x);
      } else {
        return x;
      }
    }

    var COMMAND_PUSH = '$push';
    var COMMAND_UNSHIFT = '$unshift';
    var COMMAND_SPLICE = '$splice';
    var COMMAND_SET = '$set';
    var COMMAND_MERGE = '$merge';
    var COMMAND_APPLY = '$apply';

    var ALL_COMMANDS_LIST = [COMMAND_PUSH, COMMAND_UNSHIFT, COMMAND_SPLICE, COMMAND_SET, COMMAND_MERGE, COMMAND_APPLY];

    var ALL_COMMANDS_SET = {};

    ALL_COMMANDS_LIST.forEach(function (command) {
      ALL_COMMANDS_SET[command] = true;
    });

    function invariantArrayCase(value, spec, command) {
      !Array.isArray(value) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'update(): expected target of %s to be an array; got %s.', command, value) : _prodInvariant('1', command, value) : void 0;
      var specValue = spec[command];
      !Array.isArray(specValue) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'update(): expected spec of %s to be an array; got %s. Did you forget to wrap your parameter in an array?', command, specValue) : _prodInvariant('2', command, specValue) : void 0;
    }

    /**
     * Returns a updated shallow copy of an object without mutating the original.
     * See https://facebook.github.io/react/docs/update.html for details.
     */
    function update(value, spec) {
      !(typeof spec === 'object') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'update(): You provided a key path to update() that did not contain one of %s. Did you forget to include {%s: ...}?', ALL_COMMANDS_LIST.join(', '), COMMAND_SET) : _prodInvariant('3', ALL_COMMANDS_LIST.join(', '), COMMAND_SET) : void 0;

      if (hasOwnProperty.call(spec, COMMAND_SET)) {
        !(Object.keys(spec).length === 1) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Cannot have more than one key in an object with %s', COMMAND_SET) : _prodInvariant('4', COMMAND_SET) : void 0;

        return spec[COMMAND_SET];
      }

      var nextValue = shallowCopy(value);

      if (hasOwnProperty.call(spec, COMMAND_MERGE)) {
        var mergeObj = spec[COMMAND_MERGE];
        !(mergeObj && typeof mergeObj === 'object') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'update(): %s expects a spec of type \'object\'; got %s', COMMAND_MERGE, mergeObj) : _prodInvariant('5', COMMAND_MERGE, mergeObj) : void 0;
        !(nextValue && typeof nextValue === 'object') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'update(): %s expects a target of type \'object\'; got %s', COMMAND_MERGE, nextValue) : _prodInvariant('6', COMMAND_MERGE, nextValue) : void 0;
        _assign(nextValue, spec[COMMAND_MERGE]);
      }

      if (hasOwnProperty.call(spec, COMMAND_PUSH)) {
        invariantArrayCase(value, spec, COMMAND_PUSH);
        spec[COMMAND_PUSH].forEach(function (item) {
          nextValue.push(item);
        });
      }

      if (hasOwnProperty.call(spec, COMMAND_UNSHIFT)) {
        invariantArrayCase(value, spec, COMMAND_UNSHIFT);
        spec[COMMAND_UNSHIFT].forEach(function (item) {
          nextValue.unshift(item);
        });
      }

      if (hasOwnProperty.call(spec, COMMAND_SPLICE)) {
        !Array.isArray(value) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected %s target to be an array; got %s', COMMAND_SPLICE, value) : _prodInvariant('7', COMMAND_SPLICE, value) : void 0;
        !Array.isArray(spec[COMMAND_SPLICE]) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'update(): expected spec of %s to be an array of arrays; got %s. Did you forget to wrap your parameters in an array?', COMMAND_SPLICE, spec[COMMAND_SPLICE]) : _prodInvariant('8', COMMAND_SPLICE, spec[COMMAND_SPLICE]) : void 0;
        spec[COMMAND_SPLICE].forEach(function (args) {
          !Array.isArray(args) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'update(): expected spec of %s to be an array of arrays; got %s. Did you forget to wrap your parameters in an array?', COMMAND_SPLICE, spec[COMMAND_SPLICE]) : _prodInvariant('8', COMMAND_SPLICE, spec[COMMAND_SPLICE]) : void 0;
          nextValue.splice.apply(nextValue, args);
        });
      }

      if (hasOwnProperty.call(spec, COMMAND_APPLY)) {
        !(typeof spec[COMMAND_APPLY] === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'update(): expected spec of %s to be a function; got %s.', COMMAND_APPLY, spec[COMMAND_APPLY]) : _prodInvariant('9', COMMAND_APPLY, spec[COMMAND_APPLY]) : void 0;
        nextValue = spec[COMMAND_APPLY](nextValue);
      }

      for (var k in spec) {
        if (!(ALL_COMMANDS_SET.hasOwnProperty(k) && ALL_COMMANDS_SET[k])) {
          nextValue[k] = update(value[k], spec[k]);
        }
      }

      return nextValue;
    }

    module.exports = update;

    }).call(this,require('_process'))
    },{"./reactProdInvariant":609,"_process":728,"fbjs/lib/invariant":615,"object-assign":617}],612:[function(require,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;

    },{}],613:[function(require,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;

    },{}],614:[function(require,module,exports){
    (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;

    }).call(this,require('_process'))
    },{"_process":728}],615:[function(require,module,exports){
    (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.
     */

    var validateFormat = function validateFormat(format) {};

    if (process.env.NODE_ENV !== 'production') {
      validateFormat = function validateFormat(format) {
        if (format === undefined) {
          throw new Error('invariant requires an error message argument');
        }
      };
    }

    function invariant(condition, format, a, b, c, d, e, f) {
      validateFormat(format);

      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;

    }).call(this,require('_process'))
    },{"_process":728}],616:[function(require,module,exports){
    (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 = require('./emptyFunction');

    /**
     * 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;

    }).call(this,require('_process'))
    },{"./emptyFunction":613,"_process":728}],617:[function(require,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;
    };

    },{}],618:[function(require,module,exports){
    'use strict';

    module.exports = require('./lib/React');

    },{"./lib/React":588}],619:[function(require,module,exports){

    /**
     * Module dependencies.
     */

    var url = require('./url');
    var parser = require('socket.io-parser');
    var Manager = require('./manager');
    var debug = require('debug')('socket.io-client');

    /**
     * Module exports.
     */

    module.exports = exports = lookup;

    /**
     * Managers cache.
     */

    var cache = exports.managers = {};

    /**
     * Looks up an existing `Manager` for multiplexing.
     * If the user summons:
     *
     *   `io('http://localhost/a');`
     *   `io('http://localhost/b');`
     *
     * We reuse the existing instance based on same scheme/port/host,
     * and we initialize sockets for each namespace.
     *
     * @api public
     */

    function lookup (uri, opts) {
      if (typeof uri === 'object') {
        opts = uri;
        uri = undefined;
      }

      opts = opts || {};

      var parsed = url(uri);
      var source = parsed.source;
      var id = parsed.id;
      var path = parsed.path;
      var sameNamespace = cache[id] && path in cache[id].nsps;
      var newConnection = opts.forceNew || opts['force new connection'] ||
                          false === opts.multiplex || sameNamespace;

      var io;

      if (newConnection) {
        debug('ignoring socket cache for %s', source);
        io = Manager(source, opts);
      } else {
        if (!cache[id]) {
          debug('new io instance for %s', source);
          cache[id] = Manager(source, opts);
        }
        io = cache[id];
      }
      if (parsed.query && !opts.query) {
        opts.query = parsed.query;
      } else if (opts && 'object' === typeof opts.query) {
        opts.query = encodeQueryString(opts.query);
      }
      return io.socket(parsed.path, opts);
    }
    /**
     *  Helper method to parse query objects to string.
     * @param {object} query
     * @returns {string}
     */
    function encodeQueryString (obj) {
      var str = [];
      for (var p in obj) {
        if (obj.hasOwnProperty(p)) {
          str.push(encodeURIComponent(p) + '=' + encodeURIComponent(obj[p]));
        }
      }
      return str.join('&');
    }
    /**
     * Protocol version.
     *
     * @api public
     */

    exports.protocol = parser.protocol;

    /**
     * `connect`.
     *
     * @param {String} uri
     * @api public
     */

    exports.connect = lookup;

    /**
     * Expose constructors for standalone build.
     *
     * @api public
     */

    exports.Manager = require('./manager');
    exports.Socket = require('./socket');

    },{"./manager":620,"./socket":622,"./url":623,"debug":627,"socket.io-parser":657}],620:[function(require,module,exports){

    /**
     * Module dependencies.
     */

    var eio = require('engine.io-client');
    var Socket = require('./socket');
    var Emitter = require('component-emitter');
    var parser = require('socket.io-parser');
    var on = require('./on');
    var bind = require('component-bind');
    var debug = require('debug')('socket.io-client:manager');
    var indexOf = require('indexof');
    var Backoff = require('backo2');

    /**
     * IE6+ hasOwnProperty
     */

    var has = Object.prototype.hasOwnProperty;

    /**
     * Module exports
     */

    module.exports = Manager;

    /**
     * `Manager` constructor.
     *
     * @param {String} engine instance or engine uri/opts
     * @param {Object} options
     * @api public
     */

    function Manager (uri, opts) {
      if (!(this instanceof Manager)) return new Manager(uri, opts);
      if (uri && ('object' === typeof uri)) {
        opts = uri;
        uri = undefined;
      }
      opts = opts || {};

      opts.path = opts.path || '/socket.io';
      this.nsps = {};
      this.subs = [];
      this.opts = opts;
      this.reconnection(opts.reconnection !== false);
      this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);
      this.reconnectionDelay(opts.reconnectionDelay || 1000);
      this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);
      this.randomizationFactor(opts.randomizationFactor || 0.5);
      this.backoff = new Backoff({
        min: this.reconnectionDelay(),
        max: this.reconnectionDelayMax(),
        jitter: this.randomizationFactor()
      });
      this.timeout(null == opts.timeout ? 20000 : opts.timeout);
      this.readyState = 'closed';
      this.uri = uri;
      this.connecting = [];
      this.lastPing = null;
      this.encoding = false;
      this.packetBuffer = [];
      this.encoder = new parser.Encoder();
      this.decoder = new parser.Decoder();
      this.autoConnect = opts.autoConnect !== false;
      if (this.autoConnect) this.open();
    }

    /**
     * Propagate given event to sockets and emit on `this`
     *
     * @api private
     */

    Manager.prototype.emitAll = function () {
      this.emit.apply(this, arguments);
      for (var nsp in this.nsps) {
        if (has.call(this.nsps, nsp)) {
          this.nsps[nsp].emit.apply(this.nsps[nsp], arguments);
        }
      }
    };

    /**
     * Update `socket.id` of all sockets
     *
     * @api private
     */

    Manager.prototype.updateSocketIds = function () {
      for (var nsp in this.nsps) {
        if (has.call(this.nsps, nsp)) {
          this.nsps[nsp].id = this.engine.id;
        }
      }
    };

    /**
     * Mix in `Emitter`.
     */

    Emitter(Manager.prototype);

    /**
     * Sets the `reconnection` config.
     *
     * @param {Boolean} true/false if it should automatically reconnect
     * @return {Manager} self or value
     * @api public
     */

    Manager.prototype.reconnection = function (v) {
      if (!arguments.length) return this._reconnection;
      this._reconnection = !!v;
      return this;
    };

    /**
     * Sets the reconnection attempts config.
     *
     * @param {Number} max reconnection attempts before giving up
     * @return {Manager} self or value
     * @api public
     */

    Manager.prototype.reconnectionAttempts = function (v) {
      if (!arguments.length) return this._reconnectionAttempts;
      this._reconnectionAttempts = v;
      return this;
    };

    /**
     * Sets the delay between reconnections.
     *
     * @param {Number} delay
     * @return {Manager} self or value
     * @api public
     */

    Manager.prototype.reconnectionDelay = function (v) {
      if (!arguments.length) return this._reconnectionDelay;
      this._reconnectionDelay = v;
      this.backoff && this.backoff.setMin(v);
      return this;
    };

    Manager.prototype.randomizationFactor = function (v) {
      if (!arguments.length) return this._randomizationFactor;
      this._randomizationFactor = v;
      this.backoff && this.backoff.setJitter(v);
      return this;
    };

    /**
     * Sets the maximum delay between reconnections.
     *
     * @param {Number} delay
     * @return {Manager} self or value
     * @api public
     */

    Manager.prototype.reconnectionDelayMax = function (v) {
      if (!arguments.length) return this._reconnectionDelayMax;
      this._reconnectionDelayMax = v;
      this.backoff && this.backoff.setMax(v);
      return this;
    };

    /**
     * Sets the connection timeout. `false` to disable
     *
     * @return {Manager} self or value
     * @api public
     */

    Manager.prototype.timeout = function (v) {
      if (!arguments.length) return this._timeout;
      this._timeout = v;
      return this;
    };

    /**
     * Starts trying to reconnect if reconnection is enabled and we have not
     * started reconnecting yet
     *
     * @api private
     */

    Manager.prototype.maybeReconnectOnOpen = function () {
      // Only try to reconnect if it's the first time we're connecting
      if (!this.reconnecting && this._reconnection && this.backoff.attempts === 0) {
        // keeps reconnection from firing twice for the same reconnection loop
        this.reconnect();
      }
    };

    /**
     * Sets the current transport `socket`.
     *
     * @param {Function} optional, callback
     * @return {Manager} self
     * @api public
     */

    Manager.prototype.open =
    Manager.prototype.connect = function (fn, opts) {
      debug('readyState %s', this.readyState);
      if (~this.readyState.indexOf('open')) return this;

      debug('opening %s', this.uri);
      this.engine = eio(this.uri, this.opts);
      var socket = this.engine;
      var self = this;
      this.readyState = 'opening';
      this.skipReconnect = false;

      // emit `open`
      var openSub = on(socket, 'open', function () {
        self.onopen();
        fn && fn();
      });

      // emit `connect_error`
      var errorSub = on(socket, 'error', function (data) {
        debug('connect_error');
        self.cleanup();
        self.readyState = 'closed';
        self.emitAll('connect_error', data);
        if (fn) {
          var err = new Error('Connection error');
          err.data = data;
          fn(err);
        } else {
          // Only do this if there is no fn to handle the error
          self.maybeReconnectOnOpen();
        }
      });

      // emit `connect_timeout`
      if (false !== this._timeout) {
        var timeout = this._timeout;
        debug('connect attempt will timeout after %d', timeout);

        // set timer
        var timer = setTimeout(function () {
          debug('connect attempt timed out after %d', timeout);
          openSub.destroy();
          socket.close();
          socket.emit('error', 'timeout');
          self.emitAll('connect_timeout', timeout);
        }, timeout);

        this.subs.push({
          destroy: function () {
            clearTimeout(timer);
          }
        });
      }

      this.subs.push(openSub);
      this.subs.push(errorSub);

      return this;
    };

    /**
     * Called upon transport open.
     *
     * @api private
     */

    Manager.prototype.onopen = function () {
      debug('open');

      // clear old subs
      this.cleanup();

      // mark as open
      this.readyState = 'open';
      this.emit('open');

      // add new subs
      var socket = this.engine;
      this.subs.push(on(socket, 'data', bind(this, 'ondata')));
      this.subs.push(on(socket, 'ping', bind(this, 'onping')));
      this.subs.push(on(socket, 'pong', bind(this, 'onpong')));
      this.subs.push(on(socket, 'error', bind(this, 'onerror')));
      this.subs.push(on(socket, 'close', bind(this, 'onclose')));
      this.subs.push(on(this.decoder, 'decoded', bind(this, 'ondecoded')));
    };

    /**
     * Called upon a ping.
     *
     * @api private
     */

    Manager.prototype.onping = function () {
      this.lastPing = new Date();
      this.emitAll('ping');
    };

    /**
     * Called upon a packet.
     *
     * @api private
     */

    Manager.prototype.onpong = function () {
      this.emitAll('pong', new Date() - this.lastPing);
    };

    /**
     * Called with data.
     *
     * @api private
     */

    Manager.prototype.ondata = function (data) {
      this.decoder.add(data);
    };

    /**
     * Called when parser fully decodes a packet.
     *
     * @api private
     */

    Manager.prototype.ondecoded = function (packet) {
      this.emit('packet', packet);
    };

    /**
     * Called upon socket error.
     *
     * @api private
     */

    Manager.prototype.onerror = function (err) {
      debug('error', err);
      this.emitAll('error', err);
    };

    /**
     * Creates a new socket for the given `nsp`.
     *
     * @return {Socket}
     * @api public
     */

    Manager.prototype.socket = function (nsp, opts) {
      var socket = this.nsps[nsp];
      if (!socket) {
        socket = new Socket(this, nsp, opts);
        this.nsps[nsp] = socket;
        var self = this;
        socket.on('connecting', onConnecting);
        socket.on('connect', function () {
          socket.id = self.engine.id;
        });

        if (this.autoConnect) {
          // manually call here since connecting evnet is fired before listening
          onConnecting();
        }
      }

      function onConnecting () {
        if (!~indexOf(self.connecting, socket)) {
          self.connecting.push(socket);
        }
      }

      return socket;
    };

    /**
     * Called upon a socket close.
     *
     * @param {Socket} socket
     */

    Manager.prototype.destroy = function (socket) {
      var index = indexOf(this.connecting, socket);
      if (~index) this.connecting.splice(index, 1);
      if (this.connecting.length) return;

      this.close();
    };

    /**
     * Writes a packet.
     *
     * @param {Object} packet
     * @api private
     */

    Manager.prototype.packet = function (packet) {
      debug('writing packet %j', packet);
      var self = this;
      if (packet.query && packet.type === 0) packet.nsp += '?' + packet.query;

      if (!self.encoding) {
        // encode, then write to engine with result
        self.encoding = true;
        this.encoder.encode(packet, function (encodedPackets) {
          for (var i = 0; i < encodedPackets.length; i++) {
            self.engine.write(encodedPackets[i], packet.options);
          }
          self.encoding = false;
          self.processPacketQueue();
        });
      } else { // add packet to the queue
        self.packetBuffer.push(packet);
      }
    };

    /**
     * If packet buffer is non-empty, begins encoding the
     * next packet in line.
     *
     * @api private
     */

    Manager.prototype.processPacketQueue = function () {
      if (this.packetBuffer.length > 0 && !this.encoding) {
        var pack = this.packetBuffer.shift();
        this.packet(pack);
      }
    };

    /**
     * Clean up transport subscriptions and packet buffer.
     *
     * @api private
     */

    Manager.prototype.cleanup = function () {
      debug('cleanup');

      var subsLength = this.subs.length;
      for (var i = 0; i < subsLength; i++) {
        var sub = this.subs.shift();
        sub.destroy();
      }

      this.packetBuffer = [];
      this.encoding = false;
      this.lastPing = null;

      this.decoder.destroy();
    };

    /**
     * Close the current socket.
     *
     * @api private
     */

    Manager.prototype.close =
    Manager.prototype.disconnect = function () {
      debug('disconnect');
      this.skipReconnect = true;
      this.reconnecting = false;
      if ('opening' === this.readyState) {
        // `onclose` will not fire because
        // an open event never happened
        this.cleanup();
      }
      this.backoff.reset();
      this.readyState = 'closed';
      if (this.engine) this.engine.close();
    };

    /**
     * Called upon engine close.
     *
     * @api private
     */

    Manager.prototype.onclose = function (reason) {
      debug('onclose');

      this.cleanup();
      this.backoff.reset();
      this.readyState = 'closed';
      this.emit('close', reason);

      if (this._reconnection && !this.skipReconnect) {
        this.reconnect();
      }
    };

    /**
     * Attempt a reconnection.
     *
     * @api private
     */

    Manager.prototype.reconnect = function () {
      if (this.reconnecting || this.skipReconnect) return this;

      var self = this;

      if (this.backoff.attempts >= this._reconnectionAttempts) {
        debug('reconnect failed');
        this.backoff.reset();
        this.emitAll('reconnect_failed');
        this.reconnecting = false;
      } else {
        var delay = this.backoff.duration();
        debug('will wait %dms before reconnect attempt', delay);

        this.reconnecting = true;
        var timer = setTimeout(function () {
          if (self.skipReconnect) return;

          debug('attempting reconnect');
          self.emitAll('reconnect_attempt', self.backoff.attempts);
          self.emitAll('reconnecting', self.backoff.attempts);

          // check again for the case socket closed in above events
          if (self.skipReconnect) return;

          self.open(function (err) {
            if (err) {
              debug('reconnect attempt error');
              self.reconnecting = false;
              self.reconnect();
              self.emitAll('reconnect_error', err.data);
            } else {
              debug('reconnect success');
              self.onreconnect();
            }
          });
        }, delay);

        this.subs.push({
          destroy: function () {
            clearTimeout(timer);
          }
        });
      }
    };

    /**
     * Called upon successful reconnect.
     *
     * @api private
     */

    Manager.prototype.onreconnect = function () {
      var attempt = this.backoff.attempts;
      this.reconnecting = false;
      this.backoff.reset();
      this.updateSocketIds();
      this.emitAll('reconnect', attempt);
    };

    },{"./on":621,"./socket":622,"backo2":624,"component-bind":625,"component-emitter":626,"debug":627,"engine.io-client":630,"indexof":654,"socket.io-parser":657}],621:[function(require,module,exports){

    /**
     * Module exports.
     */

    module.exports = on;

    /**
     * Helper for subscriptions.
     *
     * @param {Object|EventEmitter} obj with `Emitter` mixin or `EventEmitter`
     * @param {String} event name
     * @param {Function} callback
     * @api public
     */

    function on (obj, ev, fn) {
      obj.on(ev, fn);
      return {
        destroy: function () {
          obj.removeListener(ev, fn);
        }
      };
    }

    },{}],622:[function(require,module,exports){

    /**
     * Module dependencies.
     */

    var parser = require('socket.io-parser');
    var Emitter = require('component-emitter');
    var toArray = require('to-array');
    var on = require('./on');
    var bind = require('component-bind');
    var debug = require('debug')('socket.io-client:socket');
    var hasBin = require('has-binary');

    /**
     * Module exports.
     */

    module.exports = exports = Socket;

    /**
     * Internal events (blacklisted).
     * These events can't be emitted by the user.
     *
     * @api private
     */

    var events = {
      connect: 1,
      connect_error: 1,
      connect_timeout: 1,
      connecting: 1,
      disconnect: 1,
      error: 1,
      reconnect: 1,
      reconnect_attempt: 1,
      reconnect_failed: 1,
      reconnect_error: 1,
      reconnecting: 1,
      ping: 1,
      pong: 1
    };

    /**
     * Shortcut to `Emitter#emit`.
     */

    var emit = Emitter.prototype.emit;

    /**
     * `Socket` constructor.
     *
     * @api public
     */

    function Socket (io, nsp, opts) {
      this.io = io;
      this.nsp = nsp;
      this.json = this; // compat
      this.ids = 0;
      this.acks = {};
      this.receiveBuffer = [];
      this.sendBuffer = [];
      this.connected = false;
      this.disconnected = true;
      if (opts && opts.query) {
        this.query = opts.query;
      }
      if (this.io.autoConnect) this.open();
    }

    /**
     * Mix in `Emitter`.
     */

    Emitter(Socket.prototype);

    /**
     * Subscribe to open, close and packet events
     *
     * @api private
     */

    Socket.prototype.subEvents = function () {
      if (this.subs) return;

      var io = this.io;
      this.subs = [
        on(io, 'open', bind(this, 'onopen')),
        on(io, 'packet', bind(this, 'onpacket')),
        on(io, 'close', bind(this, 'onclose'))
      ];
    };

    /**
     * "Opens" the socket.
     *
     * @api public
     */

    Socket.prototype.open =
    Socket.prototype.connect = function () {
      if (this.connected) return this;

      this.subEvents();
      this.io.open(); // ensure open
      if ('open' === this.io.readyState) this.onopen();
      this.emit('connecting');
      return this;
    };

    /**
     * Sends a `message` event.
     *
     * @return {Socket} self
     * @api public
     */

    Socket.prototype.send = function () {
      var args = toArray(arguments);
      args.unshift('message');
      this.emit.apply(this, args);
      return this;
    };

    /**
     * Override `emit`.
     * If the event is in `events`, it's emitted normally.
     *
     * @param {String} event name
     * @return {Socket} self
     * @api public
     */

    Socket.prototype.emit = function (ev) {
      if (events.hasOwnProperty(ev)) {
        emit.apply(this, arguments);
        return this;
      }

      var args = toArray(arguments);
      var parserType = parser.EVENT; // default
      if (hasBin(args)) { parserType = parser.BINARY_EVENT; } // binary
      var packet = { type: parserType, data: args };

      packet.options = {};
      packet.options.compress = !this.flags || false !== this.flags.compress;

      // event ack callback
      if ('function' === typeof args[args.length - 1]) {
        debug('emitting packet with ack id %d', this.ids);
        this.acks[this.ids] = args.pop();
        packet.id = this.ids++;
      }

      if (this.connected) {
        this.packet(packet);
      } else {
        this.sendBuffer.push(packet);
      }

      delete this.flags;

      return this;
    };

    /**
     * Sends a packet.
     *
     * @param {Object} packet
     * @api private
     */

    Socket.prototype.packet = function (packet) {
      packet.nsp = this.nsp;
      this.io.packet(packet);
    };

    /**
     * Called upon engine `open`.
     *
     * @api private
     */

    Socket.prototype.onopen = function () {
      debug('transport is open - connecting');

      // write connect packet if necessary
      if ('/' !== this.nsp) {
        if (this.query) {
          this.packet({type: parser.CONNECT, query: this.query});
        } else {
          this.packet({type: parser.CONNECT});
        }
      }
    };

    /**
     * Called upon engine `close`.
     *
     * @param {String} reason
     * @api private
     */

    Socket.prototype.onclose = function (reason) {
      debug('close (%s)', reason);
      this.connected = false;
      this.disconnected = true;
      delete this.id;
      this.emit('disconnect', reason);
    };

    /**
     * Called with socket packet.
     *
     * @param {Object} packet
     * @api private
     */

    Socket.prototype.onpacket = function (packet) {
      if (packet.nsp !== this.nsp) return;

      switch (packet.type) {
        case parser.CONNECT:
          this.onconnect();
          break;

        case parser.EVENT:
          this.onevent(packet);
          break;

        case parser.BINARY_EVENT:
          this.onevent(packet);
          break;

        case parser.ACK:
          this.onack(packet);
          break;

        case parser.BINARY_ACK:
          this.onack(packet);
          break;

        case parser.DISCONNECT:
          this.ondisconnect();
          break;

        case parser.ERROR:
          this.emit('error', packet.data);
          break;
      }
    };

    /**
     * Called upon a server event.
     *
     * @param {Object} packet
     * @api private
     */

    Socket.prototype.onevent = function (packet) {
      var args = packet.data || [];
      debug('emitting event %j', args);

      if (null != packet.id) {
        debug('attaching ack callback to event');
        args.push(this.ack(packet.id));
      }

      if (this.connected) {
        emit.apply(this, args);
      } else {
        this.receiveBuffer.push(args);
      }
    };

    /**
     * Produces an ack callback to emit with an event.
     *
     * @api private
     */

    Socket.prototype.ack = function (id) {
      var self = this;
      var sent = false;
      return function () {
        // prevent double callbacks
        if (sent) return;
        sent = true;
        var args = toArray(arguments);
        debug('sending ack %j', args);

        var type = hasBin(args) ? parser.BINARY_ACK : parser.ACK;
        self.packet({
          type: type,
          id: id,
          data: args
        });
      };
    };

    /**
     * Called upon a server acknowlegement.
     *
     * @param {Object} packet
     * @api private
     */

    Socket.prototype.onack = function (packet) {
      var ack = this.acks[packet.id];
      if ('function' === typeof ack) {
        debug('calling ack %s with %j', packet.id, packet.data);
        ack.apply(this, packet.data);
        delete this.acks[packet.id];
      } else {
        debug('bad ack %s', packet.id);
      }
    };

    /**
     * Called upon server connect.
     *
     * @api private
     */

    Socket.prototype.onconnect = function () {
      this.connected = true;
      this.disconnected = false;
      this.emit('connect');
      this.emitBuffered();
    };

    /**
     * Emit buffered events (received and emitted).
     *
     * @api private
     */

    Socket.prototype.emitBuffered = function () {
      var i;
      for (i = 0; i < this.receiveBuffer.length; i++) {
        emit.apply(this, this.receiveBuffer[i]);
      }
      this.receiveBuffer = [];

      for (i = 0; i < this.sendBuffer.length; i++) {
        this.packet(this.sendBuffer[i]);
      }
      this.sendBuffer = [];
    };

    /**
     * Called upon server disconnect.
     *
     * @api private
     */

    Socket.prototype.ondisconnect = function () {
      debug('server disconnect (%s)', this.nsp);
      this.destroy();
      this.onclose('io server disconnect');
    };

    /**
     * Called upon forced client/server side disconnections,
     * this method ensures the manager stops tracking us and
     * that reconnections don't get triggered for this.
     *
     * @api private.
     */

    Socket.prototype.destroy = function () {
      if (this.subs) {
        // clean subscriptions to avoid reconnections
        for (var i = 0; i < this.subs.length; i++) {
          this.subs[i].destroy();
        }
        this.subs = null;
      }

      this.io.destroy(this);
    };

    /**
     * Disconnects the socket manually.
     *
     * @return {Socket} self
     * @api public
     */

    Socket.prototype.close =
    Socket.prototype.disconnect = function () {
      if (this.connected) {
        debug('performing disconnect (%s)', this.nsp);
        this.packet({ type: parser.DISCONNECT });
      }

      // remove socket from pool
      this.destroy();

      if (this.connected) {
        // fire events
        this.onclose('io client disconnect');
      }
      return this;
    };

    /**
     * Sets the compress flag.
     *
     * @param {Boolean} if `true`, compresses the sending data
     * @return {Socket} self
     * @api public
     */

    Socket.prototype.compress = function (compress) {
      this.flags = this.flags || {};
      this.flags.compress = compress;
      return this;
    };

    },{"./on":621,"component-bind":625,"component-emitter":626,"debug":627,"has-binary":652,"socket.io-parser":657,"to-array":665}],623:[function(require,module,exports){
    (function (global){

    /**
     * Module dependencies.
     */

    var parseuri = require('parseuri');
    var debug = require('debug')('socket.io-client:url');

    /**
     * Module exports.
     */

    module.exports = url;

    /**
     * URL parser.
     *
     * @param {String} url
     * @param {Object} An object meant to mimic window.location.
     *                 Defaults to window.location.
     * @api public
     */

    function url (uri, loc) {
      var obj = uri;

      // default to window.location
      loc = loc || global.location;
      if (null == uri) uri = loc.protocol + '//' + loc.host;

      // relative path support
      if ('string' === typeof uri) {
        if ('/' === uri.charAt(0)) {
          if ('/' === uri.charAt(1)) {
            uri = loc.protocol + uri;
          } else {
            uri = loc.host + uri;
          }
        }

        if (!/^(https?|wss?):\/\//.test(uri)) {
          debug('protocol-less url %s', uri);
          if ('undefined' !== typeof loc) {
            uri = loc.protocol + '//' + uri;
          } else {
            uri = 'https://' + uri;
          }
        }

        // parse
        debug('parse %s', uri);
        obj = parseuri(uri);
      }

      // make sure we treat `localhost:80` and `localhost` equally
      if (!obj.port) {
        if (/^(http|ws)$/.test(obj.protocol)) {
          obj.port = '80';
        } else if (/^(http|ws)s$/.test(obj.protocol)) {
          obj.port = '443';
        }
      }

      obj.path = obj.path || '/';

      var ipv6 = obj.host.indexOf(':') !== -1;
      var host = ipv6 ? '[' + obj.host + ']' : obj.host;

      // define unique id
      obj.id = obj.protocol + '://' + host + ':' + obj.port;
      // define href
      obj.href = obj.protocol + '://' + host + (loc && loc.port === obj.port ? '' : (':' + obj.port));

      return obj;
    }

    }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{"debug":627,"parseuri":655}],624:[function(require,module,exports){

    /**
     * Expose `Backoff`.
     */

    module.exports = Backoff;

    /**
     * Initialize backoff timer with `opts`.
     *
     * - `min` initial timeout in milliseconds [100]
     * - `max` max timeout [10000]
     * - `jitter` [0]
     * - `factor` [2]
     *
     * @param {Object} opts
     * @api public
     */

    function Backoff(opts) {
      opts = opts || {};
      this.ms = opts.min || 100;
      this.max = opts.max || 10000;
      this.factor = opts.factor || 2;
      this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
      this.attempts = 0;
    }

    /**
     * Return the backoff duration.
     *
     * @return {Number}
     * @api public
     */

    Backoff.prototype.duration = function(){
      var ms = this.ms * Math.pow(this.factor, this.attempts++);
      if (this.jitter) {
        var rand =  Math.random();
        var deviation = Math.floor(rand * this.jitter * ms);
        ms = (Math.floor(rand * 10) & 1) == 0  ? ms - deviation : ms + deviation;
      }
      return Math.min(ms, this.max) | 0;
    };

    /**
     * Reset the number of attempts.
     *
     * @api public
     */

    Backoff.prototype.reset = function(){
      this.attempts = 0;
    };

    /**
     * Set the minimum duration
     *
     * @api public
     */

    Backoff.prototype.setMin = function(min){
      this.ms = min;
    };

    /**
     * Set the maximum duration
     *
     * @api public
     */

    Backoff.prototype.setMax = function(max){
      this.max = max;
    };

    /**
     * Set the jitter
     *
     * @api public
     */

    Backoff.prototype.setJitter = function(jitter){
      this.jitter = jitter;
    };

    },{}],625:[function(require,module,exports){
    /**
     * Slice reference.
     */

    var slice = [].slice;

    /**
     * Bind `obj` to `fn`.
     *
     * @param {Object} obj
     * @param {Function|String} fn or string
     * @return {Function}
     * @api public
     */

    module.exports = function(obj, fn){
      if ('string' == typeof fn) fn = obj[fn];
      if ('function' != typeof fn) throw new Error('bind() requires a function');
      var args = slice.call(arguments, 2);
      return function(){
        return fn.apply(obj, args.concat(slice.call(arguments)));
      }
    };

    },{}],626:[function(require,module,exports){

    /**
     * Expose `Emitter`.
     */

    if (typeof module !== 'undefined') {
      module.exports = Emitter;
    }

    /**
     * Initialize a new `Emitter`.
     *
     * @api public
     */

    function Emitter(obj) {
      if (obj) return mixin(obj);
    };

    /**
     * Mixin the emitter properties.
     *
     * @param {Object} obj
     * @return {Object}
     * @api private
     */

    function mixin(obj) {
      for (var key in Emitter.prototype) {
        obj[key] = Emitter.prototype[key];
      }
      return obj;
    }

    /**
     * Listen on the given `event` with `fn`.
     *
     * @param {String} event
     * @param {Function} fn
     * @return {Emitter}
     * @api public
     */

    Emitter.prototype.on =
    Emitter.prototype.addEventListener = function(event, fn){
      this._callbacks = this._callbacks || {};
      (this._callbacks['$' + event] = this._callbacks['$' + event] || [])
        .push(fn);
      return this;
    };

    /**
     * Adds an `event` listener that will be invoked a single
     * time then automatically removed.
     *
     * @param {String} event
     * @param {Function} fn
     * @return {Emitter}
     * @api public
     */

    Emitter.prototype.once = function(event, fn){
      function on() {
        this.off(event, on);
        fn.apply(this, arguments);
      }

      on.fn = fn;
      this.on(event, on);
      return this;
    };

    /**
     * Remove the given callback for `event` or all
     * registered callbacks.
     *
     * @param {String} event
     * @param {Function} fn
     * @return {Emitter}
     * @api public
     */

    Emitter.prototype.off =
    Emitter.prototype.removeListener =
    Emitter.prototype.removeAllListeners =
    Emitter.prototype.removeEventListener = function(event, fn){
      this._callbacks = this._callbacks || {};

      // all
      if (0 == arguments.length) {
        this._callbacks = {};
        return this;
      }

      // specific event
      var callbacks = this._callbacks['$' + event];
      if (!callbacks) return this;

      // remove all handlers
      if (1 == arguments.length) {
        delete this._callbacks['$' + event];
        return this;
      }

      // remove specific handler
      var cb;
      for (var i = 0; i < callbacks.length; i++) {
        cb = callbacks[i];
        if (cb === fn || cb.fn === fn) {
          callbacks.splice(i, 1);
          break;
        }
      }
      return this;
    };

    /**
     * Emit `event` with the given args.
     *
     * @param {String} event
     * @param {Mixed} ...
     * @return {Emitter}
     */

    Emitter.prototype.emit = function(event){
      this._callbacks = this._callbacks || {};
      var args = [].slice.call(arguments, 1)
        , callbacks = this._callbacks['$' + event];

      if (callbacks) {
        callbacks = callbacks.slice(0);
        for (var i = 0, len = callbacks.length; i < len; ++i) {
          callbacks[i].apply(this, args);
        }
      }

      return this;
    };

    /**
     * Return array of callbacks for `event`.
     *
     * @param {String} event
     * @return {Array}
     * @api public
     */

    Emitter.prototype.listeners = function(event){
      this._callbacks = this._callbacks || {};
      return this._callbacks['$' + event] || [];
    };

    /**
     * Check if this emitter has `event` handlers.
     *
     * @param {String} event
     * @return {Boolean}
     * @api public
     */

    Emitter.prototype.hasListeners = function(event){
      return !! this.listeners(event).length;
    };
    },{}],627:[function(require,module,exports){
    (function (process){

    /**
     * This is the web browser implementation of `debug()`.
     *
     * Expose `debug()` as the module.
     */

    exports = module.exports = require('./debug');
    exports.log = log;
    exports.formatArgs = formatArgs;
    exports.save = save;
    exports.load = load;
    exports.useColors = useColors;
    exports.storage = 'undefined' != typeof chrome
                   && 'undefined' != typeof chrome.storage
                      ? chrome.storage.local
                      : localstorage();

    /**
     * Colors.
     */

    exports.colors = [
      'lightseagreen',
      'forestgreen',
      'goldenrod',
      'dodgerblue',
      'darkorchid',
      'crimson'
    ];

    /**
     * Currently only WebKit-based Web Inspectors, Firefox >= v31,
     * and the Firebug extension (any Firefox version) are known
     * to support "%c" CSS customizations.
     *
     * TODO: add a `localStorage` variable to explicitly enable/disable colors
     */

    function useColors() {
      // is webkit? http://stackoverflow.com/a/16459606/376773
      // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
      return (typeof document !== 'undefined' && 'WebkitAppearance' in document.documentElement.style) ||
        // is firebug? http://stackoverflow.com/a/398120/376773
        (window.console && (console.firebug || (console.exception && console.table))) ||
        // is firefox >= v31?
        // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
        (navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31);
    }

    /**
     * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
     */

    exports.formatters.j = function(v) {
      try {
        return JSON.stringify(v);
      } catch (err) {
        return '[UnexpectedJSONParseError]: ' + err.message;
      }
    };

    /**
     * Colorize log arguments if enabled.
     *
     * @api public
     */

    function formatArgs() {
      var args = arguments;
      var useColors = this.useColors;

      args[0] = (useColors ? '%c' : '')
        + this.namespace
        + (useColors ? ' %c' : ' ')
        + args[0]
        + (useColors ? '%c ' : ' ')
        + '+' + exports.humanize(this.diff);

      if (!useColors) return args;

      var c = 'color: ' + this.color;
      args = [args[0], c, 'color: inherit'].concat(Array.prototype.slice.call(args, 1));

      // the final "%c" is somewhat tricky, because there could be other
      // arguments passed either before or after the %c, so we need to
      // figure out the correct index to insert the CSS into
      var index = 0;
      var lastC = 0;
      args[0].replace(/%[a-z%]/g, function(match) {
        if ('%%' === match) return;
        index++;
        if ('%c' === match) {
          // we only are interested in the *last* %c
          // (the user may have provided their own)
          lastC = index;
        }
      });

      args.splice(lastC, 0, c);
      return args;
    }

    /**
     * Invokes `console.log()` when available.
     * No-op when `console.log` is not a "function".
     *
     * @api public
     */

    function log() {
      // this hackery is required for IE8/9, where
      // the `console.log` function doesn't have 'apply'
      return 'object' === typeof console
        && console.log
        && Function.prototype.apply.call(console.log, console, arguments);
    }

    /**
     * Save `namespaces`.
     *
     * @param {String} namespaces
     * @api private
     */

    function save(namespaces) {
      try {
        if (null == namespaces) {
          exports.storage.removeItem('debug');
        } else {
          exports.storage.debug = namespaces;
        }
      } catch(e) {}
    }

    /**
     * Load `namespaces`.
     *
     * @return {String} returns the previously persisted debug modes
     * @api private
     */

    function load() {
      var r;
      try {
        return exports.storage.debug;
      } catch(e) {}

      // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
      if (typeof process !== 'undefined' && 'env' in process) {
        return process.env.DEBUG;
      }
    }

    /**
     * Enable namespaces listed in `localStorage.debug` initially.
     */

    exports.enable(load());

    /**
     * Localstorage attempts to return the localstorage.
     *
     * This is necessary because safari throws
     * when a user disables cookies/localstorage
     * and you attempt to access it.
     *
     * @return {LocalStorage}
     * @api private
     */

    function localstorage(){
      try {
        return window.localStorage;
      } catch (e) {}
    }

    }).call(this,require('_process'))
    },{"./debug":628,"_process":728}],628:[function(require,module,exports){

    /**
     * This is the common logic for both the Node.js and web browser
     * implementations of `debug()`.
     *
     * Expose `debug()` as the module.
     */

    exports = module.exports = debug.debug = debug;
    exports.coerce = coerce;
    exports.disable = disable;
    exports.enable = enable;
    exports.enabled = enabled;
    exports.humanize = require('ms');

    /**
     * The currently active debug mode names, and names to skip.
     */

    exports.names = [];
    exports.skips = [];

    /**
     * Map of special "%n" handling functions, for the debug "format" argument.
     *
     * Valid key names are a single, lowercased letter, i.e. "n".
     */

    exports.formatters = {};

    /**
     * Previously assigned color.
     */

    var prevColor = 0;

    /**
     * Previous log timestamp.
     */

    var prevTime;

    /**
     * Select a color.
     *
     * @return {Number}
     * @api private
     */

    function selectColor() {
      return exports.colors[prevColor++ % exports.colors.length];
    }

    /**
     * Create a debugger with the given `namespace`.
     *
     * @param {String} namespace
     * @return {Function}
     * @api public
     */

    function debug(namespace) {

      // define the `disabled` version
      function disabled() {
      }
      disabled.enabled = false;

      // define the `enabled` version
      function enabled() {

        var self = enabled;

        // set `diff` timestamp
        var curr = +new Date();
        var ms = curr - (prevTime || curr);
        self.diff = ms;
        self.prev = prevTime;
        self.curr = curr;
        prevTime = curr;

        // add the `color` if not set
        if (null == self.useColors) self.useColors = exports.useColors();
        if (null == self.color && self.useColors) self.color = selectColor();

        var args = new Array(arguments.length);
        for (var i = 0; i < args.length; i++) {
          args[i] = arguments[i];
        }

        args[0] = exports.coerce(args[0]);

        if ('string' !== typeof args[0]) {
          // anything else let's inspect with %o
          args = ['%o'].concat(args);
        }

        // apply any `formatters` transformations
        var index = 0;
        args[0] = args[0].replace(/%([a-z%])/g, function(match, format) {
          // if we encounter an escaped % then don't increase the array index
          if (match === '%%') return match;
          index++;
          var formatter = exports.formatters[format];
          if ('function' === typeof formatter) {
            var val = args[index];
            match = formatter.call(self, val);

            // now we need to remove `args[index]` since it's inlined in the `format`
            args.splice(index, 1);
            index--;
          }
          return match;
        });

        // apply env-specific formatting
        args = exports.formatArgs.apply(self, args);

        var logFn = enabled.log || exports.log || console.log.bind(console);
        logFn.apply(self, args);
      }
      enabled.enabled = true;

      var fn = exports.enabled(namespace) ? enabled : disabled;

      fn.namespace = namespace;

      return fn;
    }

    /**
     * Enables a debug mode by namespaces. This can include modes
     * separated by a colon and wildcards.
     *
     * @param {String} namespaces
     * @api public
     */

    function enable(namespaces) {
      exports.save(namespaces);

      var split = (namespaces || '').split(/[\s,]+/);
      var len = split.length;

      for (var i = 0; i < len; i++) {
        if (!split[i]) continue; // ignore empty strings
        namespaces = split[i].replace(/[\\^$+?.()|[\]{}]/g, '\\$&').replace(/\*/g, '.*?');
        if (namespaces[0] === '-') {
          exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
        } else {
          exports.names.push(new RegExp('^' + namespaces + '$'));
        }
      }
    }

    /**
     * Disable debug output.
     *
     * @api public
     */

    function disable() {
      exports.enable('');
    }

    /**
     * Returns true if the given mode name is enabled, false otherwise.
     *
     * @param {String} name
     * @return {Boolean}
     * @api public
     */

    function enabled(name) {
      var i, len;
      for (i = 0, len = exports.skips.length; i < len; i++) {
        if (exports.skips[i].test(name)) {
          return false;
        }
      }
      for (i = 0, len = exports.names.length; i < len; i++) {
        if (exports.names[i].test(name)) {
          return true;
        }
      }
      return false;
    }

    /**
     * Coerce `val`.
     *
     * @param {Mixed} val
     * @return {Mixed}
     * @api private
     */

    function coerce(val) {
      if (val instanceof Error) return val.stack || val.message;
      return val;
    }

    },{"ms":629}],629:[function(require,module,exports){
    /**
     * Helpers.
     */

    var s = 1000
    var m = s * 60
    var h = m * 60
    var d = h * 24
    var y = d * 365.25

    /**
     * Parse or format the given `val`.
     *
     * Options:
     *
     *  - `long` verbose formatting [false]
     *
     * @param {String|Number} val
     * @param {Object} options
     * @throws {Error} throw an error if val is not a non-empty string or a number
     * @return {String|Number}
     * @api public
     */

    module.exports = function (val, options) {
      options = options || {}
      var type = typeof val
      if (type === 'string' && val.length > 0) {
        return parse(val)
      } else if (type === 'number' && isNaN(val) === false) {
        return options.long ?
    			fmtLong(val) :
    			fmtShort(val)
      }
      throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val))
    }

    /**
     * Parse the given `str` and return milliseconds.
     *
     * @param {String} str
     * @return {Number}
     * @api private
     */

    function parse(str) {
      str = String(str)
      if (str.length > 10000) {
        return
      }
      var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str)
      if (!match) {
        return
      }
      var n = parseFloat(match[1])
      var type = (match[2] || 'ms').toLowerCase()
      switch (type) {
        case 'years':
        case 'year':
        case 'yrs':
        case 'yr':
        case 'y':
          return n * y
        case 'days':
        case 'day':
        case 'd':
          return n * d
        case 'hours':
        case 'hour':
        case 'hrs':
        case 'hr':
        case 'h':
          return n * h
        case 'minutes':
        case 'minute':
        case 'mins':
        case 'min':
        case 'm':
          return n * m
        case 'seconds':
        case 'second':
        case 'secs':
        case 'sec':
        case 's':
          return n * s
        case 'milliseconds':
        case 'millisecond':
        case 'msecs':
        case 'msec':
        case 'ms':
          return n
        default:
          return undefined
      }
    }

    /**
     * Short format for `ms`.
     *
     * @param {Number} ms
     * @return {String}
     * @api private
     */

    function fmtShort(ms) {
      if (ms >= d) {
        return Math.round(ms / d) + 'd'
      }
      if (ms >= h) {
        return Math.round(ms / h) + 'h'
      }
      if (ms >= m) {
        return Math.round(ms / m) + 'm'
      }
      if (ms >= s) {
        return Math.round(ms / s) + 's'
      }
      return ms + 'ms'
    }

    /**
     * Long format for `ms`.
     *
     * @param {Number} ms
     * @return {String}
     * @api private
     */

    function fmtLong(ms) {
      return plural(ms, d, 'day') ||
        plural(ms, h, 'hour') ||
        plural(ms, m, 'minute') ||
        plural(ms, s, 'second') ||
        ms + ' ms'
    }

    /**
     * Pluralization helper.
     */

    function plural(ms, n, name) {
      if (ms < n) {
        return
      }
      if (ms < n * 1.5) {
        return Math.floor(ms / n) + ' ' + name
      }
      return Math.ceil(ms / n) + ' ' + name + 's'
    }

    },{}],630:[function(require,module,exports){

    module.exports = require('./lib/index');

    },{"./lib/index":631}],631:[function(require,module,exports){

    module.exports = require('./socket');

    /**
     * Exports parser
     *
     * @api public
     *
     */
    module.exports.parser = require('engine.io-parser');

    },{"./socket":632,"engine.io-parser":641}],632:[function(require,module,exports){
    (function (global){
    /**
     * Module dependencies.
     */

    var transports = require('./transports/index');
    var Emitter = require('component-emitter');
    var debug = require('debug')('engine.io-client:socket');
    var index = require('indexof');
    var parser = require('engine.io-parser');
    var parseuri = require('parseuri');
    var parsejson = require('parsejson');
    var parseqs = require('parseqs');

    /**
     * Module exports.
     */

    module.exports = Socket;

    /**
     * Socket constructor.
     *
     * @param {String|Object} uri or options
     * @param {Object} options
     * @api public
     */

    function Socket (uri, opts) {
      if (!(this instanceof Socket)) return new Socket(uri, opts);

      opts = opts || {};

      if (uri && 'object' === typeof uri) {
        opts = uri;
        uri = null;
      }

      if (uri) {
        uri = parseuri(uri);
        opts.hostname = uri.host;
        opts.secure = uri.protocol === 'https' || uri.protocol === 'wss';
        opts.port = uri.port;
        if (uri.query) opts.query = uri.query;
      } else if (opts.host) {
        opts.hostname = parseuri(opts.host).host;
      }

      this.secure = null != opts.secure ? opts.secure
        : (global.location && 'https:' === location.protocol);

      if (opts.hostname && !opts.port) {
        // if no port is specified manually, use the protocol default
        opts.port = this.secure ? '443' : '80';
      }

      this.agent = opts.agent || false;
      this.hostname = opts.hostname ||
        (global.location ? location.hostname : 'localhost');
      this.port = opts.port || (global.location && location.port
          ? location.port
          : (this.secure ? 443 : 80));
      this.query = opts.query || {};
      if ('string' === typeof this.query) this.query = parseqs.decode(this.query);
      this.upgrade = false !== opts.upgrade;
      this.path = (opts.path || '/engine.io').replace(/\/$/, '') + '/';
      this.forceJSONP = !!opts.forceJSONP;
      this.jsonp = false !== opts.jsonp;
      this.forceBase64 = !!opts.forceBase64;
      this.enablesXDR = !!opts.enablesXDR;
      this.timestampParam = opts.timestampParam || 't';
      this.timestampRequests = opts.timestampRequests;
      this.transports = opts.transports || ['polling', 'websocket'];
      this.readyState = '';
      this.writeBuffer = [];
      this.prevBufferLen = 0;
      this.policyPort = opts.policyPort || 843;
      this.rememberUpgrade = opts.rememberUpgrade || false;
      this.binaryType = null;
      this.onlyBinaryUpgrades = opts.onlyBinaryUpgrades;
      this.perMessageDeflate = false !== opts.perMessageDeflate ? (opts.perMessageDeflate || {}) : false;

      if (true === this.perMessageDeflate) this.perMessageDeflate = {};
      if (this.perMessageDeflate && null == this.perMessageDeflate.threshold) {
        this.perMessageDeflate.threshold = 1024;
      }

      // SSL options for Node.js client
      this.pfx = opts.pfx || null;
      this.key = opts.key || null;
      this.passphrase = opts.passphrase || null;
      this.cert = opts.cert || null;
      this.ca = opts.ca || null;
      this.ciphers = opts.ciphers || null;
      this.rejectUnauthorized = opts.rejectUnauthorized === undefined ? null : opts.rejectUnauthorized;
      this.forceNode = !!opts.forceNode;

      // other options for Node.js client
      var freeGlobal = typeof global === 'object' && global;
      if (freeGlobal.global === freeGlobal) {
        if (opts.extraHeaders && Object.keys(opts.extraHeaders).length > 0) {
          this.extraHeaders = opts.extraHeaders;
        }

        if (opts.localAddress) {
          this.localAddress = opts.localAddress;
        }
      }

      // set on handshake
      this.id = null;
      this.upgrades = null;
      this.pingInterval = null;
      this.pingTimeout = null;

      // set on heartbeat
      this.pingIntervalTimer = null;
      this.pingTimeoutTimer = null;

      this.open();
    }

    Socket.priorWebsocketSuccess = false;

    /**
     * Mix in `Emitter`.
     */

    Emitter(Socket.prototype);

    /**
     * Protocol version.
     *
     * @api public
     */

    Socket.protocol = parser.protocol; // this is an int

    /**
     * Expose deps for legacy compatibility
     * and standalone browser access.
     */

    Socket.Socket = Socket;
    Socket.Transport = require('./transport');
    Socket.transports = require('./transports/index');
    Socket.parser = require('engine.io-parser');

    /**
     * Creates transport of the given type.
     *
     * @param {String} transport name
     * @return {Transport}
     * @api private
     */

    Socket.prototype.createTransport = function (name) {
      debug('creating transport "%s"', name);
      var query = clone(this.query);

      // append engine.io protocol identifier
      query.EIO = parser.protocol;

      // transport name
      query.transport = name;

      // session id if we already have one
      if (this.id) query.sid = this.id;

      var transport = new transports[name]({
        agent: this.agent,
        hostname: this.hostname,
        port: this.port,
        secure: this.secure,
        path: this.path,
        query: query,
        forceJSONP: this.forceJSONP,
        jsonp: this.jsonp,
        forceBase64: this.forceBase64,
        enablesXDR: this.enablesXDR,
        timestampRequests: this.timestampRequests,
        timestampParam: this.timestampParam,
        policyPort: this.policyPort,
        socket: this,
        pfx: this.pfx,
        key: this.key,
        passphrase: this.passphrase,
        cert: this.cert,
        ca: this.ca,
        ciphers: this.ciphers,
        rejectUnauthorized: this.rejectUnauthorized,
        perMessageDeflate: this.perMessageDeflate,
        extraHeaders: this.extraHeaders,
        forceNode: this.forceNode,
        localAddress: this.localAddress
      });

      return transport;
    };

    function clone (obj) {
      var o = {};
      for (var i in obj) {
        if (obj.hasOwnProperty(i)) {
          o[i] = obj[i];
        }
      }
      return o;
    }

    /**
     * Initializes transport to use and starts probe.
     *
     * @api private
     */
    Socket.prototype.open = function () {
      var transport;
      if (this.rememberUpgrade && Socket.priorWebsocketSuccess && this.transports.indexOf('websocket') !== -1) {
        transport = 'websocket';
      } else if (0 === this.transports.length) {
        // Emit error on next tick so it can be listened to
        var self = this;
        setTimeout(function () {
          self.emit('error', 'No transports available');
        }, 0);
        return;
      } else {
        transport = this.transports[0];
      }
      this.readyState = 'opening';

      // Retry with the next transport if the transport is disabled (jsonp: false)
      try {
        transport = this.createTransport(transport);
      } catch (e) {
        this.transports.shift();
        this.open();
        return;
      }

      transport.open();
      this.setTransport(transport);
    };

    /**
     * Sets the current transport. Disables the existing one (if any).
     *
     * @api private
     */

    Socket.prototype.setTransport = function (transport) {
      debug('setting transport %s', transport.name);
      var self = this;

      if (this.transport) {
        debug('clearing existing transport %s', this.transport.name);
        this.transport.removeAllListeners();
      }

      // set up transport
      this.transport = transport;

      // set up transport listeners
      transport
      .on('drain', function () {
        self.onDrain();
      })
      .on('packet', function (packet) {
        self.onPacket(packet);
      })
      .on('error', function (e) {
        self.onError(e);
      })
      .on('close', function () {
        self.onClose('transport close');
      });
    };

    /**
     * Probes a transport.
     *
     * @param {String} transport name
     * @api private
     */

    Socket.prototype.probe = function (name) {
      debug('probing transport "%s"', name);
      var transport = this.createTransport(name, { probe: 1 });
      var failed = false;
      var self = this;

      Socket.priorWebsocketSuccess = false;

      function onTransportOpen () {
        if (self.onlyBinaryUpgrades) {
          var upgradeLosesBinary = !this.supportsBinary && self.transport.supportsBinary;
          failed = failed || upgradeLosesBinary;
        }
        if (failed) return;

        debug('probe transport "%s" opened', name);
        transport.send([{ type: 'ping', data: 'probe' }]);
        transport.once('packet', function (msg) {
          if (failed) return;
          if ('pong' === msg.type && 'probe' === msg.data) {
            debug('probe transport "%s" pong', name);
            self.upgrading = true;
            self.emit('upgrading', transport);
            if (!transport) return;
            Socket.priorWebsocketSuccess = 'websocket' === transport.name;

            debug('pausing current transport "%s"', self.transport.name);
            self.transport.pause(function () {
              if (failed) return;
              if ('closed' === self.readyState) return;
              debug('changing transport and sending upgrade packet');

              cleanup();

              self.setTransport(transport);
              transport.send([{ type: 'upgrade' }]);
              self.emit('upgrade', transport);
              transport = null;
              self.upgrading = false;
              self.flush();
            });
          } else {
            debug('probe transport "%s" failed', name);
            var err = new Error('probe error');
            err.transport = transport.name;
            self.emit('upgradeError', err);
          }
        });
      }

      function freezeTransport () {
        if (failed) return;

        // Any callback called by transport should be ignored since now
        failed = true;

        cleanup();

        transport.close();
        transport = null;
      }

      // Handle any error that happens while probing
      function onerror (err) {
        var error = new Error('probe error: ' + err);
        error.transport = transport.name;

        freezeTransport();

        debug('probe transport "%s" failed because of error: %s', name, err);

        self.emit('upgradeError', error);
      }

      function onTransportClose () {
        onerror('transport closed');
      }

      // When the socket is closed while we're probing
      function onclose () {
        onerror('socket closed');
      }

      // When the socket is upgraded while we're probing
      function onupgrade (to) {
        if (transport && to.name !== transport.name) {
          debug('"%s" works - aborting "%s"', to.name, transport.name);
          freezeTransport();
        }
      }

      // Remove all listeners on the transport and on self
      function cleanup () {
        transport.removeListener('open', onTransportOpen);
        transport.removeListener('error', onerror);
        transport.removeListener('close', onTransportClose);
        self.removeListener('close', onclose);
        self.removeListener('upgrading', onupgrade);
      }

      transport.once('open', onTransportOpen);
      transport.once('error', onerror);
      transport.once('close', onTransportClose);

      this.once('close', onclose);
      this.once('upgrading', onupgrade);

      transport.open();
    };

    /**
     * Called when connection is deemed open.
     *
     * @api public
     */

    Socket.prototype.onOpen = function () {
      debug('socket open');
      this.readyState = 'open';
      Socket.priorWebsocketSuccess = 'websocket' === this.transport.name;
      this.emit('open');
      this.flush();

      // we check for `readyState` in case an `open`
      // listener already closed the socket
      if ('open' === this.readyState && this.upgrade && this.transport.pause) {
        debug('starting upgrade probes');
        for (var i = 0, l = this.upgrades.length; i < l; i++) {
          this.probe(this.upgrades[i]);
        }
      }
    };

    /**
     * Handles a packet.
     *
     * @api private
     */

    Socket.prototype.onPacket = function (packet) {
      if ('opening' === this.readyState || 'open' === this.readyState ||
          'closing' === this.readyState) {
        debug('socket receive: type "%s", data "%s"', packet.type, packet.data);

        this.emit('packet', packet);

        // Socket is live - any packet counts
        this.emit('heartbeat');

        switch (packet.type) {
          case 'open':
            this.onHandshake(parsejson(packet.data));
            break;

          case 'pong':
            this.setPing();
            this.emit('pong');
            break;

          case 'error':
            var err = new Error('server error');
            err.code = packet.data;
            this.onError(err);
            break;

          case 'message':
            this.emit('data', packet.data);
            this.emit('message', packet.data);
            break;
        }
      } else {
        debug('packet received with socket readyState "%s"', this.readyState);
      }
    };

    /**
     * Called upon handshake completion.
     *
     * @param {Object} handshake obj
     * @api private
     */

    Socket.prototype.onHandshake = function (data) {
      this.emit('handshake', data);
      this.id = data.sid;
      this.transport.query.sid = data.sid;
      this.upgrades = this.filterUpgrades(data.upgrades);
      this.pingInterval = data.pingInterval;
      this.pingTimeout = data.pingTimeout;
      this.onOpen();
      // In case open handler closes socket
      if ('closed' === this.readyState) return;
      this.setPing();

      // Prolong liveness of socket on heartbeat
      this.removeListener('heartbeat', this.onHeartbeat);
      this.on('heartbeat', this.onHeartbeat);
    };

    /**
     * Resets ping timeout.
     *
     * @api private
     */

    Socket.prototype.onHeartbeat = function (timeout) {
      clearTimeout(this.pingTimeoutTimer);
      var self = this;
      self.pingTimeoutTimer = setTimeout(function () {
        if ('closed' === self.readyState) return;
        self.onClose('ping timeout');
      }, timeout || (self.pingInterval + self.pingTimeout));
    };

    /**
     * Pings server every `this.pingInterval` and expects response
     * within `this.pingTimeout` or closes connection.
     *
     * @api private
     */

    Socket.prototype.setPing = function () {
      var self = this;
      clearTimeout(self.pingIntervalTimer);
      self.pingIntervalTimer = setTimeout(function () {
        debug('writing ping packet - expecting pong within %sms', self.pingTimeout);
        self.ping();
        self.onHeartbeat(self.pingTimeout);
      }, self.pingInterval);
    };

    /**
    * Sends a ping packet.
    *
    * @api private
    */

    Socket.prototype.ping = function () {
      var self = this;
      this.sendPacket('ping', function () {
        self.emit('ping');
      });
    };

    /**
     * Called on `drain` event
     *
     * @api private
     */

    Socket.prototype.onDrain = function () {
      this.writeBuffer.splice(0, this.prevBufferLen);

      // setting prevBufferLen = 0 is very important
      // for example, when upgrading, upgrade packet is sent over,
      // and a nonzero prevBufferLen could cause problems on `drain`
      this.prevBufferLen = 0;

      if (0 === this.writeBuffer.length) {
        this.emit('drain');
      } else {
        this.flush();
      }
    };

    /**
     * Flush write buffers.
     *
     * @api private
     */

    Socket.prototype.flush = function () {
      if ('closed' !== this.readyState && this.transport.writable &&
        !this.upgrading && this.writeBuffer.length) {
        debug('flushing %d packets in socket', this.writeBuffer.length);
        this.transport.send(this.writeBuffer);
        // keep track of current length of writeBuffer
        // splice writeBuffer and callbackBuffer on `drain`
        this.prevBufferLen = this.writeBuffer.length;
        this.emit('flush');
      }
    };

    /**
     * Sends a message.
     *
     * @param {String} message.
     * @param {Function} callback function.
     * @param {Object} options.
     * @return {Socket} for chaining.
     * @api public
     */

    Socket.prototype.write =
    Socket.prototype.send = function (msg, options, fn) {
      this.sendPacket('message', msg, options, fn);
      return this;
    };

    /**
     * Sends a packet.
     *
     * @param {String} packet type.
     * @param {String} data.
     * @param {Object} options.
     * @param {Function} callback function.
     * @api private
     */

    Socket.prototype.sendPacket = function (type, data, options, fn) {
      if ('function' === typeof data) {
        fn = data;
        data = undefined;
      }

      if ('function' === typeof options) {
        fn = options;
        options = null;
      }

      if ('closing' === this.readyState || 'closed' === this.readyState) {
        return;
      }

      options = options || {};
      options.compress = false !== options.compress;

      var packet = {
        type: type,
        data: data,
        options: options
      };
      this.emit('packetCreate', packet);
      this.writeBuffer.push(packet);
      if (fn) this.once('flush', fn);
      this.flush();
    };

    /**
     * Closes the connection.
     *
     * @api private
     */

    Socket.prototype.close = function () {
      if ('opening' === this.readyState || 'open' === this.readyState) {
        this.readyState = 'closing';

        var self = this;

        if (this.writeBuffer.length) {
          this.once('drain', function () {
            if (this.upgrading) {
              waitForUpgrade();
            } else {
              close();
            }
          });
        } else if (this.upgrading) {
          waitForUpgrade();
        } else {
          close();
        }
      }

      function close () {
        self.onClose('forced close');
        debug('socket closing - telling transport to close');
        self.transport.close();
      }

      function cleanupAndClose () {
        self.removeListener('upgrade', cleanupAndClose);
        self.removeListener('upgradeError', cleanupAndClose);
        close();
      }

      function waitForUpgrade () {
        // wait for upgrade to finish since we can't send packets while pausing a transport
        self.once('upgrade', cleanupAndClose);
        self.once('upgradeError', cleanupAndClose);
      }

      return this;
    };

    /**
     * Called upon transport error
     *
     * @api private
     */

    Socket.prototype.onError = function (err) {
      debug('socket error %j', err);
      Socket.priorWebsocketSuccess = false;
      this.emit('error', err);
      this.onClose('transport error', err);
    };

    /**
     * Called upon transport close.
     *
     * @api private
     */

    Socket.prototype.onClose = function (reason, desc) {
      if ('opening' === this.readyState || 'open' === this.readyState || 'closing' === this.readyState) {
        debug('socket close with reason: "%s"', reason);
        var self = this;

        // clear timers
        clearTimeout(this.pingIntervalTimer);
        clearTimeout(this.pingTimeoutTimer);

        // stop event from firing again for transport
        this.transport.removeAllListeners('close');

        // ensure transport won't stay open
        this.transport.close();

        // ignore further transport communication
        this.transport.removeAllListeners();

        // set ready state
        this.readyState = 'closed';

        // clear session id
        this.id = null;

        // emit close event
        this.emit('close', reason, desc);

        // clean buffers after, so users can still
        // grab the buffers on `close` event
        self.writeBuffer = [];
        self.prevBufferLen = 0;
      }
    };

    /**
     * Filters upgrades, returning only those matching client transports.
     *
     * @param {Array} server upgrades
     * @api private
     *
     */

    Socket.prototype.filterUpgrades = function (upgrades) {
      var filteredUpgrades = [];
      for (var i = 0, j = upgrades.length; i < j; i++) {
        if (~index(this.transports, upgrades[i])) filteredUpgrades.push(upgrades[i]);
      }
      return filteredUpgrades;
    };

    }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{"./transport":633,"./transports/index":634,"component-emitter":626,"debug":627,"engine.io-parser":641,"indexof":654,"parsejson":649,"parseqs":650,"parseuri":655}],633:[function(require,module,exports){
    /**
     * Module dependencies.
     */

    var parser = require('engine.io-parser');
    var Emitter = require('component-emitter');

    /**
     * Module exports.
     */

    module.exports = Transport;

    /**
     * Transport abstract constructor.
     *
     * @param {Object} options.
     * @api private
     */

    function Transport (opts) {
      this.path = opts.path;
      this.hostname = opts.hostname;
      this.port = opts.port;
      this.secure = opts.secure;
      this.query = opts.query;
      this.timestampParam = opts.timestampParam;
      this.timestampRequests = opts.timestampRequests;
      this.readyState = '';
      this.agent = opts.agent || false;
      this.socket = opts.socket;
      this.enablesXDR = opts.enablesXDR;

      // SSL options for Node.js client
      this.pfx = opts.pfx;
      this.key = opts.key;
      this.passphrase = opts.passphrase;
      this.cert = opts.cert;
      this.ca = opts.ca;
      this.ciphers = opts.ciphers;
      this.rejectUnauthorized = opts.rejectUnauthorized;
      this.forceNode = opts.forceNode;

      // other options for Node.js client
      this.extraHeaders = opts.extraHeaders;
      this.localAddress = opts.localAddress;
    }

    /**
     * Mix in `Emitter`.
     */

    Emitter(Transport.prototype);

    /**
     * Emits an error.
     *
     * @param {String} str
     * @return {Transport} for chaining
     * @api public
     */

    Transport.prototype.onError = function (msg, desc) {
      var err = new Error(msg);
      err.type = 'TransportError';
      err.description = desc;
      this.emit('error', err);
      return this;
    };

    /**
     * Opens the transport.
     *
     * @api public
     */

    Transport.prototype.open = function () {
      if ('closed' === this.readyState || '' === this.readyState) {
        this.readyState = 'opening';
        this.doOpen();
      }

      return this;
    };

    /**
     * Closes the transport.
     *
     * @api private
     */

    Transport.prototype.close = function () {
      if ('opening' === this.readyState || 'open' === this.readyState) {
        this.doClose();
        this.onClose();
      }

      return this;
    };

    /**
     * Sends multiple packets.
     *
     * @param {Array} packets
     * @api private
     */

    Transport.prototype.send = function (packets) {
      if ('open' === this.readyState) {
        this.write(packets);
      } else {
        throw new Error('Transport not open');
      }
    };

    /**
     * Called upon open
     *
     * @api private
     */

    Transport.prototype.onOpen = function () {
      this.readyState = 'open';
      this.writable = true;
      this.emit('open');
    };

    /**
     * Called with data.
     *
     * @param {String} data
     * @api private
     */

    Transport.prototype.onData = function (data) {
      var packet = parser.decodePacket(data, this.socket.binaryType);
      this.onPacket(packet);
    };

    /**
     * Called with a decoded packet.
     */

    Transport.prototype.onPacket = function (packet) {
      this.emit('packet', packet);
    };

    /**
     * Called upon close.
     *
     * @api private
     */

    Transport.prototype.onClose = function () {
      this.readyState = 'closed';
      this.emit('close');
    };

    },{"component-emitter":626,"engine.io-parser":641}],634:[function(require,module,exports){
    (function (global){
    /**
     * Module dependencies
     */

    var XMLHttpRequest = require('xmlhttprequest-ssl');
    var XHR = require('./polling-xhr');
    var JSONP = require('./polling-jsonp');
    var websocket = require('./websocket');

    /**
     * Export transports.
     */

    exports.polling = polling;
    exports.websocket = websocket;

    /**
     * Polling transport polymorphic constructor.
     * Decides on xhr vs jsonp based on feature detection.
     *
     * @api private
     */

    function polling (opts) {
      var xhr;
      var xd = false;
      var xs = false;
      var jsonp = false !== opts.jsonp;

      if (global.location) {
        var isSSL = 'https:' === location.protocol;
        var port = location.port;

        // some user agents have empty `location.port`
        if (!port) {
          port = isSSL ? 443 : 80;
        }

        xd = opts.hostname !== location.hostname || port !== opts.port;
        xs = opts.secure !== isSSL;
      }

      opts.xdomain = xd;
      opts.xscheme = xs;
      xhr = new XMLHttpRequest(opts);

      if ('open' in xhr && !opts.forceJSONP) {
        return new XHR(opts);
      } else {
        if (!jsonp) throw new Error('JSONP disabled');
        return new JSONP(opts);
      }
    }

    }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{"./polling-jsonp":635,"./polling-xhr":636,"./websocket":638,"xmlhttprequest-ssl":639}],635:[function(require,module,exports){
    (function (global){

    /**
     * Module requirements.
     */

    var Polling = require('./polling');
    var inherit = require('component-inherit');

    /**
     * Module exports.
     */

    module.exports = JSONPPolling;

    /**
     * Cached regular expressions.
     */

    var rNewline = /\n/g;
    var rEscapedNewline = /\\n/g;

    /**
     * Global JSONP callbacks.
     */

    var callbacks;

    /**
     * Noop.
     */

    function empty () { }

    /**
     * JSONP Polling constructor.
     *
     * @param {Object} opts.
     * @api public
     */

    function JSONPPolling (opts) {
      Polling.call(this, opts);

      this.query = this.query || {};

      // define global callbacks array if not present
      // we do this here (lazily) to avoid unneeded global pollution
      if (!callbacks) {
        // we need to consider multiple engines in the same page
        if (!global.___eio) global.___eio = [];
        callbacks = global.___eio;
      }

      // callback identifier
      this.index = callbacks.length;

      // add callback to jsonp global
      var self = this;
      callbacks.push(function (msg) {
        self.onData(msg);
      });

      // append to query string
      this.query.j = this.index;

      // prevent spurious errors from being emitted when the window is unloaded
      if (global.document && global.addEventListener) {
        global.addEventListener('beforeunload', function () {
          if (self.script) self.script.onerror = empty;
        }, false);
      }
    }

    /**
     * Inherits from Polling.
     */

    inherit(JSONPPolling, Polling);

    /*
     * JSONP only supports binary as base64 encoded strings
     */

    JSONPPolling.prototype.supportsBinary = false;

    /**
     * Closes the socket.
     *
     * @api private
     */

    JSONPPolling.prototype.doClose = function () {
      if (this.script) {
        this.script.parentNode.removeChild(this.script);
        this.script = null;
      }

      if (this.form) {
        this.form.parentNode.removeChild(this.form);
        this.form = null;
        this.iframe = null;
      }

      Polling.prototype.doClose.call(this);
    };

    /**
     * Starts a poll cycle.
     *
     * @api private
     */

    JSONPPolling.prototype.doPoll = function () {
      var self = this;
      var script = document.createElement('script');

      if (this.script) {
        this.script.parentNode.removeChild(this.script);
        this.script = null;
      }

      script.async = true;
      script.src = this.uri();
      script.onerror = function (e) {
        self.onError('jsonp poll error', e);
      };

      var insertAt = document.getElementsByTagName('script')[0];
      if (insertAt) {
        insertAt.parentNode.insertBefore(script, insertAt);
      } else {
        (document.head || document.body).appendChild(script);
      }
      this.script = script;

      var isUAgecko = 'undefined' !== typeof navigator && /gecko/i.test(navigator.userAgent);

      if (isUAgecko) {
        setTimeout(function () {
          var iframe = document.createElement('iframe');
          document.body.appendChild(iframe);
          document.body.removeChild(iframe);
        }, 100);
      }
    };

    /**
     * Writes with a hidden iframe.
     *
     * @param {String} data to send
     * @param {Function} called upon flush.
     * @api private
     */

    JSONPPolling.prototype.doWrite = function (data, fn) {
      var self = this;

      if (!this.form) {
        var form = document.createElement('form');
        var area = document.createElement('textarea');
        var id = this.iframeId = 'eio_iframe_' + this.index;
        var iframe;

        form.className = 'socketio';
        form.style.position = 'absolute';
        form.style.top = '-1000px';
        form.style.left = '-1000px';
        form.target = id;
        form.method = 'POST';
        form.setAttribute('accept-charset', 'utf-8');
        area.name = 'd';
        form.appendChild(area);
        document.body.appendChild(form);

        this.form = form;
        this.area = area;
      }

      this.form.action = this.uri();

      function complete () {
        initIframe();
        fn();
      }

      function initIframe () {
        if (self.iframe) {
          try {
            self.form.removeChild(self.iframe);
          } catch (e) {
            self.onError('jsonp polling iframe removal error', e);
          }
        }

        try {
          // ie6 dynamic iframes with target="" support (thanks Chris Lambacher)
          var html = '<iframe src="javascript:0" name="' + self.iframeId + '">';
          iframe = document.createElement(html);
        } catch (e) {
          iframe = document.createElement('iframe');
          iframe.name = self.iframeId;
          iframe.src = 'javascript:0';
        }

        iframe.id = self.iframeId;

        self.form.appendChild(iframe);
        self.iframe = iframe;
      }

      initIframe();

      // escape \n to prevent it from being converted into \r\n by some UAs
      // double escaping is required for escaped new lines because unescaping of new lines can be done safely on server-side
      data = data.replace(rEscapedNewline, '\\\n');
      this.area.value = data.replace(rNewline, '\\n');

      try {
        this.form.submit();
      } catch (e) {}

      if (this.iframe.attachEvent) {
        this.iframe.onreadystatechange = function () {
          if (self.iframe.readyState === 'complete') {
            complete();
          }
        };
      } else {
        this.iframe.onload = complete;
      }
    };

    }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{"./polling":637,"component-inherit":640}],636:[function(require,module,exports){
    (function (global){
    /**
     * Module requirements.
     */

    var XMLHttpRequest = require('xmlhttprequest-ssl');
    var Polling = require('./polling');
    var Emitter = require('component-emitter');
    var inherit = require('component-inherit');
    var debug = require('debug')('engine.io-client:polling-xhr');

    /**
     * Module exports.
     */

    module.exports = XHR;
    module.exports.Request = Request;

    /**
     * Empty function
     */

    function empty () {}

    /**
     * XHR Polling constructor.
     *
     * @param {Object} opts
     * @api public
     */

    function XHR (opts) {
      Polling.call(this, opts);
      this.requestTimeout = opts.requestTimeout;

      if (global.location) {
        var isSSL = 'https:' === location.protocol;
        var port = location.port;

        // some user agents have empty `location.port`
        if (!port) {
          port = isSSL ? 443 : 80;
        }

        this.xd = opts.hostname !== global.location.hostname ||
          port !== opts.port;
        this.xs = opts.secure !== isSSL;
      } else {
        this.extraHeaders = opts.extraHeaders;
      }
    }

    /**
     * Inherits from Polling.
     */

    inherit(XHR, Polling);

    /**
     * XHR supports binary
     */

    XHR.prototype.supportsBinary = true;

    /**
     * Creates a request.
     *
     * @param {String} method
     * @api private
     */

    XHR.prototype.request = function (opts) {
      opts = opts || {};
      opts.uri = this.uri();
      opts.xd = this.xd;
      opts.xs = this.xs;
      opts.agent = this.agent || false;
      opts.supportsBinary = this.supportsBinary;
      opts.enablesXDR = this.enablesXDR;

      // SSL options for Node.js client
      opts.pfx = this.pfx;
      opts.key = this.key;
      opts.passphrase = this.passphrase;
      opts.cert = this.cert;
      opts.ca = this.ca;
      opts.ciphers = this.ciphers;
      opts.rejectUnauthorized = this.rejectUnauthorized;
      opts.requestTimeout = this.requestTimeout;

      // other options for Node.js client
      opts.extraHeaders = this.extraHeaders;

      return new Request(opts);
    };

    /**
     * Sends data.
     *
     * @param {String} data to send.
     * @param {Function} called upon flush.
     * @api private
     */

    XHR.prototype.doWrite = function (data, fn) {
      var isBinary = typeof data !== 'string' && data !== undefined;
      var req = this.request({ method: 'POST', data: data, isBinary: isBinary });
      var self = this;
      req.on('success', fn);
      req.on('error', function (err) {
        self.onError('xhr post error', err);
      });
      this.sendXhr = req;
    };

    /**
     * Starts a poll cycle.
     *
     * @api private
     */

    XHR.prototype.doPoll = function () {
      debug('xhr poll');
      var req = this.request();
      var self = this;
      req.on('data', function (data) {
        self.onData(data);
      });
      req.on('error', function (err) {
        self.onError('xhr poll error', err);
      });
      this.pollXhr = req;
    };

    /**
     * Request constructor
     *
     * @param {Object} options
     * @api public
     */

    function Request (opts) {
      this.method = opts.method || 'GET';
      this.uri = opts.uri;
      this.xd = !!opts.xd;
      this.xs = !!opts.xs;
      this.async = false !== opts.async;
      this.data = undefined !== opts.data ? opts.data : null;
      this.agent = opts.agent;
      this.isBinary = opts.isBinary;
      this.supportsBinary = opts.supportsBinary;
      this.enablesXDR = opts.enablesXDR;
      this.requestTimeout = opts.requestTimeout;

      // SSL options for Node.js client
      this.pfx = opts.pfx;
      this.key = opts.key;
      this.passphrase = opts.passphrase;
      this.cert = opts.cert;
      this.ca = opts.ca;
      this.ciphers = opts.ciphers;
      this.rejectUnauthorized = opts.rejectUnauthorized;

      // other options for Node.js client
      this.extraHeaders = opts.extraHeaders;

      this.create();
    }

    /**
     * Mix in `Emitter`.
     */

    Emitter(Request.prototype);

    /**
     * Creates the XHR object and sends the request.
     *
     * @api private
     */

    Request.prototype.create = function () {
      var opts = { agent: this.agent, xdomain: this.xd, xscheme: this.xs, enablesXDR: this.enablesXDR };

      // SSL options for Node.js client
      opts.pfx = this.pfx;
      opts.key = this.key;
      opts.passphrase = this.passphrase;
      opts.cert = this.cert;
      opts.ca = this.ca;
      opts.ciphers = this.ciphers;
      opts.rejectUnauthorized = this.rejectUnauthorized;

      var xhr = this.xhr = new XMLHttpRequest(opts);
      var self = this;

      try {
        debug('xhr open %s: %s', this.method, this.uri);
        xhr.open(this.method, this.uri, this.async);
        try {
          if (this.extraHeaders) {
            xhr.setDisableHeaderCheck(true);
            for (var i in this.extraHeaders) {
              if (this.extraHeaders.hasOwnProperty(i)) {
                xhr.setRequestHeader(i, this.extraHeaders[i]);
              }
            }
          }
        } catch (e) {}
        if (this.supportsBinary) {
          // This has to be done after open because Firefox is stupid
          // http://stackoverflow.com/questions/13216903/get-binary-data-with-xmlhttprequest-in-a-firefox-extension
          xhr.responseType = 'arraybuffer';
        }

        if ('POST' === this.method) {
          try {
            if (this.isBinary) {
              xhr.setRequestHeader('Content-type', 'application/octet-stream');
            } else {
              xhr.setRequestHeader('Content-type', 'text/plain;charset=UTF-8');
            }
          } catch (e) {}
        }

        try {
          xhr.setRequestHeader('Accept', '*/*');
        } catch (e) {}

        // ie6 check
        if ('withCredentials' in xhr) {
          xhr.withCredentials = true;
        }

        if (this.requestTimeout) {
          xhr.timeout = this.requestTimeout;
        }

        if (this.hasXDR()) {
          xhr.onload = function () {
            self.onLoad();
          };
          xhr.onerror = function () {
            self.onError(xhr.responseText);
          };
        } else {
          xhr.onreadystatechange = function () {
            if (4 !== xhr.readyState) return;
            if (200 === xhr.status || 1223 === xhr.status) {
              self.onLoad();
            } else {
              // make sure the `error` event handler that's user-set
              // does not throw in the same tick and gets caught here
              setTimeout(function () {
                self.onError(xhr.status);
              }, 0);
            }
          };
        }

        debug('xhr data %s', this.data);
        xhr.send(this.data);
      } catch (e) {
        // Need to defer since .create() is called directly fhrom the constructor
        // and thus the 'error' event can only be only bound *after* this exception
        // occurs.  Therefore, also, we cannot throw here at all.
        setTimeout(function () {
          self.onError(e);
        }, 0);
        return;
      }

      if (global.document) {
        this.index = Request.requestsCount++;
        Request.requests[this.index] = this;
      }
    };

    /**
     * Called upon successful response.
     *
     * @api private
     */

    Request.prototype.onSuccess = function () {
      this.emit('success');
      this.cleanup();
    };

    /**
     * Called if we have data.
     *
     * @api private
     */

    Request.prototype.onData = function (data) {
      this.emit('data', data);
      this.onSuccess();
    };

    /**
     * Called upon error.
     *
     * @api private
     */

    Request.prototype.onError = function (err) {
      this.emit('error', err);
      this.cleanup(true);
    };

    /**
     * Cleans up house.
     *
     * @api private
     */

    Request.prototype.cleanup = function (fromError) {
      if ('undefined' === typeof this.xhr || null === this.xhr) {
        return;
      }
      // xmlhttprequest
      if (this.hasXDR()) {
        this.xhr.onload = this.xhr.onerror = empty;
      } else {
        this.xhr.onreadystatechange = empty;
      }

      if (fromError) {
        try {
          this.xhr.abort();
        } catch (e) {}
      }

      if (global.document) {
        delete Request.requests[this.index];
      }

      this.xhr = null;
    };

    /**
     * Called upon load.
     *
     * @api private
     */

    Request.prototype.onLoad = function () {
      var data;
      try {
        var contentType;
        try {
          contentType = this.xhr.getResponseHeader('Content-Type').split(';')[0];
        } catch (e) {}
        if (contentType === 'application/octet-stream') {
          data = this.xhr.response || this.xhr.responseText;
        } else {
          if (!this.supportsBinary) {
            data = this.xhr.responseText;
          } else {
            try {
              data = String.fromCharCode.apply(null, new Uint8Array(this.xhr.response));
            } catch (e) {
              var ui8Arr = new Uint8Array(this.xhr.response);
              var dataArray = [];
              for (var idx = 0, length = ui8Arr.length; idx < length; idx++) {
                dataArray.push(ui8Arr[idx]);
              }

              data = String.fromCharCode.apply(null, dataArray);
            }
          }
        }
      } catch (e) {
        this.onError(e);
      }
      if (null != data) {
        this.onData(data);
      }
    };

    /**
     * Check if it has XDomainRequest.
     *
     * @api private
     */

    Request.prototype.hasXDR = function () {
      return 'undefined' !== typeof global.XDomainRequest && !this.xs && this.enablesXDR;
    };

    /**
     * Aborts the request.
     *
     * @api public
     */

    Request.prototype.abort = function () {
      this.cleanup();
    };

    /**
     * Aborts pending requests when unloading the window. This is needed to prevent
     * memory leaks (e.g. when using IE) and to ensure that no spurious error is
     * emitted.
     */

    Request.requestsCount = 0;
    Request.requests = {};

    if (global.document) {
      if (global.attachEvent) {
        global.attachEvent('onunload', unloadHandler);
      } else if (global.addEventListener) {
        global.addEventListener('beforeunload', unloadHandler, false);
      }
    }

    function unloadHandler () {
      for (var i in Request.requests) {
        if (Request.requests.hasOwnProperty(i)) {
          Request.requests[i].abort();
        }
      }
    }

    }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{"./polling":637,"component-emitter":626,"component-inherit":640,"debug":627,"xmlhttprequest-ssl":639}],637:[function(require,module,exports){
    /**
     * Module dependencies.
     */

    var Transport = require('../transport');
    var parseqs = require('parseqs');
    var parser = require('engine.io-parser');
    var inherit = require('component-inherit');
    var yeast = require('yeast');
    var debug = require('debug')('engine.io-client:polling');

    /**
     * Module exports.
     */

    module.exports = Polling;

    /**
     * Is XHR2 supported?
     */

    var hasXHR2 = (function () {
      var XMLHttpRequest = require('xmlhttprequest-ssl');
      var xhr = new XMLHttpRequest({ xdomain: false });
      return null != xhr.responseType;
    })();

    /**
     * Polling interface.
     *
     * @param {Object} opts
     * @api private
     */

    function Polling (opts) {
      var forceBase64 = (opts && opts.forceBase64);
      if (!hasXHR2 || forceBase64) {
        this.supportsBinary = false;
      }
      Transport.call(this, opts);
    }

    /**
     * Inherits from Transport.
     */

    inherit(Polling, Transport);

    /**
     * Transport name.
     */

    Polling.prototype.name = 'polling';

    /**
     * Opens the socket (triggers polling). We write a PING message to determine
     * when the transport is open.
     *
     * @api private
     */

    Polling.prototype.doOpen = function () {
      this.poll();
    };

    /**
     * Pauses polling.
     *
     * @param {Function} callback upon buffers are flushed and transport is paused
     * @api private
     */

    Polling.prototype.pause = function (onPause) {
      var self = this;

      this.readyState = 'pausing';

      function pause () {
        debug('paused');
        self.readyState = 'paused';
        onPause();
      }

      if (this.polling || !this.writable) {
        var total = 0;

        if (this.polling) {
          debug('we are currently polling - waiting to pause');
          total++;
          this.once('pollComplete', function () {
            debug('pre-pause polling complete');
            --total || pause();
          });
        }

        if (!this.writable) {
          debug('we are currently writing - waiting to pause');
          total++;
          this.once('drain', function () {
            debug('pre-pause writing complete');
            --total || pause();
          });
        }
      } else {
        pause();
      }
    };

    /**
     * Starts polling cycle.
     *
     * @api public
     */

    Polling.prototype.poll = function () {
      debug('polling');
      this.polling = true;
      this.doPoll();
      this.emit('poll');
    };

    /**
     * Overloads onData to detect payloads.
     *
     * @api private
     */

    Polling.prototype.onData = function (data) {
      var self = this;
      debug('polling got data %s', data);
      var callback = function (packet, index, total) {
        // if its the first message we consider the transport open
        if ('opening' === self.readyState) {
          self.onOpen();
        }

        // if its a close packet, we close the ongoing requests
        if ('close' === packet.type) {
          self.onClose();
          return false;
        }

        // otherwise bypass onData and handle the message
        self.onPacket(packet);
      };

      // decode payload
      parser.decodePayload(data, this.socket.binaryType, callback);

      // if an event did not trigger closing
      if ('closed' !== this.readyState) {
        // if we got data we're not polling
        this.polling = false;
        this.emit('pollComplete');

        if ('open' === this.readyState) {
          this.poll();
        } else {
          debug('ignoring poll - transport state "%s"', this.readyState);
        }
      }
    };

    /**
     * For polling, send a close packet.
     *
     * @api private
     */

    Polling.prototype.doClose = function () {
      var self = this;

      function close () {
        debug('writing close packet');
        self.write([{ type: 'close' }]);
      }

      if ('open' === this.readyState) {
        debug('transport open - closing');
        close();
      } else {
        // in case we're trying to close while
        // handshaking is in progress (GH-164)
        debug('transport not open - deferring close');
        this.once('open', close);
      }
    };

    /**
     * Writes a packets payload.
     *
     * @param {Array} data packets
     * @param {Function} drain callback
     * @api private
     */

    Polling.prototype.write = function (packets) {
      var self = this;
      this.writable = false;
      var callbackfn = function () {
        self.writable = true;
        self.emit('drain');
      };

      parser.encodePayload(packets, this.supportsBinary, function (data) {
        self.doWrite(data, callbackfn);
      });
    };

    /**
     * Generates uri for connection.
     *
     * @api private
     */

    Polling.prototype.uri = function () {
      var query = this.query || {};
      var schema = this.secure ? 'https' : 'http';
      var port = '';

      // cache busting is forced
      if (false !== this.timestampRequests) {
        query[this.timestampParam] = yeast();
      }

      if (!this.supportsBinary && !query.sid) {
        query.b64 = 1;
      }

      query = parseqs.encode(query);

      // avoid port if default for schema
      if (this.port && (('https' === schema && Number(this.port) !== 443) ||
         ('http' === schema && Number(this.port) !== 80))) {
        port = ':' + this.port;
      }

      // prepend ? to query
      if (query.length) {
        query = '?' + query;
      }

      var ipv6 = this.hostname.indexOf(':') !== -1;
      return schema + '://' + (ipv6 ? '[' + this.hostname + ']' : this.hostname) + port + this.path + query;
    };

    },{"../transport":633,"component-inherit":640,"debug":627,"engine.io-parser":641,"parseqs":650,"xmlhttprequest-ssl":639,"yeast":651}],638:[function(require,module,exports){
    (function (global){
    /**
     * Module dependencies.
     */

    var Transport = require('../transport');
    var parser = require('engine.io-parser');
    var parseqs = require('parseqs');
    var inherit = require('component-inherit');
    var yeast = require('yeast');
    var debug = require('debug')('engine.io-client:websocket');
    var BrowserWebSocket = global.WebSocket || global.MozWebSocket;
    var NodeWebSocket;
    if (typeof window === 'undefined') {
      try {
        NodeWebSocket = require('ws');
      } catch (e) { }
    }

    /**
     * Get either the `WebSocket` or `MozWebSocket` globals
     * in the browser or try to resolve WebSocket-compatible
     * interface exposed by `ws` for Node-like environment.
     */

    var WebSocket = BrowserWebSocket;
    if (!WebSocket && typeof window === 'undefined') {
      WebSocket = NodeWebSocket;
    }

    /**
     * Module exports.
     */

    module.exports = WS;

    /**
     * WebSocket transport constructor.
     *
     * @api {Object} connection options
     * @api public
     */

    function WS (opts) {
      var forceBase64 = (opts && opts.forceBase64);
      if (forceBase64) {
        this.supportsBinary = false;
      }
      this.perMessageDeflate = opts.perMessageDeflate;
      this.usingBrowserWebSocket = BrowserWebSocket && !opts.forceNode;
      if (!this.usingBrowserWebSocket) {
        WebSocket = NodeWebSocket;
      }
      Transport.call(this, opts);
    }

    /**
     * Inherits from Transport.
     */

    inherit(WS, Transport);

    /**
     * Transport name.
     *
     * @api public
     */

    WS.prototype.name = 'websocket';

    /*
     * WebSockets support binary
     */

    WS.prototype.supportsBinary = true;

    /**
     * Opens socket.
     *
     * @api private
     */

    WS.prototype.doOpen = function () {
      if (!this.check()) {
        // let probe timeout
        return;
      }

      var uri = this.uri();
      var protocols = void (0);
      var opts = {
        agent: this.agent,
        perMessageDeflate: this.perMessageDeflate
      };

      // SSL options for Node.js client
      opts.pfx = this.pfx;
      opts.key = this.key;
      opts.passphrase = this.passphrase;
      opts.cert = this.cert;
      opts.ca = this.ca;
      opts.ciphers = this.ciphers;
      opts.rejectUnauthorized = this.rejectUnauthorized;
      if (this.extraHeaders) {
        opts.headers = this.extraHeaders;
      }
      if (this.localAddress) {
        opts.localAddress = this.localAddress;
      }

      try {
        this.ws = this.usingBrowserWebSocket ? new WebSocket(uri) : new WebSocket(uri, protocols, opts);
      } catch (err) {
        return this.emit('error', err);
      }

      if (this.ws.binaryType === undefined) {
        this.supportsBinary = false;
      }

      if (this.ws.supports && this.ws.supports.binary) {
        this.supportsBinary = true;
        this.ws.binaryType = 'nodebuffer';
      } else {
        this.ws.binaryType = 'arraybuffer';
      }

      this.addEventListeners();
    };

    /**
     * Adds event listeners to the socket
     *
     * @api private
     */

    WS.prototype.addEventListeners = function () {
      var self = this;

      this.ws.onopen = function () {
        self.onOpen();
      };
      this.ws.onclose = function () {
        self.onClose();
      };
      this.ws.onmessage = function (ev) {
        self.onData(ev.data);
      };
      this.ws.onerror = function (e) {
        self.onError('websocket error', e);
      };
    };

    /**
     * Writes data to socket.
     *
     * @param {Array} array of packets.
     * @api private
     */

    WS.prototype.write = function (packets) {
      var self = this;
      this.writable = false;

      // encodePacket efficient as it uses WS framing
      // no need for encodePayload
      var total = packets.length;
      for (var i = 0, l = total; i < l; i++) {
        (function (packet) {
          parser.encodePacket(packet, self.supportsBinary, function (data) {
            if (!self.usingBrowserWebSocket) {
              // always create a new object (GH-437)
              var opts = {};
              if (packet.options) {
                opts.compress = packet.options.compress;
              }

              if (self.perMessageDeflate) {
                var len = 'string' === typeof data ? global.Buffer.byteLength(data) : data.length;
                if (len < self.perMessageDeflate.threshold) {
                  opts.compress = false;
                }
              }
            }

            // Sometimes the websocket has already been closed but the browser didn't
            // have a chance of informing us about it yet, in that case send will
            // throw an error
            try {
              if (self.usingBrowserWebSocket) {
                // TypeError is thrown when passing the second argument on Safari
                self.ws.send(data);
              } else {
                self.ws.send(data, opts);
              }
            } catch (e) {
              debug('websocket closed before onclose event');
            }

            --total || done();
          });
        })(packets[i]);
      }

      function done () {
        self.emit('flush');

        // fake drain
        // defer to next tick to allow Socket to clear writeBuffer
        setTimeout(function () {
          self.writable = true;
          self.emit('drain');
        }, 0);
      }
    };

    /**
     * Called upon close
     *
     * @api private
     */

    WS.prototype.onClose = function () {
      Transport.prototype.onClose.call(this);
    };

    /**
     * Closes socket.
     *
     * @api private
     */

    WS.prototype.doClose = function () {
      if (typeof this.ws !== 'undefined') {
        this.ws.close();
      }
    };

    /**
     * Generates uri for connection.
     *
     * @api private
     */

    WS.prototype.uri = function () {
      var query = this.query || {};
      var schema = this.secure ? 'wss' : 'ws';
      var port = '';

      // avoid port if default for schema
      if (this.port && (('wss' === schema && Number(this.port) !== 443) ||
        ('ws' === schema && Number(this.port) !== 80))) {
        port = ':' + this.port;
      }

      // append timestamp to URI
      if (this.timestampRequests) {
        query[this.timestampParam] = yeast();
      }

      // communicate binary support capabilities
      if (!this.supportsBinary) {
        query.b64 = 1;
      }

      query = parseqs.encode(query);

      // prepend ? to query
      if (query.length) {
        query = '?' + query;
      }

      var ipv6 = this.hostname.indexOf(':') !== -1;
      return schema + '://' + (ipv6 ? '[' + this.hostname + ']' : this.hostname) + port + this.path + query;
    };

    /**
     * Feature detection for WebSocket.
     *
     * @return {Boolean} whether this transport is available.
     * @api public
     */

    WS.prototype.check = function () {
      return !!WebSocket && !('__initialize' in WebSocket && this.name === WS.prototype.name);
    };

    }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{"../transport":633,"component-inherit":640,"debug":627,"engine.io-parser":641,"parseqs":650,"ws":727,"yeast":651}],639:[function(require,module,exports){
    (function (global){
    // browser shim for xmlhttprequest module

    var hasCORS = require('has-cors');

    module.exports = function (opts) {
      var xdomain = opts.xdomain;

      // scheme must be same when usign XDomainRequest
      // http://blogs.msdn.com/b/ieinternals/archive/2010/05/13/xdomainrequest-restrictions-limitations-and-workarounds.aspx
      var xscheme = opts.xscheme;

      // XDomainRequest has a flow of not sending cookie, therefore it should be disabled as a default.
      // https://github.com/Automattic/engine.io-client/pull/217
      var enablesXDR = opts.enablesXDR;

      // XMLHttpRequest can be disabled on IE
      try {
        if ('undefined' !== typeof XMLHttpRequest && (!xdomain || hasCORS)) {
          return new XMLHttpRequest();
        }
      } catch (e) { }

      // Use XDomainRequest for IE8 if enablesXDR is true
      // because loading bar keeps flashing when using jsonp-polling
      // https://github.com/yujiosaka/socke.io-ie8-loading-example
      try {
        if ('undefined' !== typeof XDomainRequest && !xscheme && enablesXDR) {
          return new XDomainRequest();
        }
      } catch (e) { }

      if (!xdomain) {
        try {
          return new global[['Active'].concat('Object').join('X')]('Microsoft.XMLHTTP');
        } catch (e) { }
      }
    };

    }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{"has-cors":648}],640:[function(require,module,exports){

    module.exports = function(a, b){
      var fn = function(){};
      fn.prototype = b.prototype;
      a.prototype = new fn;
      a.prototype.constructor = a;
    };

    },{}],641:[function(require,module,exports){
    (function (global){
    /**
     * Module dependencies.
     */

    var keys = require('./keys');
    var hasBinary = require('has-binary');
    var sliceBuffer = require('arraybuffer.slice');
    var after = require('after');
    var utf8 = require('wtf-8');

    var base64encoder;
    if (global && global.ArrayBuffer) {
      base64encoder = require('base64-arraybuffer');
    }

    /**
     * Check if we are running an android browser. That requires us to use
     * ArrayBuffer with polling transports...
     *
     * http://ghinda.net/jpeg-blob-ajax-android/
     */

    var isAndroid = typeof navigator !== 'undefined' && /Android/i.test(navigator.userAgent);

    /**
     * Check if we are running in PhantomJS.
     * Uploading a Blob with PhantomJS does not work correctly, as reported here:
     * https://github.com/ariya/phantomjs/issues/11395
     * @type boolean
     */
    var isPhantomJS = typeof navigator !== 'undefined' && /PhantomJS/i.test(navigator.userAgent);

    /**
     * When true, avoids using Blobs to encode payloads.
     * @type boolean
     */
    var dontSendBlobs = isAndroid || isPhantomJS;

    /**
     * Current protocol version.
     */

    exports.protocol = 3;

    /**
     * Packet types.
     */

    var packets = exports.packets = {
        open:     0    // non-ws
      , close:    1    // non-ws
      , ping:     2
      , pong:     3
      , message:  4
      , upgrade:  5
      , noop:     6
    };

    var packetslist = keys(packets);

    /**
     * Premade error packet.
     */

    var err = { type: 'error', data: 'parser error' };

    /**
     * Create a blob api even for blob builder when vendor prefixes exist
     */

    var Blob = require('blob');

    /**
     * Encodes a packet.
     *
     *     <packet type id> [ <data> ]
     *
     * Example:
     *
     *     5hello world
     *     3
     *     4
     *
     * Binary is encoded in an identical principle
     *
     * @api private
     */

    exports.encodePacket = function (packet, supportsBinary, utf8encode, callback) {
      if ('function' == typeof supportsBinary) {
        callback = supportsBinary;
        supportsBinary = false;
      }

      if ('function' == typeof utf8encode) {
        callback = utf8encode;
        utf8encode = null;
      }

      var data = (packet.data === undefined)
        ? undefined
        : packet.data.buffer || packet.data;

      if (global.ArrayBuffer && data instanceof ArrayBuffer) {
        return encodeArrayBuffer(packet, supportsBinary, callback);
      } else if (Blob && data instanceof global.Blob) {
        return encodeBlob(packet, supportsBinary, callback);
      }

      // might be an object with { base64: true, data: dataAsBase64String }
      if (data && data.base64) {
        return encodeBase64Object(packet, callback);
      }

      // Sending data as a utf-8 string
      var encoded = packets[packet.type];

      // data fragment is optional
      if (undefined !== packet.data) {
        encoded += utf8encode ? utf8.encode(String(packet.data)) : String(packet.data);
      }

      return callback('' + encoded);

    };

    function encodeBase64Object(packet, callback) {
      // packet data is an object { base64: true, data: dataAsBase64String }
      var message = 'b' + exports.packets[packet.type] + packet.data.data;
      return callback(message);
    }

    /**
     * Encode packet helpers for binary types
     */

    function encodeArrayBuffer(packet, supportsBinary, callback) {
      if (!supportsBinary) {
        return exports.encodeBase64Packet(packet, callback);
      }

      var data = packet.data;
      var contentArray = new Uint8Array(data);
      var resultBuffer = new Uint8Array(1 + data.byteLength);

      resultBuffer[0] = packets[packet.type];
      for (var i = 0; i < contentArray.length; i++) {
        resultBuffer[i+1] = contentArray[i];
      }

      return callback(resultBuffer.buffer);
    }

    function encodeBlobAsArrayBuffer(packet, supportsBinary, callback) {
      if (!supportsBinary) {
        return exports.encodeBase64Packet(packet, callback);
      }

      var fr = new FileReader();
      fr.onload = function() {
        packet.data = fr.result;
        exports.encodePacket(packet, supportsBinary, true, callback);
      };
      return fr.readAsArrayBuffer(packet.data);
    }

    function encodeBlob(packet, supportsBinary, callback) {
      if (!supportsBinary) {
        return exports.encodeBase64Packet(packet, callback);
      }

      if (dontSendBlobs) {
        return encodeBlobAsArrayBuffer(packet, supportsBinary, callback);
      }

      var length = new Uint8Array(1);
      length[0] = packets[packet.type];
      var blob = new Blob([length.buffer, packet.data]);

      return callback(blob);
    }

    /**
     * Encodes a packet with binary data in a base64 string
     *
     * @param {Object} packet, has `type` and `data`
     * @return {String} base64 encoded message
     */

    exports.encodeBase64Packet = function(packet, callback) {
      var message = 'b' + exports.packets[packet.type];
      if (Blob && packet.data instanceof global.Blob) {
        var fr = new FileReader();
        fr.onload = function() {
          var b64 = fr.result.split(',')[1];
          callback(message + b64);
        };
        return fr.readAsDataURL(packet.data);
      }

      var b64data;
      try {
        b64data = String.fromCharCode.apply(null, new Uint8Array(packet.data));
      } catch (e) {
        // iPhone Safari doesn't let you apply with typed arrays
        var typed = new Uint8Array(packet.data);
        var basic = new Array(typed.length);
        for (var i = 0; i < typed.length; i++) {
          basic[i] = typed[i];
        }
        b64data = String.fromCharCode.apply(null, basic);
      }
      message += global.btoa(b64data);
      return callback(message);
    };

    /**
     * Decodes a packet. Changes format to Blob if requested.
     *
     * @return {Object} with `type` and `data` (if any)
     * @api private
     */

    exports.decodePacket = function (data, binaryType, utf8decode) {
      if (data === undefined) {
        return err;
      }
      // String data
      if (typeof data == 'string') {
        if (data.charAt(0) == 'b') {
          return exports.decodeBase64Packet(data.substr(1), binaryType);
        }

        if (utf8decode) {
          data = tryDecode(data);
          if (data === false) {
            return err;
          }
        }
        var type = data.charAt(0);

        if (Number(type) != type || !packetslist[type]) {
          return err;
        }

        if (data.length > 1) {
          return { type: packetslist[type], data: data.substring(1) };
        } else {
          return { type: packetslist[type] };
        }
      }

      var asArray = new Uint8Array(data);
      var type = asArray[0];
      var rest = sliceBuffer(data, 1);
      if (Blob && binaryType === 'blob') {
        rest = new Blob([rest]);
      }
      return { type: packetslist[type], data: rest };
    };

    function tryDecode(data) {
      try {
        data = utf8.decode(data);
      } catch (e) {
        return false;
      }
      return data;
    }

    /**
     * Decodes a packet encoded in a base64 string
     *
     * @param {String} base64 encoded message
     * @return {Object} with `type` and `data` (if any)
     */

    exports.decodeBase64Packet = function(msg, binaryType) {
      var type = packetslist[msg.charAt(0)];
      if (!base64encoder) {
        return { type: type, data: { base64: true, data: msg.substr(1) } };
      }

      var data = base64encoder.decode(msg.substr(1));

      if (binaryType === 'blob' && Blob) {
        data = new Blob([data]);
      }

      return { type: type, data: data };
    };

    /**
     * Encodes multiple messages (payload).
     *
     *     <length>:data
     *
     * Example:
     *
     *     11:hello world2:hi
     *
     * If any contents are binary, they will be encoded as base64 strings. Base64
     * encoded strings are marked with a b before the length specifier
     *
     * @param {Array} packets
     * @api private
     */

    exports.encodePayload = function (packets, supportsBinary, callback) {
      if (typeof supportsBinary == 'function') {
        callback = supportsBinary;
        supportsBinary = null;
      }

      var isBinary = hasBinary(packets);

      if (supportsBinary && isBinary) {
        if (Blob && !dontSendBlobs) {
          return exports.encodePayloadAsBlob(packets, callback);
        }

        return exports.encodePayloadAsArrayBuffer(packets, callback);
      }

      if (!packets.length) {
        return callback('0:');
      }

      function setLengthHeader(message) {
        return message.length + ':' + message;
      }

      function encodeOne(packet, doneCallback) {
        exports.encodePacket(packet, !isBinary ? false : supportsBinary, true, function(message) {
          doneCallback(null, setLengthHeader(message));
        });
      }

      map(packets, encodeOne, function(err, results) {
        return callback(results.join(''));
      });
    };

    /**
     * Async array map using after
     */

    function map(ary, each, done) {
      var result = new Array(ary.length);
      var next = after(ary.length, done);

      var eachWithIndex = function(i, el, cb) {
        each(el, function(error, msg) {
          result[i] = msg;
          cb(error, result);
        });
      };

      for (var i = 0; i < ary.length; i++) {
        eachWithIndex(i, ary[i], next);
      }
    }

    /*
     * Decodes data when a payload is maybe expected. Possible binary contents are
     * decoded from their base64 representation
     *
     * @param {String} data, callback method
     * @api public
     */

    exports.decodePayload = function (data, binaryType, callback) {
      if (typeof data != 'string') {
        return exports.decodePayloadAsBinary(data, binaryType, callback);
      }

      if (typeof binaryType === 'function') {
        callback = binaryType;
        binaryType = null;
      }

      var packet;
      if (data == '') {
        // parser error - ignoring payload
        return callback(err, 0, 1);
      }

      var length = ''
        , n, msg;

      for (var i = 0, l = data.length; i < l; i++) {
        var chr = data.charAt(i);

        if (':' != chr) {
          length += chr;
        } else {
          if ('' == length || (length != (n = Number(length)))) {
            // parser error - ignoring payload
            return callback(err, 0, 1);
          }

          msg = data.substr(i + 1, n);

          if (length != msg.length) {
            // parser error - ignoring payload
            return callback(err, 0, 1);
          }

          if (msg.length) {
            packet = exports.decodePacket(msg, binaryType, true);

            if (err.type == packet.type && err.data == packet.data) {
              // parser error in individual packet - ignoring payload
              return callback(err, 0, 1);
            }

            var ret = callback(packet, i + n, l);
            if (false === ret) return;
          }

          // advance cursor
          i += n;
          length = '';
        }
      }

      if (length != '') {
        // parser error - ignoring payload
        return callback(err, 0, 1);
      }

    };

    /**
     * Encodes multiple messages (payload) as binary.
     *
     * <1 = binary, 0 = string><number from 0-9><number from 0-9>[...]<number
     * 255><data>
     *
     * Example:
     * 1 3 255 1 2 3, if the binary contents are interpreted as 8 bit integers
     *
     * @param {Array} packets
     * @return {ArrayBuffer} encoded payload
     * @api private
     */

    exports.encodePayloadAsArrayBuffer = function(packets, callback) {
      if (!packets.length) {
        return callback(new ArrayBuffer(0));
      }

      function encodeOne(packet, doneCallback) {
        exports.encodePacket(packet, true, true, function(data) {
          return doneCallback(null, data);
        });
      }

      map(packets, encodeOne, function(err, encodedPackets) {
        var totalLength = encodedPackets.reduce(function(acc, p) {
          var len;
          if (typeof p === 'string'){
            len = p.length;
          } else {
            len = p.byteLength;
          }
          return acc + len.toString().length + len + 2; // string/binary identifier + separator = 2
        }, 0);

        var resultArray = new Uint8Array(totalLength);

        var bufferIndex = 0;
        encodedPackets.forEach(function(p) {
          var isString = typeof p === 'string';
          var ab = p;
          if (isString) {
            var view = new Uint8Array(p.length);
            for (var i = 0; i < p.length; i++) {
              view[i] = p.charCodeAt(i);
            }
            ab = view.buffer;
          }

          if (isString) { // not true binary
            resultArray[bufferIndex++] = 0;
          } else { // true binary
            resultArray[bufferIndex++] = 1;
          }

          var lenStr = ab.byteLength.toString();
          for (var i = 0; i < lenStr.length; i++) {
            resultArray[bufferIndex++] = parseInt(lenStr[i]);
          }
          resultArray[bufferIndex++] = 255;

          var view = new Uint8Array(ab);
          for (var i = 0; i < view.length; i++) {
            resultArray[bufferIndex++] = view[i];
          }
        });

        return callback(resultArray.buffer);
      });
    };

    /**
     * Encode as Blob
     */

    exports.encodePayloadAsBlob = function(packets, callback) {
      function encodeOne(packet, doneCallback) {
        exports.encodePacket(packet, true, true, function(encoded) {
          var binaryIdentifier = new Uint8Array(1);
          binaryIdentifier[0] = 1;
          if (typeof encoded === 'string') {
            var view = new Uint8Array(encoded.length);
            for (var i = 0; i < encoded.length; i++) {
              view[i] = encoded.charCodeAt(i);
            }
            encoded = view.buffer;
            binaryIdentifier[0] = 0;
          }

          var len = (encoded instanceof ArrayBuffer)
            ? encoded.byteLength
            : encoded.size;

          var lenStr = len.toString();
          var lengthAry = new Uint8Array(lenStr.length + 1);
          for (var i = 0; i < lenStr.length; i++) {
            lengthAry[i] = parseInt(lenStr[i]);
          }
          lengthAry[lenStr.length] = 255;

          if (Blob) {
            var blob = new Blob([binaryIdentifier.buffer, lengthAry.buffer, encoded]);
            doneCallback(null, blob);
          }
        });
      }

      map(packets, encodeOne, function(err, results) {
        return callback(new Blob(results));
      });
    };

    /*
     * Decodes data when a payload is maybe expected. Strings are decoded by
     * interpreting each byte as a key code for entries marked to start with 0. See
     * description of encodePayloadAsBinary
     *
     * @param {ArrayBuffer} data, callback method
     * @api public
     */

    exports.decodePayloadAsBinary = function (data, binaryType, callback) {
      if (typeof binaryType === 'function') {
        callback = binaryType;
        binaryType = null;
      }

      var bufferTail = data;
      var buffers = [];

      var numberTooLong = false;
      while (bufferTail.byteLength > 0) {
        var tailArray = new Uint8Array(bufferTail);
        var isString = tailArray[0] === 0;
        var msgLength = '';

        for (var i = 1; ; i++) {
          if (tailArray[i] == 255) break;

          if (msgLength.length > 310) {
            numberTooLong = true;
            break;
          }

          msgLength += tailArray[i];
        }

        if(numberTooLong) return callback(err, 0, 1);

        bufferTail = sliceBuffer(bufferTail, 2 + msgLength.length);
        msgLength = parseInt(msgLength);

        var msg = sliceBuffer(bufferTail, 0, msgLength);
        if (isString) {
          try {
            msg = String.fromCharCode.apply(null, new Uint8Array(msg));
          } catch (e) {
            // iPhone Safari doesn't let you apply to typed arrays
            var typed = new Uint8Array(msg);
            msg = '';
            for (var i = 0; i < typed.length; i++) {
              msg += String.fromCharCode(typed[i]);
            }
          }
        }

        buffers.push(msg);
        bufferTail = sliceBuffer(bufferTail, msgLength);
      }

      var total = buffers.length;
      buffers.forEach(function(buffer, i) {
        callback(exports.decodePacket(buffer, binaryType, true), i, total);
      });
    };

    }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{"./keys":642,"after":643,"arraybuffer.slice":644,"base64-arraybuffer":645,"blob":646,"has-binary":652,"wtf-8":647}],642:[function(require,module,exports){

    /**
     * Gets the keys for an object.
     *
     * @return {Array} keys
     * @api private
     */

    module.exports = Object.keys || function keys (obj){
      var arr = [];
      var has = Object.prototype.hasOwnProperty;

      for (var i in obj) {
        if (has.call(obj, i)) {
          arr.push(i);
        }
      }
      return arr;
    };

    },{}],643:[function(require,module,exports){
    module.exports = after

    function after(count, callback, err_cb) {
        var bail = false
        err_cb = err_cb || noop
        proxy.count = count

        return (count === 0) ? callback() : proxy

        function proxy(err, result) {
            if (proxy.count <= 0) {
                throw new Error('after called too many times')
            }
            --proxy.count

            // after first error, rest are passed to err_cb
            if (err) {
                bail = true
                callback(err)
                // future error callbacks will go to error handler
                callback = err_cb
            } else if (proxy.count === 0 && !bail) {
                callback(null, result)
            }
        }
    }

    function noop() {}

    },{}],644:[function(require,module,exports){
    /**
     * An abstraction for slicing an arraybuffer even when
     * ArrayBuffer.prototype.slice is not supported
     *
     * @api public
     */

    module.exports = function(arraybuffer, start, end) {
      var bytes = arraybuffer.byteLength;
      start = start || 0;
      end = end || bytes;

      if (arraybuffer.slice) { return arraybuffer.slice(start, end); }

      if (start < 0) { start += bytes; }
      if (end < 0) { end += bytes; }
      if (end > bytes) { end = bytes; }

      if (start >= bytes || start >= end || bytes === 0) {
        return new ArrayBuffer(0);
      }

      var abv = new Uint8Array(arraybuffer);
      var result = new Uint8Array(end - start);
      for (var i = start, ii = 0; i < end; i++, ii++) {
        result[ii] = abv[i];
      }
      return result.buffer;
    };

    },{}],645:[function(require,module,exports){
    /*
     * base64-arraybuffer
     * https://github.com/niklasvh/base64-arraybuffer
     *
     * Copyright (c) 2012 Niklas von Hertzen
     * Licensed under the MIT license.
     */
    (function(){
      "use strict";

      var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

      // Use a lookup table to find the index.
      var lookup = new Uint8Array(256);
      for (var i = 0; i < chars.length; i++) {
        lookup[chars.charCodeAt(i)] = i;
      }

      exports.encode = function(arraybuffer) {
        var bytes = new Uint8Array(arraybuffer),
        i, len = bytes.length, base64 = "";

        for (i = 0; i < len; i+=3) {
          base64 += chars[bytes[i] >> 2];
          base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];
          base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];
          base64 += chars[bytes[i + 2] & 63];
        }

        if ((len % 3) === 2) {
          base64 = base64.substring(0, base64.length - 1) + "=";
        } else if (len % 3 === 1) {
          base64 = base64.substring(0, base64.length - 2) + "==";
        }

        return base64;
      };

      exports.decode =  function(base64) {
        var bufferLength = base64.length * 0.75,
        len = base64.length, i, p = 0,
        encoded1, encoded2, encoded3, encoded4;

        if (base64[base64.length - 1] === "=") {
          bufferLength--;
          if (base64[base64.length - 2] === "=") {
            bufferLength--;
          }
        }

        var arraybuffer = new ArrayBuffer(bufferLength),
        bytes = new Uint8Array(arraybuffer);

        for (i = 0; i < len; i+=4) {
          encoded1 = lookup[base64.charCodeAt(i)];
          encoded2 = lookup[base64.charCodeAt(i+1)];
          encoded3 = lookup[base64.charCodeAt(i+2)];
          encoded4 = lookup[base64.charCodeAt(i+3)];

          bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
          bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
          bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
        }

        return arraybuffer;
      };
    })();

    },{}],646:[function(require,module,exports){
    (function (global){
    /**
     * Create a blob builder even when vendor prefixes exist
     */

    var BlobBuilder = global.BlobBuilder
      || global.WebKitBlobBuilder
      || global.MSBlobBuilder
      || global.MozBlobBuilder;

    /**
     * Check if Blob constructor is supported
     */

    var blobSupported = (function() {
      try {
        var a = new Blob(['hi']);
        return a.size === 2;
      } catch(e) {
        return false;
      }
    })();

    /**
     * Check if Blob constructor supports ArrayBufferViews
     * Fails in Safari 6, so we need to map to ArrayBuffers there.
     */

    var blobSupportsArrayBufferView = blobSupported && (function() {
      try {
        var b = new Blob([new Uint8Array([1,2])]);
        return b.size === 2;
      } catch(e) {
        return false;
      }
    })();

    /**
     * Check if BlobBuilder is supported
     */

    var blobBuilderSupported = BlobBuilder
      && BlobBuilder.prototype.append
      && BlobBuilder.prototype.getBlob;

    /**
     * Helper function that maps ArrayBufferViews to ArrayBuffers
     * Used by BlobBuilder constructor and old browsers that didn't
     * support it in the Blob constructor.
     */

    function mapArrayBufferViews(ary) {
      for (var i = 0; i < ary.length; i++) {
        var chunk = ary[i];
        if (chunk.buffer instanceof ArrayBuffer) {
          var buf = chunk.buffer;

          // if this is a subarray, make a copy so we only
          // include the subarray region from the underlying buffer
          if (chunk.byteLength !== buf.byteLength) {
            var copy = new Uint8Array(chunk.byteLength);
            copy.set(new Uint8Array(buf, chunk.byteOffset, chunk.byteLength));
            buf = copy.buffer;
          }

          ary[i] = buf;
        }
      }
    }

    function BlobBuilderConstructor(ary, options) {
      options = options || {};

      var bb = new BlobBuilder();
      mapArrayBufferViews(ary);

      for (var i = 0; i < ary.length; i++) {
        bb.append(ary[i]);
      }

      return (options.type) ? bb.getBlob(options.type) : bb.getBlob();
    };

    function BlobConstructor(ary, options) {
      mapArrayBufferViews(ary);
      return new Blob(ary, options || {});
    };

    module.exports = (function() {
      if (blobSupported) {
        return blobSupportsArrayBufferView ? global.Blob : BlobConstructor;
      } else if (blobBuilderSupported) {
        return BlobBuilderConstructor;
      } else {
        return undefined;
      }
    })();

    }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{}],647:[function(require,module,exports){
    (function (global){
    /*! https://mths.be/wtf8 v1.0.0 by @mathias */
    ;(function(root) {

    	// Detect free variables `exports`
    	var freeExports = typeof exports == 'object' && exports;

    	// Detect free variable `module`
    	var freeModule = typeof module == 'object' && module &&
    		module.exports == freeExports && module;

    	// Detect free variable `global`, from Node.js or Browserified code,
    	// and use it as `root`
    	var freeGlobal = typeof global == 'object' && global;
    	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
    		root = freeGlobal;
    	}

    	/*--------------------------------------------------------------------------*/

    	var stringFromCharCode = String.fromCharCode;

    	// Taken from https://mths.be/punycode
    	function ucs2decode(string) {
    		var output = [];
    		var counter = 0;
    		var length = string.length;
    		var value;
    		var extra;
    		while (counter < length) {
    			value = string.charCodeAt(counter++);
    			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
    				// high surrogate, and there is a next character
    				extra = string.charCodeAt(counter++);
    				if ((extra & 0xFC00) == 0xDC00) { // low surrogate
    					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
    				} else {
    					// unmatched surrogate; only append this code unit, in case the next
    					// code unit is the high surrogate of a surrogate pair
    					output.push(value);
    					counter--;
    				}
    			} else {
    				output.push(value);
    			}
    		}
    		return output;
    	}

    	// Taken from https://mths.be/punycode
    	function ucs2encode(array) {
    		var length = array.length;
    		var index = -1;
    		var value;
    		var output = '';
    		while (++index < length) {
    			value = array[index];
    			if (value > 0xFFFF) {
    				value -= 0x10000;
    				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
    				value = 0xDC00 | value & 0x3FF;
    			}
    			output += stringFromCharCode(value);
    		}
    		return output;
    	}

    	/*--------------------------------------------------------------------------*/

    	function createByte(codePoint, shift) {
    		return stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);
    	}

    	function encodeCodePoint(codePoint) {
    		if ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence
    			return stringFromCharCode(codePoint);
    		}
    		var symbol = '';
    		if ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence
    			symbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);
    		}
    		else if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence
    			symbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);
    			symbol += createByte(codePoint, 6);
    		}
    		else if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence
    			symbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);
    			symbol += createByte(codePoint, 12);
    			symbol += createByte(codePoint, 6);
    		}
    		symbol += stringFromCharCode((codePoint & 0x3F) | 0x80);
    		return symbol;
    	}

    	function wtf8encode(string) {
    		var codePoints = ucs2decode(string);
    		var length = codePoints.length;
    		var index = -1;
    		var codePoint;
    		var byteString = '';
    		while (++index < length) {
    			codePoint = codePoints[index];
    			byteString += encodeCodePoint(codePoint);
    		}
    		return byteString;
    	}

    	/*--------------------------------------------------------------------------*/

    	function readContinuationByte() {
    		if (byteIndex >= byteCount) {
    			throw Error('Invalid byte index');
    		}

    		var continuationByte = byteArray[byteIndex] & 0xFF;
    		byteIndex++;

    		if ((continuationByte & 0xC0) == 0x80) {
    			return continuationByte & 0x3F;
    		}

    		// If we end up here, it’s not a continuation byte.
    		throw Error('Invalid continuation byte');
    	}

    	function decodeSymbol() {
    		var byte1;
    		var byte2;
    		var byte3;
    		var byte4;
    		var codePoint;

    		if (byteIndex > byteCount) {
    			throw Error('Invalid byte index');
    		}

    		if (byteIndex == byteCount) {
    			return false;
    		}

    		// Read the first byte.
    		byte1 = byteArray[byteIndex] & 0xFF;
    		byteIndex++;

    		// 1-byte sequence (no continuation bytes)
    		if ((byte1 & 0x80) == 0) {
    			return byte1;
    		}

    		// 2-byte sequence
    		if ((byte1 & 0xE0) == 0xC0) {
    			var byte2 = readContinuationByte();
    			codePoint = ((byte1 & 0x1F) << 6) | byte2;
    			if (codePoint >= 0x80) {
    				return codePoint;
    			} else {
    				throw Error('Invalid continuation byte');
    			}
    		}

    		// 3-byte sequence (may include unpaired surrogates)
    		if ((byte1 & 0xF0) == 0xE0) {
    			byte2 = readContinuationByte();
    			byte3 = readContinuationByte();
    			codePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;
    			if (codePoint >= 0x0800) {
    				return codePoint;
    			} else {
    				throw Error('Invalid continuation byte');
    			}
    		}

    		// 4-byte sequence
    		if ((byte1 & 0xF8) == 0xF0) {
    			byte2 = readContinuationByte();
    			byte3 = readContinuationByte();
    			byte4 = readContinuationByte();
    			codePoint = ((byte1 & 0x0F) << 0x12) | (byte2 << 0x0C) |
    				(byte3 << 0x06) | byte4;
    			if (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {
    				return codePoint;
    			}
    		}

    		throw Error('Invalid WTF-8 detected');
    	}

    	var byteArray;
    	var byteCount;
    	var byteIndex;
    	function wtf8decode(byteString) {
    		byteArray = ucs2decode(byteString);
    		byteCount = byteArray.length;
    		byteIndex = 0;
    		var codePoints = [];
    		var tmp;
    		while ((tmp = decodeSymbol()) !== false) {
    			codePoints.push(tmp);
    		}
    		return ucs2encode(codePoints);
    	}

    	/*--------------------------------------------------------------------------*/

    	var wtf8 = {
    		'version': '1.0.0',
    		'encode': wtf8encode,
    		'decode': wtf8decode
    	};

    	// Some AMD build optimizers, like r.js, check for specific condition patterns
    	// like the following:
    	if (
    		typeof define == 'function' &&
    		typeof define.amd == 'object' &&
    		define.amd
    	) {
    		define(function() {
    			return wtf8;
    		});
    	}	else if (freeExports && !freeExports.nodeType) {
    		if (freeModule) { // in Node.js or RingoJS v0.8.0+
    			freeModule.exports = wtf8;
    		} else { // in Narwhal or RingoJS v0.7.0-
    			var object = {};
    			var hasOwnProperty = object.hasOwnProperty;
    			for (var key in wtf8) {
    				hasOwnProperty.call(wtf8, key) && (freeExports[key] = wtf8[key]);
    			}
    		}
    	} else { // in Rhino or a web browser
    		root.wtf8 = wtf8;
    	}

    }(this));

    }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{}],648:[function(require,module,exports){

    /**
     * Module exports.
     *
     * Logic borrowed from Modernizr:
     *
     *   - https://github.com/Modernizr/Modernizr/blob/master/feature-detects/cors.js
     */

    try {
      module.exports = typeof XMLHttpRequest !== 'undefined' &&
        'withCredentials' in new XMLHttpRequest();
    } catch (err) {
      // if XMLHttp support is disabled in IE then it will throw
      // when trying to create
      module.exports = false;
    }

    },{}],649:[function(require,module,exports){
    (function (global){
    /**
     * JSON parse.
     *
     * @see Based on jQuery#parseJSON (MIT) and JSON2
     * @api private
     */

    var rvalidchars = /^[\],:{}\s]*$/;
    var rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g;
    var rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g;
    var rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g;
    var rtrimLeft = /^\s+/;
    var rtrimRight = /\s+$/;

    module.exports = function parsejson(data) {
      if ('string' != typeof data || !data) {
        return null;
      }

      data = data.replace(rtrimLeft, '').replace(rtrimRight, '');

      // Attempt to parse using the native JSON parser first
      if (global.JSON && JSON.parse) {
        return JSON.parse(data);
      }

      if (rvalidchars.test(data.replace(rvalidescape, '@')
          .replace(rvalidtokens, ']')
          .replace(rvalidbraces, ''))) {
        return (new Function('return ' + data))();
      }
    };

    }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{}],650:[function(require,module,exports){
    /**
     * Compiles a querystring
     * Returns string representation of the object
     *
     * @param {Object}
     * @api private
     */

    exports.encode = function (obj) {
      var str = '';

      for (var i in obj) {
        if (obj.hasOwnProperty(i)) {
          if (str.length) str += '&';
          str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);
        }
      }

      return str;
    };

    /**
     * Parses a simple querystring into an object
     *
     * @param {String} qs
     * @api private
     */

    exports.decode = function(qs){
      var qry = {};
      var pairs = qs.split('&');
      for (var i = 0, l = pairs.length; i < l; i++) {
        var pair = pairs[i].split('=');
        qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
      }
      return qry;
    };
    },{}],651:[function(require,module,exports){
    'use strict';

    var alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_'.split('')
      , length = 64
      , map = {}
      , seed = 0
      , i = 0
      , prev;

    /**
     * Return a string representing the specified number.
     *
     * @param {Number} num The number to convert.
     * @returns {String} The string representation of the number.
     * @api public
     */
    function encode(num) {
      var encoded = '';

      do {
        encoded = alphabet[num % length] + encoded;
        num = Math.floor(num / length);
      } while (num > 0);

      return encoded;
    }

    /**
     * Return the integer value specified by the given string.
     *
     * @param {String} str The string to convert.
     * @returns {Number} The integer value represented by the string.
     * @api public
     */
    function decode(str) {
      var decoded = 0;

      for (i = 0; i < str.length; i++) {
        decoded = decoded * length + map[str.charAt(i)];
      }

      return decoded;
    }

    /**
     * Yeast: A tiny growing id generator.
     *
     * @returns {String} A unique id.
     * @api public
     */
    function yeast() {
      var now = encode(+new Date());

      if (now !== prev) return seed = 0, prev = now;
      return now +'.'+ encode(seed++);
    }

    //
    // Map each character to its index.
    //
    for (; i < length; i++) map[alphabet[i]] = i;

    //
    // Expose the `yeast`, `encode` and `decode` functions.
    //
    yeast.encode = encode;
    yeast.decode = decode;
    module.exports = yeast;

    },{}],652:[function(require,module,exports){
    (function (global){

    /*
     * Module requirements.
     */

    var isArray = require('isarray');

    /**
     * Module exports.
     */

    module.exports = hasBinary;

    /**
     * Checks for binary data.
     *
     * Right now only Buffer and ArrayBuffer are supported..
     *
     * @param {Object} anything
     * @api public
     */

    function hasBinary(data) {

      function _hasBinary(obj) {
        if (!obj) return false;

        if ( (global.Buffer && global.Buffer.isBuffer && global.Buffer.isBuffer(obj)) ||
             (global.ArrayBuffer && obj instanceof ArrayBuffer) ||
             (global.Blob && obj instanceof Blob) ||
             (global.File && obj instanceof File)
            ) {
          return true;
        }

        if (isArray(obj)) {
          for (var i = 0; i < obj.length; i++) {
              if (_hasBinary(obj[i])) {
                  return true;
              }
          }
        } else if (obj && 'object' == typeof obj) {
          // see: https://github.com/Automattic/has-binary/pull/4
          if (obj.toJSON && 'function' == typeof obj.toJSON) {
            obj = obj.toJSON();
          }

          for (var key in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, key) && _hasBinary(obj[key])) {
              return true;
            }
          }
        }

        return false;
      }

      return _hasBinary(data);
    }

    }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{"isarray":653}],653:[function(require,module,exports){
    module.exports = Array.isArray || function (arr) {
      return Object.prototype.toString.call(arr) == '[object Array]';
    };

    },{}],654:[function(require,module,exports){

    var indexOf = [].indexOf;

    module.exports = function(arr, obj){
      if (indexOf) return arr.indexOf(obj);
      for (var i = 0; i < arr.length; ++i) {
        if (arr[i] === obj) return i;
      }
      return -1;
    };

    },{}],655:[function(require,module,exports){
    /**
     * Parses an URI
     *
     * @author Steven Levithan <stevenlevithan.com> (MIT license)
     * @api private
     */

    var re = /^(?:(?![^:@]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;

    var parts = [
        'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'
    ];

    module.exports = function parseuri(str) {
        var src = str,
            b = str.indexOf('['),
            e = str.indexOf(']');

        if (b != -1 && e != -1) {
            str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ';') + str.substring(e, str.length);
        }

        var m = re.exec(str || ''),
            uri = {},
            i = 14;

        while (i--) {
            uri[parts[i]] = m[i] || '';
        }

        if (b != -1 && e != -1) {
            uri.source = src;
            uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ':');
            uri.authority = uri.authority.replace('[', '').replace(']', '').replace(/;/g, ':');
            uri.ipv6uri = true;
        }

        return uri;
    };
    },{}],656:[function(require,module,exports){
    (function (global){
    /*global Blob,File*/

    /**
     * Module requirements
     */

    var isArray = require('isarray');
    var isBuf = require('./is-buffer');

    /**
     * Replaces every Buffer | ArrayBuffer in packet with a numbered placeholder.
     * Anything with blobs or files should be fed through removeBlobs before coming
     * here.
     *
     * @param {Object} packet - socket.io event packet
     * @return {Object} with deconstructed packet and list of buffers
     * @api public
     */

    exports.deconstructPacket = function(packet){
      var buffers = [];
      var packetData = packet.data;

      function _deconstructPacket(data) {
        if (!data) return data;

        if (isBuf(data)) {
          var placeholder = { _placeholder: true, num: buffers.length };
          buffers.push(data);
          return placeholder;
        } else if (isArray(data)) {
          var newData = new Array(data.length);
          for (var i = 0; i < data.length; i++) {
            newData[i] = _deconstructPacket(data[i]);
          }
          return newData;
        } else if ('object' == typeof data && !(data instanceof Date)) {
          var newData = {};
          for (var key in data) {
            newData[key] = _deconstructPacket(data[key]);
          }
          return newData;
        }
        return data;
      }

      var pack = packet;
      pack.data = _deconstructPacket(packetData);
      pack.attachments = buffers.length; // number of binary 'attachments'
      return {packet: pack, buffers: buffers};
    };

    /**
     * Reconstructs a binary packet from its placeholder packet and buffers
     *
     * @param {Object} packet - event packet with placeholders
     * @param {Array} buffers - binary buffers to put in placeholder positions
     * @return {Object} reconstructed packet
     * @api public
     */

    exports.reconstructPacket = function(packet, buffers) {
      var curPlaceHolder = 0;

      function _reconstructPacket(data) {
        if (data && data._placeholder) {
          var buf = buffers[data.num]; // appropriate buffer (should be natural order anyway)
          return buf;
        } else if (isArray(data)) {
          for (var i = 0; i < data.length; i++) {
            data[i] = _reconstructPacket(data[i]);
          }
          return data;
        } else if (data && 'object' == typeof data) {
          for (var key in data) {
            data[key] = _reconstructPacket(data[key]);
          }
          return data;
        }
        return data;
      }

      packet.data = _reconstructPacket(packet.data);
      packet.attachments = undefined; // no longer useful
      return packet;
    };

    /**
     * Asynchronously removes Blobs or Files from data via
     * FileReader's readAsArrayBuffer method. Used before encoding
     * data as msgpack. Calls callback with the blobless data.
     *
     * @param {Object} data
     * @param {Function} callback
     * @api private
     */

    exports.removeBlobs = function(data, callback) {
      function _removeBlobs(obj, curKey, containingObject) {
        if (!obj) return obj;

        // convert any blob
        if ((global.Blob && obj instanceof Blob) ||
            (global.File && obj instanceof File)) {
          pendingBlobs++;

          // async filereader
          var fileReader = new FileReader();
          fileReader.onload = function() { // this.result == arraybuffer
            if (containingObject) {
              containingObject[curKey] = this.result;
            }
            else {
              bloblessData = this.result;
            }

            // if nothing pending its callback time
            if(! --pendingBlobs) {
              callback(bloblessData);
            }
          };

          fileReader.readAsArrayBuffer(obj); // blob -> arraybuffer
        } else if (isArray(obj)) { // handle array
          for (var i = 0; i < obj.length; i++) {
            _removeBlobs(obj[i], i, obj);
          }
        } else if (obj && 'object' == typeof obj && !isBuf(obj)) { // and object
          for (var key in obj) {
            _removeBlobs(obj[key], key, obj);
          }
        }
      }

      var pendingBlobs = 0;
      var bloblessData = data;
      _removeBlobs(bloblessData);
      if (!pendingBlobs) {
        callback(bloblessData);
      }
    };

    }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{"./is-buffer":658,"isarray":663}],657:[function(require,module,exports){

    /**
     * Module dependencies.
     */

    var debug = require('debug')('socket.io-parser');
    var json = require('json3');
    var Emitter = require('component-emitter');
    var binary = require('./binary');
    var isBuf = require('./is-buffer');

    /**
     * Protocol version.
     *
     * @api public
     */

    exports.protocol = 4;

    /**
     * Packet types.
     *
     * @api public
     */

    exports.types = [
      'CONNECT',
      'DISCONNECT',
      'EVENT',
      'ACK',
      'ERROR',
      'BINARY_EVENT',
      'BINARY_ACK'
    ];

    /**
     * Packet type `connect`.
     *
     * @api public
     */

    exports.CONNECT = 0;

    /**
     * Packet type `disconnect`.
     *
     * @api public
     */

    exports.DISCONNECT = 1;

    /**
     * Packet type `event`.
     *
     * @api public
     */

    exports.EVENT = 2;

    /**
     * Packet type `ack`.
     *
     * @api public
     */

    exports.ACK = 3;

    /**
     * Packet type `error`.
     *
     * @api public
     */

    exports.ERROR = 4;

    /**
     * Packet type 'binary event'
     *
     * @api public
     */

    exports.BINARY_EVENT = 5;

    /**
     * Packet type `binary ack`. For acks with binary arguments.
     *
     * @api public
     */

    exports.BINARY_ACK = 6;

    /**
     * Encoder constructor.
     *
     * @api public
     */

    exports.Encoder = Encoder;

    /**
     * Decoder constructor.
     *
     * @api public
     */

    exports.Decoder = Decoder;

    /**
     * A socket.io Encoder instance
     *
     * @api public
     */

    function Encoder() {}

    /**
     * Encode a packet as a single string if non-binary, or as a
     * buffer sequence, depending on packet type.
     *
     * @param {Object} obj - packet object
     * @param {Function} callback - function to handle encodings (likely engine.write)
     * @return Calls callback with Array of encodings
     * @api public
     */

    Encoder.prototype.encode = function(obj, callback){
      debug('encoding packet %j', obj);

      if (exports.BINARY_EVENT == obj.type || exports.BINARY_ACK == obj.type) {
        encodeAsBinary(obj, callback);
      }
      else {
        var encoding = encodeAsString(obj);
        callback([encoding]);
      }
    };

    /**
     * Encode packet as string.
     *
     * @param {Object} packet
     * @return {String} encoded
     * @api private
     */

    function encodeAsString(obj) {
      var str = '';
      var nsp = false;

      // first is type
      str += obj.type;

      // attachments if we have them
      if (exports.BINARY_EVENT == obj.type || exports.BINARY_ACK == obj.type) {
        str += obj.attachments;
        str += '-';
      }

      // if we have a namespace other than `/`
      // we append it followed by a comma `,`
      if (obj.nsp && '/' != obj.nsp) {
        nsp = true;
        str += obj.nsp;
      }

      // immediately followed by the id
      if (null != obj.id) {
        if (nsp) {
          str += ',';
          nsp = false;
        }
        str += obj.id;
      }

      // json data
      if (null != obj.data) {
        if (nsp) str += ',';
        str += json.stringify(obj.data);
      }

      debug('encoded %j as %s', obj, str);
      return str;
    }

    /**
     * Encode packet as 'buffer sequence' by removing blobs, and
     * deconstructing packet into object with placeholders and
     * a list of buffers.
     *
     * @param {Object} packet
     * @return {Buffer} encoded
     * @api private
     */

    function encodeAsBinary(obj, callback) {

      function writeEncoding(bloblessData) {
        var deconstruction = binary.deconstructPacket(bloblessData);
        var pack = encodeAsString(deconstruction.packet);
        var buffers = deconstruction.buffers;

        buffers.unshift(pack); // add packet info to beginning of data list
        callback(buffers); // write all the buffers
      }

      binary.removeBlobs(obj, writeEncoding);
    }

    /**
     * A socket.io Decoder instance
     *
     * @return {Object} decoder
     * @api public
     */

    function Decoder() {
      this.reconstructor = null;
    }

    /**
     * Mix in `Emitter` with Decoder.
     */

    Emitter(Decoder.prototype);

    /**
     * Decodes an ecoded packet string into packet JSON.
     *
     * @param {String} obj - encoded packet
     * @return {Object} packet
     * @api public
     */

    Decoder.prototype.add = function(obj) {
      var packet;
      if ('string' == typeof obj) {
        packet = decodeString(obj);
        if (exports.BINARY_EVENT == packet.type || exports.BINARY_ACK == packet.type) { // binary packet's json
          this.reconstructor = new BinaryReconstructor(packet);

          // no attachments, labeled binary but no binary data to follow
          if (this.reconstructor.reconPack.attachments === 0) {
            this.emit('decoded', packet);
          }
        } else { // non-binary full packet
          this.emit('decoded', packet);
        }
      }
      else if (isBuf(obj) || obj.base64) { // raw binary data
        if (!this.reconstructor) {
          throw new Error('got binary data when not reconstructing a packet');
        } else {
          packet = this.reconstructor.takeBinaryData(obj);
          if (packet) { // received final buffer
            this.reconstructor = null;
            this.emit('decoded', packet);
          }
        }
      }
      else {
        throw new Error('Unknown type: ' + obj);
      }
    };

    /**
     * Decode a packet String (JSON data)
     *
     * @param {String} str
     * @return {Object} packet
     * @api private
     */

    function decodeString(str) {
      var p = {};
      var i = 0;

      // look up type
      p.type = Number(str.charAt(0));
      if (null == exports.types[p.type]) return error();

      // look up attachments if type binary
      if (exports.BINARY_EVENT == p.type || exports.BINARY_ACK == p.type) {
        var buf = '';
        while (str.charAt(++i) != '-') {
          buf += str.charAt(i);
          if (i == str.length) break;
        }
        if (buf != Number(buf) || str.charAt(i) != '-') {
          throw new Error('Illegal attachments');
        }
        p.attachments = Number(buf);
      }

      // look up namespace (if any)
      if ('/' == str.charAt(i + 1)) {
        p.nsp = '';
        while (++i) {
          var c = str.charAt(i);
          if (',' == c) break;
          p.nsp += c;
          if (i == str.length) break;
        }
      } else {
        p.nsp = '/';
      }

      // look up id
      var next = str.charAt(i + 1);
      if ('' !== next && Number(next) == next) {
        p.id = '';
        while (++i) {
          var c = str.charAt(i);
          if (null == c || Number(c) != c) {
            --i;
            break;
          }
          p.id += str.charAt(i);
          if (i == str.length) break;
        }
        p.id = Number(p.id);
      }

      // look up json data
      if (str.charAt(++i)) {
        p = tryParse(p, str.substr(i));
      }

      debug('decoded %s as %j', str, p);
      return p;
    }

    function tryParse(p, str) {
      try {
        p.data = json.parse(str);
      } catch(e){
        return error();
      }
      return p;
    };

    /**
     * Deallocates a parser's resources
     *
     * @api public
     */

    Decoder.prototype.destroy = function() {
      if (this.reconstructor) {
        this.reconstructor.finishedReconstruction();
      }
    };

    /**
     * A manager of a binary event's 'buffer sequence'. Should
     * be constructed whenever a packet of type BINARY_EVENT is
     * decoded.
     *
     * @param {Object} packet
     * @return {BinaryReconstructor} initialized reconstructor
     * @api private
     */

    function BinaryReconstructor(packet) {
      this.reconPack = packet;
      this.buffers = [];
    }

    /**
     * Method to be called when binary data received from connection
     * after a BINARY_EVENT packet.
     *
     * @param {Buffer | ArrayBuffer} binData - the raw binary data received
     * @return {null | Object} returns null if more binary data is expected or
     *   a reconstructed packet object if all buffers have been received.
     * @api private
     */

    BinaryReconstructor.prototype.takeBinaryData = function(binData) {
      this.buffers.push(binData);
      if (this.buffers.length == this.reconPack.attachments) { // done with buffer list
        var packet = binary.reconstructPacket(this.reconPack, this.buffers);
        this.finishedReconstruction();
        return packet;
      }
      return null;
    };

    /**
     * Cleans up binary packet reconstruction variables.
     *
     * @api private
     */

    BinaryReconstructor.prototype.finishedReconstruction = function() {
      this.reconPack = null;
      this.buffers = [];
    };

    function error(data){
      return {
        type: exports.ERROR,
        data: 'parser error'
      };
    }

    },{"./binary":656,"./is-buffer":658,"component-emitter":659,"debug":660,"json3":664}],658:[function(require,module,exports){
    (function (global){

    module.exports = isBuf;

    /**
     * Returns true if obj is a buffer or an arraybuffer.
     *
     * @api private
     */

    function isBuf(obj) {
      return (global.Buffer && global.Buffer.isBuffer(obj)) ||
             (global.ArrayBuffer && obj instanceof ArrayBuffer);
    }

    }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{}],659:[function(require,module,exports){

    /**
     * Expose `Emitter`.
     */

    module.exports = Emitter;

    /**
     * Initialize a new `Emitter`.
     *
     * @api public
     */

    function Emitter(obj) {
      if (obj) return mixin(obj);
    };

    /**
     * Mixin the emitter properties.
     *
     * @param {Object} obj
     * @return {Object}
     * @api private
     */

    function mixin(obj) {
      for (var key in Emitter.prototype) {
        obj[key] = Emitter.prototype[key];
      }
      return obj;
    }

    /**
     * Listen on the given `event` with `fn`.
     *
     * @param {String} event
     * @param {Function} fn
     * @return {Emitter}
     * @api public
     */

    Emitter.prototype.on =
    Emitter.prototype.addEventListener = function(event, fn){
      this._callbacks = this._callbacks || {};
      (this._callbacks[event] = this._callbacks[event] || [])
        .push(fn);
      return this;
    };

    /**
     * Adds an `event` listener that will be invoked a single
     * time then automatically removed.
     *
     * @param {String} event
     * @param {Function} fn
     * @return {Emitter}
     * @api public
     */

    Emitter.prototype.once = function(event, fn){
      var self = this;
      this._callbacks = this._callbacks || {};

      function on() {
        self.off(event, on);
        fn.apply(this, arguments);
      }

      on.fn = fn;
      this.on(event, on);
      return this;
    };

    /**
     * Remove the given callback for `event` or all
     * registered callbacks.
     *
     * @param {String} event
     * @param {Function} fn
     * @return {Emitter}
     * @api public
     */

    Emitter.prototype.off =
    Emitter.prototype.removeListener =
    Emitter.prototype.removeAllListeners =
    Emitter.prototype.removeEventListener = function(event, fn){
      this._callbacks = this._callbacks || {};

      // all
      if (0 == arguments.length) {
        this._callbacks = {};
        return this;
      }

      // specific event
      var callbacks = this._callbacks[event];
      if (!callbacks) return this;

      // remove all handlers
      if (1 == arguments.length) {
        delete this._callbacks[event];
        return this;
      }

      // remove specific handler
      var cb;
      for (var i = 0; i < callbacks.length; i++) {
        cb = callbacks[i];
        if (cb === fn || cb.fn === fn) {
          callbacks.splice(i, 1);
          break;
        }
      }
      return this;
    };

    /**
     * Emit `event` with the given args.
     *
     * @param {String} event
     * @param {Mixed} ...
     * @return {Emitter}
     */

    Emitter.prototype.emit = function(event){
      this._callbacks = this._callbacks || {};
      var args = [].slice.call(arguments, 1)
        , callbacks = this._callbacks[event];

      if (callbacks) {
        callbacks = callbacks.slice(0);
        for (var i = 0, len = callbacks.length; i < len; ++i) {
          callbacks[i].apply(this, args);
        }
      }

      return this;
    };

    /**
     * Return array of callbacks for `event`.
     *
     * @param {String} event
     * @return {Array}
     * @api public
     */

    Emitter.prototype.listeners = function(event){
      this._callbacks = this._callbacks || {};
      return this._callbacks[event] || [];
    };

    /**
     * Check if this emitter has `event` handlers.
     *
     * @param {String} event
     * @return {Boolean}
     * @api public
     */

    Emitter.prototype.hasListeners = function(event){
      return !! this.listeners(event).length;
    };

    },{}],660:[function(require,module,exports){

    /**
     * This is the web browser implementation of `debug()`.
     *
     * Expose `debug()` as the module.
     */

    exports = module.exports = require('./debug');
    exports.log = log;
    exports.formatArgs = formatArgs;
    exports.save = save;
    exports.load = load;
    exports.useColors = useColors;
    exports.storage = 'undefined' != typeof chrome
                   && 'undefined' != typeof chrome.storage
                      ? chrome.storage.local
                      : localstorage();

    /**
     * Colors.
     */

    exports.colors = [
      'lightseagreen',
      'forestgreen',
      'goldenrod',
      'dodgerblue',
      'darkorchid',
      'crimson'
    ];

    /**
     * Currently only WebKit-based Web Inspectors, Firefox >= v31,
     * and the Firebug extension (any Firefox version) are known
     * to support "%c" CSS customizations.
     *
     * TODO: add a `localStorage` variable to explicitly enable/disable colors
     */

    function useColors() {
      // is webkit? http://stackoverflow.com/a/16459606/376773
      return ('WebkitAppearance' in document.documentElement.style) ||
        // is firebug? http://stackoverflow.com/a/398120/376773
        (window.console && (console.firebug || (console.exception && console.table))) ||
        // is firefox >= v31?
        // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
        (navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31);
    }

    /**
     * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
     */

    exports.formatters.j = function(v) {
      return JSON.stringify(v);
    };

    /**
     * Colorize log arguments if enabled.
     *
     * @api public
     */

    function formatArgs() {
      var args = arguments;
      var useColors = this.useColors;

      args[0] = (useColors ? '%c' : '')
        + this.namespace
        + (useColors ? ' %c' : ' ')
        + args[0]
        + (useColors ? '%c ' : ' ')
        + '+' + exports.humanize(this.diff);

      if (!useColors) return args;

      var c = 'color: ' + this.color;
      args = [args[0], c, 'color: inherit'].concat(Array.prototype.slice.call(args, 1));

      // the final "%c" is somewhat tricky, because there could be other
      // arguments passed either before or after the %c, so we need to
      // figure out the correct index to insert the CSS into
      var index = 0;
      var lastC = 0;
      args[0].replace(/%[a-z%]/g, function(match) {
        if ('%%' === match) return;
        index++;
        if ('%c' === match) {
          // we only are interested in the *last* %c
          // (the user may have provided their own)
          lastC = index;
        }
      });

      args.splice(lastC, 0, c);
      return args;
    }

    /**
     * Invokes `console.log()` when available.
     * No-op when `console.log` is not a "function".
     *
     * @api public
     */

    function log() {
      // this hackery is required for IE8/9, where
      // the `console.log` function doesn't have 'apply'
      return 'object' === typeof console
        && console.log
        && Function.prototype.apply.call(console.log, console, arguments);
    }

    /**
     * Save `namespaces`.
     *
     * @param {String} namespaces
     * @api private
     */

    function save(namespaces) {
      try {
        if (null == namespaces) {
          exports.storage.removeItem('debug');
        } else {
          exports.storage.debug = namespaces;
        }
      } catch(e) {}
    }

    /**
     * Load `namespaces`.
     *
     * @return {String} returns the previously persisted debug modes
     * @api private
     */

    function load() {
      var r;
      try {
        r = exports.storage.debug;
      } catch(e) {}
      return r;
    }

    /**
     * Enable namespaces listed in `localStorage.debug` initially.
     */

    exports.enable(load());

    /**
     * Localstorage attempts to return the localstorage.
     *
     * This is necessary because safari throws
     * when a user disables cookies/localstorage
     * and you attempt to access it.
     *
     * @return {LocalStorage}
     * @api private
     */

    function localstorage(){
      try {
        return window.localStorage;
      } catch (e) {}
    }

    },{"./debug":661}],661:[function(require,module,exports){

    /**
     * This is the common logic for both the Node.js and web browser
     * implementations of `debug()`.
     *
     * Expose `debug()` as the module.
     */

    exports = module.exports = debug;
    exports.coerce = coerce;
    exports.disable = disable;
    exports.enable = enable;
    exports.enabled = enabled;
    exports.humanize = require('ms');

    /**
     * The currently active debug mode names, and names to skip.
     */

    exports.names = [];
    exports.skips = [];

    /**
     * Map of special "%n" handling functions, for the debug "format" argument.
     *
     * Valid key names are a single, lowercased letter, i.e. "n".
     */

    exports.formatters = {};

    /**
     * Previously assigned color.
     */

    var prevColor = 0;

    /**
     * Previous log timestamp.
     */

    var prevTime;

    /**
     * Select a color.
     *
     * @return {Number}
     * @api private
     */

    function selectColor() {
      return exports.colors[prevColor++ % exports.colors.length];
    }

    /**
     * Create a debugger with the given `namespace`.
     *
     * @param {String} namespace
     * @return {Function}
     * @api public
     */

    function debug(namespace) {

      // define the `disabled` version
      function disabled() {
      }
      disabled.enabled = false;

      // define the `enabled` version
      function enabled() {

        var self = enabled;

        // set `diff` timestamp
        var curr = +new Date();
        var ms = curr - (prevTime || curr);
        self.diff = ms;
        self.prev = prevTime;
        self.curr = curr;
        prevTime = curr;

        // add the `color` if not set
        if (null == self.useColors) self.useColors = exports.useColors();
        if (null == self.color && self.useColors) self.color = selectColor();

        var args = Array.prototype.slice.call(arguments);

        args[0] = exports.coerce(args[0]);

        if ('string' !== typeof args[0]) {
          // anything else let's inspect with %o
          args = ['%o'].concat(args);
        }

        // apply any `formatters` transformations
        var index = 0;
        args[0] = args[0].replace(/%([a-z%])/g, function(match, format) {
          // if we encounter an escaped % then don't increase the array index
          if (match === '%%') return match;
          index++;
          var formatter = exports.formatters[format];
          if ('function' === typeof formatter) {
            var val = args[index];
            match = formatter.call(self, val);

            // now we need to remove `args[index]` since it's inlined in the `format`
            args.splice(index, 1);
            index--;
          }
          return match;
        });

        if ('function' === typeof exports.formatArgs) {
          args = exports.formatArgs.apply(self, args);
        }
        var logFn = enabled.log || exports.log || console.log.bind(console);
        logFn.apply(self, args);
      }
      enabled.enabled = true;

      var fn = exports.enabled(namespace) ? enabled : disabled;

      fn.namespace = namespace;

      return fn;
    }

    /**
     * Enables a debug mode by namespaces. This can include modes
     * separated by a colon and wildcards.
     *
     * @param {String} namespaces
     * @api public
     */

    function enable(namespaces) {
      exports.save(namespaces);

      var split = (namespaces || '').split(/[\s,]+/);
      var len = split.length;

      for (var i = 0; i < len; i++) {
        if (!split[i]) continue; // ignore empty strings
        namespaces = split[i].replace(/\*/g, '.*?');
        if (namespaces[0] === '-') {
          exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
        } else {
          exports.names.push(new RegExp('^' + namespaces + '$'));
        }
      }
    }

    /**
     * Disable debug output.
     *
     * @api public
     */

    function disable() {
      exports.enable('');
    }

    /**
     * Returns true if the given mode name is enabled, false otherwise.
     *
     * @param {String} name
     * @return {Boolean}
     * @api public
     */

    function enabled(name) {
      var i, len;
      for (i = 0, len = exports.skips.length; i < len; i++) {
        if (exports.skips[i].test(name)) {
          return false;
        }
      }
      for (i = 0, len = exports.names.length; i < len; i++) {
        if (exports.names[i].test(name)) {
          return true;
        }
      }
      return false;
    }

    /**
     * Coerce `val`.
     *
     * @param {Mixed} val
     * @return {Mixed}
     * @api private
     */

    function coerce(val) {
      if (val instanceof Error) return val.stack || val.message;
      return val;
    }

    },{"ms":662}],662:[function(require,module,exports){
    /**
     * Helpers.
     */

    var s = 1000;
    var m = s * 60;
    var h = m * 60;
    var d = h * 24;
    var y = d * 365.25;

    /**
     * Parse or format the given `val`.
     *
     * Options:
     *
     *  - `long` verbose formatting [false]
     *
     * @param {String|Number} val
     * @param {Object} options
     * @return {String|Number}
     * @api public
     */

    module.exports = function(val, options){
      options = options || {};
      if ('string' == typeof val) return parse(val);
      return options.long
        ? long(val)
        : short(val);
    };

    /**
     * Parse the given `str` and return milliseconds.
     *
     * @param {String} str
     * @return {Number}
     * @api private
     */

    function parse(str) {
      str = '' + str;
      if (str.length > 10000) return;
      var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str);
      if (!match) return;
      var n = parseFloat(match[1]);
      var type = (match[2] || 'ms').toLowerCase();
      switch (type) {
        case 'years':
        case 'year':
        case 'yrs':
        case 'yr':
        case 'y':
          return n * y;
        case 'days':
        case 'day':
        case 'd':
          return n * d;
        case 'hours':
        case 'hour':
        case 'hrs':
        case 'hr':
        case 'h':
          return n * h;
        case 'minutes':
        case 'minute':
        case 'mins':
        case 'min':
        case 'm':
          return n * m;
        case 'seconds':
        case 'second':
        case 'secs':
        case 'sec':
        case 's':
          return n * s;
        case 'milliseconds':
        case 'millisecond':
        case 'msecs':
        case 'msec':
        case 'ms':
          return n;
      }
    }

    /**
     * Short format for `ms`.
     *
     * @param {Number} ms
     * @return {String}
     * @api private
     */

    function short(ms) {
      if (ms >= d) return Math.round(ms / d) + 'd';
      if (ms >= h) return Math.round(ms / h) + 'h';
      if (ms >= m) return Math.round(ms / m) + 'm';
      if (ms >= s) return Math.round(ms / s) + 's';
      return ms + 'ms';
    }

    /**
     * Long format for `ms`.
     *
     * @param {Number} ms
     * @return {String}
     * @api private
     */

    function long(ms) {
      return plural(ms, d, 'day')
        || plural(ms, h, 'hour')
        || plural(ms, m, 'minute')
        || plural(ms, s, 'second')
        || ms + ' ms';
    }

    /**
     * Pluralization helper.
     */

    function plural(ms, n, name) {
      if (ms < n) return;
      if (ms < n * 1.5) return Math.floor(ms / n) + ' ' + name;
      return Math.ceil(ms / n) + ' ' + name + 's';
    }

    },{}],663:[function(require,module,exports){
    module.exports = Array.isArray || function (arr) {
      return Object.prototype.toString.call(arr) == '[object Array]';
    };

    },{}],664:[function(require,module,exports){
    (function (global){
    /*! JSON v3.3.2 | http://bestiejs.github.io/json3 | Copyright 2012-2014, Kit Cambridge | http://kit.mit-license.org */
    ;(function () {
      // Detect the `define` function exposed by asynchronous module loaders. The
      // strict `define` check is necessary for compatibility with `r.js`.
      var isLoader = typeof define === "function" && define.amd;

      // A set of types used to distinguish objects from primitives.
      var objectTypes = {
        "function": true,
        "object": true
      };

      // Detect the `exports` object exposed by CommonJS implementations.
      var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;

      // Use the `global` object exposed by Node (including Browserify via
      // `insert-module-globals`), Narwhal, and Ringo as the default context,
      // and the `window` object in browsers. Rhino exports a `global` function
      // instead.
      var root = objectTypes[typeof window] && window || this,
          freeGlobal = freeExports && objectTypes[typeof module] && module && !module.nodeType && typeof global == "object" && global;

      if (freeGlobal && (freeGlobal["global"] === freeGlobal || freeGlobal["window"] === freeGlobal || freeGlobal["self"] === freeGlobal)) {
        root = freeGlobal;
      }

      // Public: Initializes JSON 3 using the given `context` object, attaching the
      // `stringify` and `parse` functions to the specified `exports` object.
      function runInContext(context, exports) {
        context || (context = root["Object"]());
        exports || (exports = root["Object"]());

        // Native constructor aliases.
        var Number = context["Number"] || root["Number"],
            String = context["String"] || root["String"],
            Object = context["Object"] || root["Object"],
            Date = context["Date"] || root["Date"],
            SyntaxError = context["SyntaxError"] || root["SyntaxError"],
            TypeError = context["TypeError"] || root["TypeError"],
            Math = context["Math"] || root["Math"],
            nativeJSON = context["JSON"] || root["JSON"];

        // Delegate to the native `stringify` and `parse` implementations.
        if (typeof nativeJSON == "object" && nativeJSON) {
          exports.stringify = nativeJSON.stringify;
          exports.parse = nativeJSON.parse;
        }

        // Convenience aliases.
        var objectProto = Object.prototype,
            getClass = objectProto.toString,
            isProperty, forEach, undef;

        // Test the `Date#getUTC*` methods. Based on work by @Yaffle.
        var isExtended = new Date(-3509827334573292);
        try {
          // The `getUTCFullYear`, `Month`, and `Date` methods return nonsensical
          // results for certain dates in Opera >= 10.53.
          isExtended = isExtended.getUTCFullYear() == -109252 && isExtended.getUTCMonth() === 0 && isExtended.getUTCDate() === 1 &&
            // Safari < 2.0.2 stores the internal millisecond time value correctly,
            // but clips the values returned by the date methods to the range of
            // signed 32-bit integers ([-2 ** 31, 2 ** 31 - 1]).
            isExtended.getUTCHours() == 10 && isExtended.getUTCMinutes() == 37 && isExtended.getUTCSeconds() == 6 && isExtended.getUTCMilliseconds() == 708;
        } catch (exception) {}

        // Internal: Determines whether the native `JSON.stringify` and `parse`
        // implementations are spec-compliant. Based on work by Ken Snyder.
        function has(name) {
          if (has[name] !== undef) {
            // Return cached feature test result.
            return has[name];
          }
          var isSupported;
          if (name == "bug-string-char-index") {
            // IE <= 7 doesn't support accessing string characters using square
            // bracket notation. IE 8 only supports this for primitives.
            isSupported = "a"[0] != "a";
          } else if (name == "json") {
            // Indicates whether both `JSON.stringify` and `JSON.parse` are
            // supported.
            isSupported = has("json-stringify") && has("json-parse");
          } else {
            var value, serialized = '{"a":[1,true,false,null,"\\u0000\\b\\n\\f\\r\\t"]}';
            // Test `JSON.stringify`.
            if (name == "json-stringify") {
              var stringify = exports.stringify, stringifySupported = typeof stringify == "function" && isExtended;
              if (stringifySupported) {
                // A test function object with a custom `toJSON` method.
                (value = function () {
                  return 1;
                }).toJSON = value;
                try {
                  stringifySupported =
                    // Firefox 3.1b1 and b2 serialize string, number, and boolean
                    // primitives as object literals.
                    stringify(0) === "0" &&
                    // FF 3.1b1, b2, and JSON 2 serialize wrapped primitives as object
                    // literals.
                    stringify(new Number()) === "0" &&
                    stringify(new String()) == '""' &&
                    // FF 3.1b1, 2 throw an error if the value is `null`, `undefined`, or
                    // does not define a canonical JSON representation (this applies to
                    // objects with `toJSON` properties as well, *unless* they are nested
                    // within an object or array).
                    stringify(getClass) === undef &&
                    // IE 8 serializes `undefined` as `"undefined"`. Safari <= 5.1.7 and
                    // FF 3.1b3 pass this test.
                    stringify(undef) === undef &&
                    // Safari <= 5.1.7 and FF 3.1b3 throw `Error`s and `TypeError`s,
                    // respectively, if the value is omitted entirely.
                    stringify() === undef &&
                    // FF 3.1b1, 2 throw an error if the given value is not a number,
                    // string, array, object, Boolean, or `null` literal. This applies to
                    // objects with custom `toJSON` methods as well, unless they are nested
                    // inside object or array literals. YUI 3.0.0b1 ignores custom `toJSON`
                    // methods entirely.
                    stringify(value) === "1" &&
                    stringify([value]) == "[1]" &&
                    // Prototype <= 1.6.1 serializes `[undefined]` as `"[]"` instead of
                    // `"[null]"`.
                    stringify([undef]) == "[null]" &&
                    // YUI 3.0.0b1 fails to serialize `null` literals.
                    stringify(null) == "null" &&
                    // FF 3.1b1, 2 halts serialization if an array contains a function:
                    // `[1, true, getClass, 1]` serializes as "[1,true,],". FF 3.1b3
                    // elides non-JSON values from objects and arrays, unless they
                    // define custom `toJSON` methods.
                    stringify([undef, getClass, null]) == "[null,null,null]" &&
                    // Simple serialization test. FF 3.1b1 uses Unicode escape sequences
                    // where character escape codes are expected (e.g., `\b` => `\u0008`).
                    stringify({ "a": [value, true, false, null, "\x00\b\n\f\r\t"] }) == serialized &&
                    // FF 3.1b1 and b2 ignore the `filter` and `width` arguments.
                    stringify(null, value) === "1" &&
                    stringify([1, 2], null, 1) == "[\n 1,\n 2\n]" &&
                    // JSON 2, Prototype <= 1.7, and older WebKit builds incorrectly
                    // serialize extended years.
                    stringify(new Date(-8.64e15)) == '"-271821-04-20T00:00:00.000Z"' &&
                    // The milliseconds are optional in ES 5, but required in 5.1.
                    stringify(new Date(8.64e15)) == '"+275760-09-13T00:00:00.000Z"' &&
                    // Firefox <= 11.0 incorrectly serializes years prior to 0 as negative
                    // four-digit years instead of six-digit years. Credits: @Yaffle.
                    stringify(new Date(-621987552e5)) == '"-000001-01-01T00:00:00.000Z"' &&
                    // Safari <= 5.1.5 and Opera >= 10.53 incorrectly serialize millisecond
                    // values less than 1000. Credits: @Yaffle.
                    stringify(new Date(-1)) == '"1969-12-31T23:59:59.999Z"';
                } catch (exception) {
                  stringifySupported = false;
                }
              }
              isSupported = stringifySupported;
            }
            // Test `JSON.parse`.
            if (name == "json-parse") {
              var parse = exports.parse;
              if (typeof parse == "function") {
                try {
                  // FF 3.1b1, b2 will throw an exception if a bare literal is provided.
                  // Conforming implementations should also coerce the initial argument to
                  // a string prior to parsing.
                  if (parse("0") === 0 && !parse(false)) {
                    // Simple parsing test.
                    value = parse(serialized);
                    var parseSupported = value["a"].length == 5 && value["a"][0] === 1;
                    if (parseSupported) {
                      try {
                        // Safari <= 5.1.2 and FF 3.1b1 allow unescaped tabs in strings.
                        parseSupported = !parse('"\t"');
                      } catch (exception) {}
                      if (parseSupported) {
                        try {
                          // FF 4.0 and 4.0.1 allow leading `+` signs and leading
                          // decimal points. FF 4.0, 4.0.1, and IE 9-10 also allow
                          // certain octal literals.
                          parseSupported = parse("01") !== 1;
                        } catch (exception) {}
                      }
                      if (parseSupported) {
                        try {
                          // FF 4.0, 4.0.1, and Rhino 1.7R3-R4 allow trailing decimal
                          // points. These environments, along with FF 3.1b1 and 2,
                          // also allow trailing commas in JSON objects and arrays.
                          parseSupported = parse("1.") !== 1;
                        } catch (exception) {}
                      }
                    }
                  }
                } catch (exception) {
                  parseSupported = false;
                }
              }
              isSupported = parseSupported;
            }
          }
          return has[name] = !!isSupported;
        }

        if (!has("json")) {
          // Common `[[Class]]` name aliases.
          var functionClass = "[object Function]",
              dateClass = "[object Date]",
              numberClass = "[object Number]",
              stringClass = "[object String]",
              arrayClass = "[object Array]",
              booleanClass = "[object Boolean]";

          // Detect incomplete support for accessing string characters by index.
          var charIndexBuggy = has("bug-string-char-index");

          // Define additional utility methods if the `Date` methods are buggy.
          if (!isExtended) {
            var floor = Math.floor;
            // A mapping between the months of the year and the number of days between
            // January 1st and the first of the respective month.
            var Months = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
            // Internal: Calculates the number of days between the Unix epoch and the
            // first day of the given month.
            var getDay = function (year, month) {
              return Months[month] + 365 * (year - 1970) + floor((year - 1969 + (month = +(month > 1))) / 4) - floor((year - 1901 + month) / 100) + floor((year - 1601 + month) / 400);
            };
          }

          // Internal: Determines if a property is a direct property of the given
          // object. Delegates to the native `Object#hasOwnProperty` method.
          if (!(isProperty = objectProto.hasOwnProperty)) {
            isProperty = function (property) {
              var members = {}, constructor;
              if ((members.__proto__ = null, members.__proto__ = {
                // The *proto* property cannot be set multiple times in recent
                // versions of Firefox and SeaMonkey.
                "toString": 1
              }, members).toString != getClass) {
                // Safari <= 2.0.3 doesn't implement `Object#hasOwnProperty`, but
                // supports the mutable *proto* property.
                isProperty = function (property) {
                  // Capture and break the object's prototype chain (see section 8.6.2
                  // of the ES 5.1 spec). The parenthesized expression prevents an
                  // unsafe transformation by the Closure Compiler.
                  var original = this.__proto__, result = property in (this.__proto__ = null, this);
                  // Restore the original prototype chain.
                  this.__proto__ = original;
                  return result;
                };
              } else {
                // Capture a reference to the top-level `Object` constructor.
                constructor = members.constructor;
                // Use the `constructor` property to simulate `Object#hasOwnProperty` in
                // other environments.
                isProperty = function (property) {
                  var parent = (this.constructor || constructor).prototype;
                  return property in this && !(property in parent && this[property] === parent[property]);
                };
              }
              members = null;
              return isProperty.call(this, property);
            };
          }

          // Internal: Normalizes the `for...in` iteration algorithm across
          // environments. Each enumerated key is yielded to a `callback` function.
          forEach = function (object, callback) {
            var size = 0, Properties, members, property;

            // Tests for bugs in the current environment's `for...in` algorithm. The
            // `valueOf` property inherits the non-enumerable flag from
            // `Object.prototype` in older versions of IE, Netscape, and Mozilla.
            (Properties = function () {
              this.valueOf = 0;
            }).prototype.valueOf = 0;

            // Iterate over a new instance of the `Properties` class.
            members = new Properties();
            for (property in members) {
              // Ignore all properties inherited from `Object.prototype`.
              if (isProperty.call(members, property)) {
                size++;
              }
            }
            Properties = members = null;

            // Normalize the iteration algorithm.
            if (!size) {
              // A list of non-enumerable properties inherited from `Object.prototype`.
              members = ["valueOf", "toString", "toLocaleString", "propertyIsEnumerable", "isPrototypeOf", "hasOwnProperty", "constructor"];
              // IE <= 8, Mozilla 1.0, and Netscape 6.2 ignore shadowed non-enumerable
              // properties.
              forEach = function (object, callback) {
                var isFunction = getClass.call(object) == functionClass, property, length;
                var hasProperty = !isFunction && typeof object.constructor != "function" && objectTypes[typeof object.hasOwnProperty] && object.hasOwnProperty || isProperty;
                for (property in object) {
                  // Gecko <= 1.0 enumerates the `prototype` property of functions under
                  // certain conditions; IE does not.
                  if (!(isFunction && property == "prototype") && hasProperty.call(object, property)) {
                    callback(property);
                  }
                }
                // Manually invoke the callback for each non-enumerable property.
                for (length = members.length; property = members[--length]; hasProperty.call(object, property) && callback(property));
              };
            } else if (size == 2) {
              // Safari <= 2.0.4 enumerates shadowed properties twice.
              forEach = function (object, callback) {
                // Create a set of iterated properties.
                var members = {}, isFunction = getClass.call(object) == functionClass, property;
                for (property in object) {
                  // Store each property name to prevent double enumeration. The
                  // `prototype` property of functions is not enumerated due to cross-
                  // environment inconsistencies.
                  if (!(isFunction && property == "prototype") && !isProperty.call(members, property) && (members[property] = 1) && isProperty.call(object, property)) {
                    callback(property);
                  }
                }
              };
            } else {
              // No bugs detected; use the standard `for...in` algorithm.
              forEach = function (object, callback) {
                var isFunction = getClass.call(object) == functionClass, property, isConstructor;
                for (property in object) {
                  if (!(isFunction && property == "prototype") && isProperty.call(object, property) && !(isConstructor = property === "constructor")) {
                    callback(property);
                  }
                }
                // Manually invoke the callback for the `constructor` property due to
                // cross-environment inconsistencies.
                if (isConstructor || isProperty.call(object, (property = "constructor"))) {
                  callback(property);
                }
              };
            }
            return forEach(object, callback);
          };

          // Public: Serializes a JavaScript `value` as a JSON string. The optional
          // `filter` argument may specify either a function that alters how object and
          // array members are serialized, or an array of strings and numbers that
          // indicates which properties should be serialized. The optional `width`
          // argument may be either a string or number that specifies the indentation
          // level of the output.
          if (!has("json-stringify")) {
            // Internal: A map of control characters and their escaped equivalents.
            var Escapes = {
              92: "\\\\",
              34: '\\"',
              8: "\\b",
              12: "\\f",
              10: "\\n",
              13: "\\r",
              9: "\\t"
            };

            // Internal: Converts `value` into a zero-padded string such that its
            // length is at least equal to `width`. The `width` must be <= 6.
            var leadingZeroes = "000000";
            var toPaddedString = function (width, value) {
              // The `|| 0` expression is necessary to work around a bug in
              // Opera <= 7.54u2 where `0 == -0`, but `String(-0) !== "0"`.
              return (leadingZeroes + (value || 0)).slice(-width);
            };

            // Internal: Double-quotes a string `value`, replacing all ASCII control
            // characters (characters with code unit values between 0 and 31) with
            // their escaped equivalents. This is an implementation of the
            // `Quote(value)` operation defined in ES 5.1 section 15.12.3.
            var unicodePrefix = "\\u00";
            var quote = function (value) {
              var result = '"', index = 0, length = value.length, useCharIndex = !charIndexBuggy || length > 10;
              var symbols = useCharIndex && (charIndexBuggy ? value.split("") : value);
              for (; index < length; index++) {
                var charCode = value.charCodeAt(index);
                // If the character is a control character, append its Unicode or
                // shorthand escape sequence; otherwise, append the character as-is.
                switch (charCode) {
                  case 8: case 9: case 10: case 12: case 13: case 34: case 92:
                    result += Escapes[charCode];
                    break;
                  default:
                    if (charCode < 32) {
                      result += unicodePrefix + toPaddedString(2, charCode.toString(16));
                      break;
                    }
                    result += useCharIndex ? symbols[index] : value.charAt(index);
                }
              }
              return result + '"';
            };

            // Internal: Recursively serializes an object. Implements the
            // `Str(key, holder)`, `JO(value)`, and `JA(value)` operations.
            var serialize = function (property, object, callback, properties, whitespace, indentation, stack) {
              var value, className, year, month, date, time, hours, minutes, seconds, milliseconds, results, element, index, length, prefix, result;
              try {
                // Necessary for host object support.
                value = object[property];
              } catch (exception) {}
              if (typeof value == "object" && value) {
                className = getClass.call(value);
                if (className == dateClass && !isProperty.call(value, "toJSON")) {
                  if (value > -1 / 0 && value < 1 / 0) {
                    // Dates are serialized according to the `Date#toJSON` method
                    // specified in ES 5.1 section 15.9.5.44. See section 15.9.1.15
                    // for the ISO 8601 date time string format.
                    if (getDay) {
                      // Manually compute the year, month, date, hours, minutes,
                      // seconds, and milliseconds if the `getUTC*` methods are
                      // buggy. Adapted from @Yaffle's `date-shim` project.
                      date = floor(value / 864e5);
                      for (year = floor(date / 365.2425) + 1970 - 1; getDay(year + 1, 0) <= date; year++);
                      for (month = floor((date - getDay(year, 0)) / 30.42); getDay(year, month + 1) <= date; month++);
                      date = 1 + date - getDay(year, month);
                      // The `time` value specifies the time within the day (see ES
                      // 5.1 section 15.9.1.2). The formula `(A % B + B) % B` is used
                      // to compute `A modulo B`, as the `%` operator does not
                      // correspond to the `modulo` operation for negative numbers.
                      time = (value % 864e5 + 864e5) % 864e5;
                      // The hours, minutes, seconds, and milliseconds are obtained by
                      // decomposing the time within the day. See section 15.9.1.10.
                      hours = floor(time / 36e5) % 24;
                      minutes = floor(time / 6e4) % 60;
                      seconds = floor(time / 1e3) % 60;
                      milliseconds = time % 1e3;
                    } else {
                      year = value.getUTCFullYear();
                      month = value.getUTCMonth();
                      date = value.getUTCDate();
                      hours = value.getUTCHours();
                      minutes = value.getUTCMinutes();
                      seconds = value.getUTCSeconds();
                      milliseconds = value.getUTCMilliseconds();
                    }
                    // Serialize extended years correctly.
                    value = (year <= 0 || year >= 1e4 ? (year < 0 ? "-" : "+") + toPaddedString(6, year < 0 ? -year : year) : toPaddedString(4, year)) +
                      "-" + toPaddedString(2, month + 1) + "-" + toPaddedString(2, date) +
                      // Months, dates, hours, minutes, and seconds should have two
                      // digits; milliseconds should have three.
                      "T" + toPaddedString(2, hours) + ":" + toPaddedString(2, minutes) + ":" + toPaddedString(2, seconds) +
                      // Milliseconds are optional in ES 5.0, but required in 5.1.
                      "." + toPaddedString(3, milliseconds) + "Z";
                  } else {
                    value = null;
                  }
                } else if (typeof value.toJSON == "function" && ((className != numberClass && className != stringClass && className != arrayClass) || isProperty.call(value, "toJSON"))) {
                  // Prototype <= 1.6.1 adds non-standard `toJSON` methods to the
                  // `Number`, `String`, `Date`, and `Array` prototypes. JSON 3
                  // ignores all `toJSON` methods on these objects unless they are
                  // defined directly on an instance.
                  value = value.toJSON(property);
                }
              }
              if (callback) {
                // If a replacement function was provided, call it to obtain the value
                // for serialization.
                value = callback.call(object, property, value);
              }
              if (value === null) {
                return "null";
              }
              className = getClass.call(value);
              if (className == booleanClass) {
                // Booleans are represented literally.
                return "" + value;
              } else if (className == numberClass) {
                // JSON numbers must be finite. `Infinity` and `NaN` are serialized as
                // `"null"`.
                return value > -1 / 0 && value < 1 / 0 ? "" + value : "null";
              } else if (className == stringClass) {
                // Strings are double-quoted and escaped.
                return quote("" + value);
              }
              // Recursively serialize objects and arrays.
              if (typeof value == "object") {
                // Check for cyclic structures. This is a linear search; performance
                // is inversely proportional to the number of unique nested objects.
                for (length = stack.length; length--;) {
                  if (stack[length] === value) {
                    // Cyclic structures cannot be serialized by `JSON.stringify`.
                    throw TypeError();
                  }
                }
                // Add the object to the stack of traversed objects.
                stack.push(value);
                results = [];
                // Save the current indentation level and indent one additional level.
                prefix = indentation;
                indentation += whitespace;
                if (className == arrayClass) {
                  // Recursively serialize array elements.
                  for (index = 0, length = value.length; index < length; index++) {
                    element = serialize(index, value, callback, properties, whitespace, indentation, stack);
                    results.push(element === undef ? "null" : element);
                  }
                  result = results.length ? (whitespace ? "[\n" + indentation + results.join(",\n" + indentation) + "\n" + prefix + "]" : ("[" + results.join(",") + "]")) : "[]";
                } else {
                  // Recursively serialize object members. Members are selected from
                  // either a user-specified list of property names, or the object
                  // itself.
                  forEach(properties || value, function (property) {
                    var element = serialize(property, value, callback, properties, whitespace, indentation, stack);
                    if (element !== undef) {
                      // According to ES 5.1 section 15.12.3: "If `gap` {whitespace}
                      // is not the empty string, let `member` {quote(property) + ":"}
                      // be the concatenation of `member` and the `space` character."
                      // The "`space` character" refers to the literal space
                      // character, not the `space` {width} argument provided to
                      // `JSON.stringify`.
                      results.push(quote(property) + ":" + (whitespace ? " " : "") + element);
                    }
                  });
                  result = results.length ? (whitespace ? "{\n" + indentation + results.join(",\n" + indentation) + "\n" + prefix + "}" : ("{" + results.join(",") + "}")) : "{}";
                }
                // Remove the object from the traversed object stack.
                stack.pop();
                return result;
              }
            };

            // Public: `JSON.stringify`. See ES 5.1 section 15.12.3.
            exports.stringify = function (source, filter, width) {
              var whitespace, callback, properties, className;
              if (objectTypes[typeof filter] && filter) {
                if ((className = getClass.call(filter)) == functionClass) {
                  callback = filter;
                } else if (className == arrayClass) {
                  // Convert the property names array into a makeshift set.
                  properties = {};
                  for (var index = 0, length = filter.length, value; index < length; value = filter[index++], ((className = getClass.call(value)), className == stringClass || className == numberClass) && (properties[value] = 1));
                }
              }
              if (width) {
                if ((className = getClass.call(width)) == numberClass) {
                  // Convert the `width` to an integer and create a string containing
                  // `width` number of space characters.
                  if ((width -= width % 1) > 0) {
                    for (whitespace = "", width > 10 && (width = 10); whitespace.length < width; whitespace += " ");
                  }
                } else if (className == stringClass) {
                  whitespace = width.length <= 10 ? width : width.slice(0, 10);
                }
              }
              // Opera <= 7.54u2 discards the values associated with empty string keys
              // (`""`) only if they are used directly within an object member list
              // (e.g., `!("" in { "": 1})`).
              return serialize("", (value = {}, value[""] = source, value), callback, properties, whitespace, "", []);
            };
          }

          // Public: Parses a JSON source string.
          if (!has("json-parse")) {
            var fromCharCode = String.fromCharCode;

            // Internal: A map of escaped control characters and their unescaped
            // equivalents.
            var Unescapes = {
              92: "\\",
              34: '"',
              47: "/",
              98: "\b",
              116: "\t",
              110: "\n",
              102: "\f",
              114: "\r"
            };

            // Internal: Stores the parser state.
            var Index, Source;

            // Internal: Resets the parser state and throws a `SyntaxError`.
            var abort = function () {
              Index = Source = null;
              throw SyntaxError();
            };

            // Internal: Returns the next token, or `"$"` if the parser has reached
            // the end of the source string. A token may be a string, number, `null`
            // literal, or Boolean literal.
            var lex = function () {
              var source = Source, length = source.length, value, begin, position, isSigned, charCode;
              while (Index < length) {
                charCode = source.charCodeAt(Index);
                switch (charCode) {
                  case 9: case 10: case 13: case 32:
                    // Skip whitespace tokens, including tabs, carriage returns, line
                    // feeds, and space characters.
                    Index++;
                    break;
                  case 123: case 125: case 91: case 93: case 58: case 44:
                    // Parse a punctuator token (`{`, `}`, `[`, `]`, `:`, or `,`) at
                    // the current position.
                    value = charIndexBuggy ? source.charAt(Index) : source[Index];
                    Index++;
                    return value;
                  case 34:
                    // `"` delimits a JSON string; advance to the next character and
                    // begin parsing the string. String tokens are prefixed with the
                    // sentinel `@` character to distinguish them from punctuators and
                    // end-of-string tokens.
                    for (value = "@", Index++; Index < length;) {
                      charCode = source.charCodeAt(Index);
                      if (charCode < 32) {
                        // Unescaped ASCII control characters (those with a code unit
                        // less than the space character) are not permitted.
                        abort();
                      } else if (charCode == 92) {
                        // A reverse solidus (`\`) marks the beginning of an escaped
                        // control character (including `"`, `\`, and `/`) or Unicode
                        // escape sequence.
                        charCode = source.charCodeAt(++Index);
                        switch (charCode) {
                          case 92: case 34: case 47: case 98: case 116: case 110: case 102: case 114:
                            // Revive escaped control characters.
                            value += Unescapes[charCode];
                            Index++;
                            break;
                          case 117:
                            // `\u` marks the beginning of a Unicode escape sequence.
                            // Advance to the first character and validate the
                            // four-digit code point.
                            begin = ++Index;
                            for (position = Index + 4; Index < position; Index++) {
                              charCode = source.charCodeAt(Index);
                              // A valid sequence comprises four hexdigits (case-
                              // insensitive) that form a single hexadecimal value.
                              if (!(charCode >= 48 && charCode <= 57 || charCode >= 97 && charCode <= 102 || charCode >= 65 && charCode <= 70)) {
                                // Invalid Unicode escape sequence.
                                abort();
                              }
                            }
                            // Revive the escaped character.
                            value += fromCharCode("0x" + source.slice(begin, Index));
                            break;
                          default:
                            // Invalid escape sequence.
                            abort();
                        }
                      } else {
                        if (charCode == 34) {
                          // An unescaped double-quote character marks the end of the
                          // string.
                          break;
                        }
                        charCode = source.charCodeAt(Index);
                        begin = Index;
                        // Optimize for the common case where a string is valid.
                        while (charCode >= 32 && charCode != 92 && charCode != 34) {
                          charCode = source.charCodeAt(++Index);
                        }
                        // Append the string as-is.
                        value += source.slice(begin, Index);
                      }
                    }
                    if (source.charCodeAt(Index) == 34) {
                      // Advance to the next character and return the revived string.
                      Index++;
                      return value;
                    }
                    // Unterminated string.
                    abort();
                  default:
                    // Parse numbers and literals.
                    begin = Index;
                    // Advance past the negative sign, if one is specified.
                    if (charCode == 45) {
                      isSigned = true;
                      charCode = source.charCodeAt(++Index);
                    }
                    // Parse an integer or floating-point value.
                    if (charCode >= 48 && charCode <= 57) {
                      // Leading zeroes are interpreted as octal literals.
                      if (charCode == 48 && ((charCode = source.charCodeAt(Index + 1)), charCode >= 48 && charCode <= 57)) {
                        // Illegal octal literal.
                        abort();
                      }
                      isSigned = false;
                      // Parse the integer component.
                      for (; Index < length && ((charCode = source.charCodeAt(Index)), charCode >= 48 && charCode <= 57); Index++);
                      // Floats cannot contain a leading decimal point; however, this
                      // case is already accounted for by the parser.
                      if (source.charCodeAt(Index) == 46) {
                        position = ++Index;
                        // Parse the decimal component.
                        for (; position < length && ((charCode = source.charCodeAt(position)), charCode >= 48 && charCode <= 57); position++);
                        if (position == Index) {
                          // Illegal trailing decimal.
                          abort();
                        }
                        Index = position;
                      }
                      // Parse exponents. The `e` denoting the exponent is
                      // case-insensitive.
                      charCode = source.charCodeAt(Index);
                      if (charCode == 101 || charCode == 69) {
                        charCode = source.charCodeAt(++Index);
                        // Skip past the sign following the exponent, if one is
                        // specified.
                        if (charCode == 43 || charCode == 45) {
                          Index++;
                        }
                        // Parse the exponential component.
                        for (position = Index; position < length && ((charCode = source.charCodeAt(position)), charCode >= 48 && charCode <= 57); position++);
                        if (position == Index) {
                          // Illegal empty exponent.
                          abort();
                        }
                        Index = position;
                      }
                      // Coerce the parsed value to a JavaScript number.
                      return +source.slice(begin, Index);
                    }
                    // A negative sign may only precede numbers.
                    if (isSigned) {
                      abort();
                    }
                    // `true`, `false`, and `null` literals.
                    if (source.slice(Index, Index + 4) == "true") {
                      Index += 4;
                      return true;
                    } else if (source.slice(Index, Index + 5) == "false") {
                      Index += 5;
                      return false;
                    } else if (source.slice(Index, Index + 4) == "null") {
                      Index += 4;
                      return null;
                    }
                    // Unrecognized token.
                    abort();
                }
              }
              // Return the sentinel `$` character if the parser has reached the end
              // of the source string.
              return "$";
            };

            // Internal: Parses a JSON `value` token.
            var get = function (value) {
              var results, hasMembers;
              if (value == "$") {
                // Unexpected end of input.
                abort();
              }
              if (typeof value == "string") {
                if ((charIndexBuggy ? value.charAt(0) : value[0]) == "@") {
                  // Remove the sentinel `@` character.
                  return value.slice(1);
                }
                // Parse object and array literals.
                if (value == "[") {
                  // Parses a JSON array, returning a new JavaScript array.
                  results = [];
                  for (;; hasMembers || (hasMembers = true)) {
                    value = lex();
                    // A closing square bracket marks the end of the array literal.
                    if (value == "]") {
                      break;
                    }
                    // If the array literal contains elements, the current token
                    // should be a comma separating the previous element from the
                    // next.
                    if (hasMembers) {
                      if (value == ",") {
                        value = lex();
                        if (value == "]") {
                          // Unexpected trailing `,` in array literal.
                          abort();
                        }
                      } else {
                        // A `,` must separate each array element.
                        abort();
                      }
                    }
                    // Elisions and leading commas are not permitted.
                    if (value == ",") {
                      abort();
                    }
                    results.push(get(value));
                  }
                  return results;
                } else if (value == "{") {
                  // Parses a JSON object, returning a new JavaScript object.
                  results = {};
                  for (;; hasMembers || (hasMembers = true)) {
                    value = lex();
                    // A closing curly brace marks the end of the object literal.
                    if (value == "}") {
                      break;
                    }
                    // If the object literal contains members, the current token
                    // should be a comma separator.
                    if (hasMembers) {
                      if (value == ",") {
                        value = lex();
                        if (value == "}") {
                          // Unexpected trailing `,` in object literal.
                          abort();
                        }
                      } else {
                        // A `,` must separate each object member.
                        abort();
                      }
                    }
                    // Leading commas are not permitted, object property names must be
                    // double-quoted strings, and a `:` must separate each property
                    // name and value.
                    if (value == "," || typeof value != "string" || (charIndexBuggy ? value.charAt(0) : value[0]) != "@" || lex() != ":") {
                      abort();
                    }
                    results[value.slice(1)] = get(lex());
                  }
                  return results;
                }
                // Unexpected token encountered.
                abort();
              }
              return value;
            };

            // Internal: Updates a traversed object member.
            var update = function (source, property, callback) {
              var element = walk(source, property, callback);
              if (element === undef) {
                delete source[property];
              } else {
                source[property] = element;
              }
            };

            // Internal: Recursively traverses a parsed JSON object, invoking the
            // `callback` function for each value. This is an implementation of the
            // `Walk(holder, name)` operation defined in ES 5.1 section 15.12.2.
            var walk = function (source, property, callback) {
              var value = source[property], length;
              if (typeof value == "object" && value) {
                // `forEach` can't be used to traverse an array in Opera <= 8.54
                // because its `Object#hasOwnProperty` implementation returns `false`
                // for array indices (e.g., `![1, 2, 3].hasOwnProperty("0")`).
                if (getClass.call(value) == arrayClass) {
                  for (length = value.length; length--;) {
                    update(value, length, callback);
                  }
                } else {
                  forEach(value, function (property) {
                    update(value, property, callback);
                  });
                }
              }
              return callback.call(source, property, value);
            };

            // Public: `JSON.parse`. See ES 5.1 section 15.12.2.
            exports.parse = function (source, callback) {
              var result, value;
              Index = 0;
              Source = "" + source;
              result = get(lex());
              // If a JSON string contains multiple tokens, it is invalid.
              if (lex() != "$") {
                abort();
              }
              // Reset the parser state.
              Index = Source = null;
              return callback && getClass.call(callback) == functionClass ? walk((value = {}, value[""] = result, value), "", callback) : result;
            };
          }
        }

        exports["runInContext"] = runInContext;
        return exports;
      }

      if (freeExports && !isLoader) {
        // Export for CommonJS environments.
        runInContext(root, freeExports);
      } else {
        // Export for web browsers and JavaScript engines.
        var nativeJSON = root.JSON,
            previousJSON = root["JSON3"],
            isRestored = false;

        var JSON3 = runInContext(root, (root["JSON3"] = {
          // Public: Restores the original value of the global `JSON` object and
          // returns a reference to the `JSON3` object.
          "noConflict": function () {
            if (!isRestored) {
              isRestored = true;
              root.JSON = nativeJSON;
              root["JSON3"] = previousJSON;
              nativeJSON = previousJSON = null;
            }
            return JSON3;
          }
        }));

        root.JSON = {
          "parse": JSON3.parse,
          "stringify": JSON3.stringify
        };
      }

      // Export for asynchronous module loaders.
      if (isLoader) {
        define(function () {
          return JSON3;
        });
      }
    }).call(this);

    }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{}],665:[function(require,module,exports){
    module.exports = toArray

    function toArray(list, index) {
        var array = []

        index = index || 0

        for (var i = index || 0; i < list.length; i++) {
            array[i - index] = list[i]
        }

        return array
    }

    },{}],666:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var {
      Grid,
      Row,
      Col
    } = ReactBootstrap;

    var AproposPanel = require('./AproposPanel');

    var AproposContainer = React.createClass({displayName: "AproposContainer",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-AproposContainer')(this.props.controller, this);
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);

        return (
          React.createElement(Grid, {
            fluid: true,
            className: this.hideContainer ? 'hidden' : ''
          },
            React.createElement(Row, null,
              React.createElement(Col, {md: 12},
                React.createElement(AproposPanel, {
                  controller: this.controller}
                )
              )
            )
          )
        );

      }
    });

    module.exports = AproposContainer;
    },{"./AproposPanel":667,"./controller-AproposContainer":699,"react":618,"react-bootstrap":96}],667:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var Inspector = require('react-json-inspector');

    var {
      Button,
      Glyphicon,
      OverlayTrigger,
      Panel,
      Tooltip,
      Image,
      Carousel,
      Media
    } = ReactBootstrap;

    var AproposPanel = React.createClass({displayName: "AproposPanel",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-AproposPanel')(this.props.controller, this);

        this.title = (
          React.createElement("h1", null, "A propos")
        );
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);

        return (
          React.createElement(Panel, {
            collapsible: true,
            expanded: this.expanded,
            header: this.title,
            bsStyle: "primary"
          },

          React.createElement(Carousel, {activeIndex: this.state.index, direction: this.state.direction, onSelect: this.handleSelect},
            React.createElement(Carousel.Item, null,
              React.createElement("img", {width: 1800, height: 640, alt: "900x500", src: "./images/carousel.jpg"}),
              React.createElement(Carousel.Caption, null,
                React.createElement("h3", null, "First slide label"),
                React.createElement("p", null, "Nulla vitae elit libero, a pharetra augue mollis interdum.")
              )
            ),
            React.createElement(Carousel.Item, null,
              React.createElement("img", {width: 1800, height: 640, alt: "900x500", src: "./images/carousel2.jpg"}),
              React.createElement(Carousel.Caption, null,
                React.createElement("h3", null, "Second slide label"),
                React.createElement("p", null, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.")
              )
            ),
            React.createElement(Carousel.Item, null,
              React.createElement("img", {width: 1800, height: 640, alt: "900x500", src: "./images/carousel3.jpg"}),
              React.createElement(Carousel.Caption, null,
                React.createElement("h3", null, "Third slide label"),
                React.createElement("p", null, "Praesent commodo cursus magna, vel scelerisque nisl consectetur.")
              )
            )
          ),

        React.createElement(Media, null,
         React.createElement(Media.Left, null,
            React.createElement("img", {width: 64, height: 64, src: "./images/yexpert_logo.png", alt: "Image"})
          ),
          React.createElement(Media.Body, null,
            React.createElement(Media.Heading, null, "Yexpert"),

              React.createElement("p", null, "Yexpert est un Système Expert libre fonctionnant sous Mumps ", React.createElement("a", {href: "http://www.fisglobal.com/products-technologyplatforms-gtm", target: "_blank"}, "GT.M"), " et GNU/Linux. ", React.createElement("a", {href: "https://www.yrelay.fr/", target: "_blank"}, "Yrelay"), " utilise de nombreuses contributions communautaires libres notamment l'application ", React.createElement("a", {href: "http://www.mgateway.com/", target: "_blank"}, "EWD 3"), "."),
              React.createElement("p", null, "Comme tous les systèmes experts Yexpert se présente comme une coquille vide qu’il va falloir compléter.")

          )
        )

          )
        );
      }
    });

    module.exports = AproposPanel;
    },{"./controller-AproposPanel":700,"react":618,"react-bootstrap":96,"react-json-inspector":413}],668:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var {
      Nav,
      Navbar,
      NavItem,
      NavDropdown,
      MenuItem,
      SubMenu
    } = ReactBootstrap;

    var Banner = React.createClass({displayName: "Banner",

      render: function() {
        //console.log('render Banner');
        //this.props.controller.updateComponentPath(this);

        return (
          React.createElement("div", null,

          React.createElement(Nav, {bsStyle: "tabs", activeKey: "1", onSelect: this.props.controller.navOptionSelected},
            React.createElement(NavDropdown, {eventKey: "fichier", title: "Fichier", id: "nav-dropdown"},
              React.createElement(NavDropdown, {eventKey: "nouveau", title: "Nouveau", id: "nav-dropdown", horizontal: true},
                React.createElement(MenuItem, {eventKey: "nouvpartition"}, "Nouvelle partition")
              ),
              React.createElement(MenuItem, {eventKey: "ouvrirunfichier"}, "Ouvrir un fichier"),
              React.createElement(MenuItem, {divider: true}),
              React.createElement(MenuItem, {eventKey: "fermer"}, "Fermer"),
              React.createElement(MenuItem, {divider: true}),
              React.createElement(MenuItem, {eventKey: "logout"}, "Quitter")
            ),
            React.createElement(NavDropdown, {eventKey: "editer", title: "Editer", id: "nav-dropdown"}
            ),
            React.createElement(NavDropdown, {eventKey: "navigation", title: "Navigation", id: "nav-dropdown"}
            ),
            React.createElement(NavDropdown, {eventKey: "rechercher", title: "Rechercher", id: "nav-dropdown"}
            ),
            React.createElement(NavDropdown, {eventKey: "projet", title: "Projet", id: "nav-dropdown"}
            ),
            React.createElement(NavDropdown, {eventKey: "executer", title: "Exécuter", id: "nav-dropdown"}
            ),
            React.createElement(NavDropdown, {eventKey: "fenetre", title: "Fenêtre", id: "nav-dropdown"}
            ),
            React.createElement(NavDropdown, {eventKey: "aide", title: "Aide", id: "nav-dropdown"},
              React.createElement(MenuItem, {eventKey: "bienvenue"}, "Bienvenue"),
              React.createElement(MenuItem, {divider: true}),
              React.createElement(MenuItem, {eventKey: "tabledesmatieresdelaide"}, "Table des matières de l'aide"),
              React.createElement(MenuItem, {divider: true}),
              React.createElement(MenuItem, {eventKey: "apropos"}, "A propos d'Yexpert")
            ),
            React.createElement(NavDropdown, {eventKey: "ewd3", title: "EWD3", id: "nav-dropdown"},
              React.createElement(MenuItem, {eventKey: "menustore"}, "Menu général"),
              React.createElement(MenuItem, {eventKey: "terminal"}, "Terminal"),
              React.createElement(MenuItem, {eventKey: "overview"}, "Vue d'ensemble"),
              React.createElement(MenuItem, {eventKey: "docstore"}, "Globals"),
              React.createElement(MenuItem, {eventKey: "sessions"}, "Sessions"),
              React.createElement(MenuItem, {eventKey: "console"}, "Console")
            )

          )

          )
        );
      }
    });

    module.exports = Banner;
    },{"react":618,"react-bootstrap":96}],669:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var {
      Grid,
      Row,
      Col
    } = ReactBootstrap;

    var BienvenuePanel = require('./BienvenuePanel');

    var BienvenueContainer = React.createClass({displayName: "BienvenueContainer",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-BienvenueContainer')(this.props.controller, this);
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);

        return (
          React.createElement(Grid, {
            fluid: true,
            className: this.hideContainer ? 'hidden' : ''
          },
            React.createElement(Row, null,
              React.createElement(Col, {md: 12},
                React.createElement(BienvenuePanel, {
                  controller: this.controller}
                )
              )
            )
          )
        );

      }
    });

    module.exports = BienvenueContainer;
    },{"./BienvenuePanel":670,"./controller-BienvenueContainer":701,"react":618,"react-bootstrap":96}],670:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var Inspector = require('react-json-inspector');

    var {
      Button,
      Glyphicon,
      OverlayTrigger,
      Panel,
      Tooltip,
      Image,
      Carousel,
      Media,
      Jumbotron,
      Modal
    } = ReactBootstrap;

    var BienvenuePanel = React.createClass({displayName: "BienvenuePanel",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-BienvenuePanel')(this.props.controller, this);

        this.title = (
          React.createElement("h1", null, "Bienvenue")
        );
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);

        return (
          React.createElement(Panel, {
            collapsible: true,
            expanded: this.expanded,
            header: this.title,
            bsStyle: "primary"
          },

          React.createElement(Jumbotron, null,
            React.createElement("h1", null, "Bonjour !"),

            React.createElement(Media, null,
             React.createElement(Media.Left, null,
                React.createElement("img", {width: 64, height: 64, src: "./images/yexpert_logo.png", alt: "Image"})
              ),
              React.createElement(Media.Body, null,
                React.createElement(Media.Heading, null, "Yexpert-JS 0.0.1"),

                  React.createElement("p", null, "Le Système Expert Yexpert est libre et fonctionne sous Mumps ", React.createElement("a", {href: "http://www.fisglobal.com/products-technologyplatforms-gtm", target: "_blank"}, "GT.M"), " et GNU/Linux. ", React.createElement("a", {href: "https://www.yrelay.fr/", target: "_blank"}, "Yrelay"), " utilise de nombreuses contributions communautaires libres notamment l'application ", React.createElement("a", {href: "http://www.mgateway.com/", target: "_blank"}, "EWD 3"), "."),
                  React.createElement("p", null, "Comme tous les systèmes experts, Yexpert se présente comme une coquille vide qu’il va falloir compléter.")

              )
            ),

            React.createElement("p", null, React.createElement(Button, {bsStyle: "primary", href: "https://www.yrelay.fr/", target: "_blank"}, "En savoir plus"))

          )

          )
        );
      }
    });

    module.exports = BienvenuePanel;
    },{"./controller-BienvenuePanel":702,"react":618,"react-bootstrap":96,"react-json-inspector":413}],671:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var {
      Panel,
      Table
    } = ReactBootstrap;

    var BuildDetails = React.createClass({displayName: "BuildDetails",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-BuildDetails')(this.props.controller, this);
        this.title = (
          React.createElement("h2", null, "Build Details")
        );
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //console.log('Rendering Build Details!');
        //var componentPath = this.controller.updateComponentPath(this);

        return (
          React.createElement(Panel, {
    	    header: this.title,
    		bsStyle: "info"
    	  },
            React.createElement(Table, {responsive: true, className: "overviewTable"},
              React.createElement("thead", null,
                React.createElement("tr", null,
                  React.createElement("th", null, "Module"),
                  React.createElement("th", null, "Version/build")
                )
              ),
              React.createElement("tbody", null,
                React.createElement("tr", null,
                  React.createElement("td", null, "Node.js"),
                  React.createElement("td", null, this.nodejsBuild)
                ),
                React.createElement("tr", null,
                  React.createElement("td", null, "Database Interface"),
                  React.createElement("td", null, this.dbInterface)
                ),
                React.createElement("tr", null,
                  React.createElement("td", null, "Database"),
                  React.createElement("td", null, this.db)
                ),
                React.createElement("tr", null,
                  React.createElement("td", null, "ewd-qoper8"),
                  React.createElement("td", null, this.qoper8Build)
                ),
                React.createElement("tr", null,
                  React.createElement("td", null, "ewd-document-store"),
                  React.createElement("td", null, this.docStoreBuild)
                ),
                React.createElement("tr", null,
                  React.createElement("td", null, "ewd-qoper8-express"),
                  React.createElement("td", null, this.qxBuild)
                ),
                React.createElement("tr", null,
                  React.createElement("td", null, "ewd-express"),
                  React.createElement("td", null, this.xpressBuild)
                ),
                React.createElement("tr", null,
                  React.createElement("td", null, "Yexpert-M"),
                  React.createElement("td", null, "4.0.6")
                ),
                React.createElement("tr", null,
                  React.createElement("td", null, "Yexpert-JS"),
                  React.createElement("td", null, "0.0.1")
                )
              )
            )
          )
        );
      }
    });

    module.exports = BuildDetails;
    },{"./controller-BuildDetails":703,"react":618,"react-bootstrap":96}],672:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var {
      Grid,
      Row,
      Col
    } = ReactBootstrap;

    var ConsolePanel = require('./ConsolePanel');

    var ConsoleContainer = React.createClass({displayName: "ConsoleContainer",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-ConsoleContainer')(this.props.controller, this);
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);

        return (
          React.createElement(Grid, {
            className: this.hideContainer ? 'hidden' : ''
          },
            React.createElement(Row, null,
              React.createElement(Col, {md: 12},
                React.createElement(ConsolePanel, {
                  controller: this.controller}
                )
              )
            )
          )
        );

      }
    });

    module.exports = ConsoleContainer;
    },{"./ConsolePanel":673,"./controller-ConsoleContainer":704,"react":618,"react-bootstrap":96}],673:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var {
      Panel,
      Grid,
      Row,
      Col
    } = ReactBootstrap;

    var ConsolePanel = React.createClass({displayName: "ConsolePanel",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-ConsolePanel')(this.props.controller, this);
        this.title = (
          React.createElement("h1", null, "Console")
        );
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);

        return (
          React.createElement(Panel, {collapsible: true, expanded: this.expanded, header: this.title},
             React.createElement("div", null, "Console Panel contents here"),

            React.createElement(Grid, null,
              React.createElement(Row, null,
                React.createElement(Col, {md: 4},
                  React.createElement("div", null, "Build details")
                ),
                React.createElement(Col, {md: 4},
                  React.createElement("div", null, "Master Process details")
                ),
                React.createElement(Col, {md: 4},
                  React.createElement("div", null, "Child Process details")
                )
              )
            )

          )
        );
      }
    });

    module.exports = ConsolePanel;
    },{"./controller-ConsolePanel":705,"react":618,"react-bootstrap":96}],674:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');

    var NouvPartitionContainer = require('./NouvPartitionContainer');

    var BienvenueContainer = require('./BienvenueContainer');
    var AproposContainer = require('./AproposContainer');

    var MenuStoreContainer = require('./MenuStoreContainer');
    var TerminalContainer = require('./TerminalContainer');
    var OverviewContainer = require('./OverviewContainer');
    var DocumentStoreContainer = require('./DocumentStoreContainer');
    var SessionsContainer = require('./SessionsContainer');
    var ConsoleContainer = require('./ConsoleContainer');

    var Content = React.createClass({displayName: "Content",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-Content')(this.props.controller, this);
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);

        if (this.status === 'initial') {
          return (
            React.createElement("div", null)
          );
        }
        else {
          return (
            React.createElement("div", null,
              React.createElement(NouvPartitionContainer, {controller: this.controller, status: this.status}),

              React.createElement(BienvenueContainer, {controller: this.controller, status: this.status}),
              React.createElement(AproposContainer, {controller: this.controller, status: this.status}),

              React.createElement(MenuStoreContainer, {
                controller: this.controller,
                status: this.status}
              ),
              React.createElement(TerminalContainer, {
                controller: this.controller,
                status: this.status}
              ),
              React.createElement(OverviewContainer, {
                controller: this.controller,
                status: this.status}
              ),
              React.createElement(DocumentStoreContainer, {
                controller: this.controller,
                status: this.status}
              ),
              React.createElement(SessionsContainer, {
                controller: this.controller,
                status: this.status}
              ),
              React.createElement(ConsoleContainer, {
                controller: this.controller,
                status: this.status}
              )
            )
          );
        }
      }
    });

    module.exports = Content;
    },{"./AproposContainer":666,"./BienvenueContainer":669,"./ConsoleContainer":672,"./DocumentStoreContainer":675,"./MenuStoreContainer":681,"./NouvPartitionContainer":683,"./OverviewContainer":685,"./SessionsContainer":690,"./TerminalContainer":694,"./controller-Content":706,"react":618}],675:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var {
      Grid,
      Row,
      Col
    } = ReactBootstrap;

    var DocumentStorePanel = require('./DocumentStorePanel');

    var DocumentStoreContainer = React.createClass({displayName: "DocumentStoreContainer",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-DocumentStoreContainer')(this.props.controller, this);
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);

        return (
          React.createElement(Grid, {
            fluid: true,
            className: this.hideContainer ? 'hidden' : ''
          },
            React.createElement(Row, null,
              React.createElement(Col, {md: 12},
                React.createElement(DocumentStorePanel, {
                  controller: this.controller}
                )
              )
            )
          )
        );

      }
    });

    module.exports = DocumentStoreContainer;
    },{"./DocumentStorePanel":676,"./controller-DocumentStoreContainer":707,"react":618,"react-bootstrap":96}],676:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var Inspector = require('react-json-inspector');

    var {
      Button,
      Glyphicon,
      OverlayTrigger,
      Panel,
      Tooltip
    } = ReactBootstrap;

    var DocumentStorePanel = React.createClass({displayName: "DocumentStorePanel",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-DocumentStorePanel')(this.props.controller, this);

        this.tooltip = (
          React.createElement(Tooltip, {
            id: "DocumentRefreshBtn"
          },
            "Refresh"
          )
        );

        this.title = (
          React.createElement("span", null,
            React.createElement("b", null, "Documents"),
            React.createElement(OverlayTrigger, {
              placement: "top",
                overlay: this.tooltip
                    },
              React.createElement(Button, {
                bsClass: "btn btn-success pull-right",
                onClick: this.refresh
              },
                React.createElement(Glyphicon, {
                  glyph: "refresh"}
                )
              )
            )
          )
        );
      },

      componentDidUpdate: function() {

        //console.log('status: ' + this.state.status);
        var that = this;

        setTimeout(function() {
          $('.json-inspector__leaf').each(function(ix, item) {
            var id = $(item).attr('id');
            var name = id.split('root.')[1];
            if (!name) {
              $(item).find('span.json-inspector__key').first().hide();
              $(item).find('span.json-inspector__value').first().hide();
            }
            else if (name.indexOf('.') === -1 && that.data[name]) {
              $(item).find('span.json-inspector__key').first().addClass('json-inspector__docName');
            }
          });
        }, 100);
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);

        if (!this.data) {
          return (
            React.createElement("div", null)
          );
        }

        // create a clone of data to ensure re-rendering
        var newData = {};
        Object.assign(newData, this.data);

        return (
          React.createElement(Panel, {
            collapsible: true,
            expanded: this.expanded,
            header: this.title,
            bsStyle: "primary"
          },
            React.createElement(Inspector, {
              data: newData,
              isExpanded: this.isExpanded,
              onClick: this.nodeClicked,
              search: false}
            )
          )
        );
      }
    });

    module.exports = DocumentStorePanel;
    },{"./controller-DocumentStorePanel":708,"react":618,"react-bootstrap":96,"react-json-inspector":413}],677:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');

    var {
      FormControl
    } = ReactBootstrap;

    var LoginField = React.createClass({displayName: "LoginField",

      getInitialState: function() {
        return {value:''}
      },

      componentWillMount: function() {
        this.controller = require('./controller-LoginField')(this.props.controller, this);
      },

      render: function() {

        //console.log('LoginField rendering');
        //this.controller.updateComponentPath(this);

        return (
         React.createElement("div", null,
          React.createElement(FormControl, {
            type: "password",
            autoFocus: true,
            value: this.state.value,
            placeholder: this.props.placeholder,
            bsStyle: this.validationState(),
            ref: this.props.fieldname,
            label: this.props.label,
            onChange: this.handleChange}
          ),
          React.createElement(FormControl.Feedback, null)
         )
        )
      }
    });

    module.exports = LoginField;
    },{"./controller-LoginField":709,"react":618,"react-bootstrap":96}],678:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');

    var {
      Button,
      Modal,
      ModalTrigger,
      OverlayMixin
    } = ReactBootstrap;

    var LoginField = require('./LoginField');

    var LoginModal = React.createClass({displayName: "LoginModal",

      componentWillMount: function() {
        this.controller = require('./controller-LoginModal')(this.props.controller, this);
      },

      render: function() {

        //console.log('LoginModal rendering');
        //var componentPath = this.controller.updateComponentPath(this);

        return (

            React.createElement(Modal, {
              show: this.props.show,
              backdrop: "static",
              bsStyle: "primary",
              animation: true,
              onKeyPress: this.handleKeyDown
            },

              React.createElement(Modal.Header, null,
                React.createElement(Modal.Title, null, "Mot de passe")
              ),

              React.createElement(Modal.Body, null,
                React.createElement(LoginField, {
                  placeholder: "Entrez le mot de passe administrateur",
                  fieldname: "password",
                  label: "Mot de passe administrateur",
                  controller: this.controller,
                  focus: true}
                )
              ),

              React.createElement(Modal.Footer, null,
                React.createElement(Button, {onClick: this.handleLogin, bsStyle: "primary"}, "Se connecter")
              )

            )

        )
      }
    });

    module.exports = LoginModal;
    },{"./LoginField":677,"./controller-LoginModal":710,"react":618,"react-bootstrap":96}],679:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactToastr = require('react-toastr');
    var jQuery = require('jquery');
    window.$ = window.jQuery = jQuery;

    var {ToastContainer} = ReactToastr;
    var ToastMessageFactory = React.createFactory(ReactToastr.ToastMessage.animation);

    var LoginModal = require('./LoginModal');
    var Banner = require('./Banner');
    var Content = require('./Content');
    var Shutdown = require('./Shutdown');

    var controller;
    var title = 'Moniteur Yexpert';

    var MainPage = React.createClass({displayName: "MainPage",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        controller = require('./controller-MainPage')(this.props.controller, this);
      },

      render: function() {

         //console.log('rendering MainPage');
         //var componentPath = controller.updateComponentPath(this);

         if (this.state.status === 'shutdown') {
           return (
             React.createElement(Shutdown, {
               title: title}
             )
           );
         }

         return (
          React.createElement("div", null,
            React.createElement(Banner, {
              title: title,
              controller: controller}
            ),

            React.createElement(ToastContainer, {
              ref: "toastContainer",
              toastMessageFactory: ToastMessageFactory,
              className: "toast-top-right",
              newestOnTop: true,
              target: "body"}
            ),

            React.createElement(LoginModal, {
              controller: controller,
              show: this.showLoginModal}
            ),

            React.createElement(Content, {
              controller: controller,
              status: this.state.status}
            )

          )

        );
      }
    });

    module.exports = MainPage;
    },{"./Banner":668,"./Content":674,"./LoginModal":678,"./Shutdown":692,"./controller-MainPage":711,"jquery":8,"react":618,"react-toastr":432}],680:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var {
      Panel,
      Table,
      Button,
      Glyphicon,
      OverlayTrigger,
      Popover,
      Tooltip
    } = ReactBootstrap;

    var MasterProcessDetails = React.createClass({displayName: "MasterProcessDetails",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-MasterProcessDetails')(this.props.controller, this);
        this.title = (
          React.createElement("h2", null, "Master Process Details")
        );
        this.tooltip = (
          React.createElement(Tooltip, {
            id: "masterProcessShutdownBtn"
          },
            "Shutdown ewd-xpress"
          )
        );

      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //console.log('Rendering MasterProcessDetails!');
        //var componentPath = this.controller.updateComponentPath(this);

        var memoryPopover = (
          React.createElement(Popover, {
            id: "master-process-memory",
            title: "Master Process Memory"
          },
            React.createElement(Table, null,
              React.createElement("tbody", null,
                React.createElement("tr", null,
                  React.createElement("td", null, "rss:"),
                  React.createElement("td", null, this.master.memory.rss)
                ),
                React.createElement("tr", null,
                  React.createElement("td", null, "heapTotal:"),
                  React.createElement("td", null, this.master.memory.heapTotal)
                ),
                React.createElement("tr", null,
                  React.createElement("td", null, "heapUsed:"),
                  React.createElement("td", null, this.master.memory.heapUsed)
                )
              )
            )
          )
        );

        return (
          React.createElement(Panel, {
            header: this.title,
            bsStyle: "info"
          },
            React.createElement(Table, {
              responsive: true,
              className: "overviewTable"
            },
              React.createElement("tbody", null,
                React.createElement("tr", null,
                  React.createElement("td", null,
                    React.createElement(OverlayTrigger, {
                      trigger: ['hover', 'focus'],
                      placement: "right",
                      overlay: memoryPopover
                    },
                      React.createElement("span", null, this.pid)
                    )
                  ),
                  React.createElement("td", {className: "pushRight"},
                    React.createElement(OverlayTrigger, {
                      placement: "top",
                      overlay: this.tooltip
                    },
                      React.createElement(Button, {
                        bsStyle: "danger",
                        onClick: this.stopMasterProcess
                      },
                        React.createElement(Glyphicon, {
                          glyph: "remove"}
                        )
                      )
                    )
                  )
                ),
                React.createElement("tr", null,
                  React.createElement("td", null, "Started"),
                  React.createElement("td", {className: "pushRight"}, this.started)
                ),
                React.createElement("tr", null,
                  React.createElement("td", null, "Uptime"),
                  React.createElement("td", {className: "pushRight"}, this.upTime)
                )
              )
            )
          )
        );
      }
    });

    module.exports = MasterProcessDetails;
    },{"./controller-MasterProcessDetails":712,"react":618,"react-bootstrap":96}],681:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var {
      Grid,
      Row,
      Col
    } = ReactBootstrap;

    var MenuStorePanel = require('./MenuStorePanel');

    var MenuStoreContainer = React.createClass({displayName: "MenuStoreContainer",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-MenuStoreContainer')(this.props.controller, this);
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);

        return (
          React.createElement(Grid, {
            fluid: true,
            className: this.hideContainer ? 'hidden' : ''
          },
            React.createElement(Row, null,
              React.createElement(Col, {md: 12},
                React.createElement(MenuStorePanel, {
                  controller: this.controller}
                )
              )
            )
          )
        );

      }
    });

    module.exports = MenuStoreContainer;
    },{"./MenuStorePanel":682,"./controller-MenuStoreContainer":713,"react":618,"react-bootstrap":96}],682:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var Inspector = require('react-json-inspector');

    var {
      Button,
      Glyphicon,
      OverlayTrigger,
      Panel,
      Tooltip
    } = ReactBootstrap;

    var MenuStorePanel = React.createClass({displayName: "MenuStorePanel",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-MenuStorePanel')(this.props.controller, this);

        this.tooltip = (
          React.createElement(Tooltip, {
            id: "MenuRefreshBtn"
          },
            "Rafraîchir"
          )
        );

        this.title = (
          React.createElement("span", null,
            React.createElement("b", null, "Menus"),
            React.createElement(OverlayTrigger, {
              placement: "top",
                overlay: this.tooltip
                    },
              React.createElement(Button, {
                bsClass: "btn btn-success pull-right",
                onClick: this.refresh
              },
                React.createElement(Glyphicon, {
                  glyph: "refresh"}
                )
              )
            )
          )
        );
      },

      componentDidUpdate: function() {

        //console.log('status: ' + this.state.status);
        var that = this;

        setTimeout(function() {
          $('.json-inspector__leaf').each(function(ix, item) {
            var id = $(item).attr('id');
            var name = id.split('root.')[1];
            if (!name) {
              $(item).find('span.json-inspector__key').first().hide();
              $(item).find('span.json-inspector__value').first().hide();
            }
            else if (name.indexOf('.') === -1 && that.data[name]) {
              $(item).find('span.json-inspector__key').first().addClass('json-inspector__docName');
            }
          });
        }, 100);
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);

        if (!this.data) {
          return (
            React.createElement("div", null)
          );
        }

        // Créer un clone de données pour assurer un nouveau rendu
        var newData = {};
        Object.assign(newData, this.data);

        return (
          React.createElement(Panel, {
            collapsible: true,
            expanded: this.expanded,
            header: this.title,
            bsStyle: "primary"
          },
            React.createElement(Inspector, {
              data: newData,
              isExpanded: this.isExpanded,
              onClick: this.nodeClicked,
              search: false}
            )
          )
        );
      }
    });

    module.exports = MenuStorePanel;
    },{"./controller-MenuStorePanel":714,"react":618,"react-bootstrap":96,"react-json-inspector":413}],683:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var {
      Grid,
      Row,
      Col
    } = ReactBootstrap;

    var NouvPartitionPanel = require('./NouvPartitionPanel');

    var NouvPartitionContainer = React.createClass({displayName: "NouvPartitionContainer",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-NouvPartitionContainer')(this.props.controller, this);
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);

        return (
          React.createElement(Grid, {
            fluid: true,
            className: this.hideContainer ? 'hidden' : ''
          },
            React.createElement(Row, null,
              React.createElement(Col, {md: 12},
                React.createElement(NouvPartitionPanel, {
                  controller: this.controller}
                )
              )
            )
          )
        );

      }
    });

    module.exports = NouvPartitionContainer;
    },{"./NouvPartitionPanel":684,"./controller-NouvPartitionContainer":715,"react":618,"react-bootstrap":96}],684:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var Inspector = require('react-json-inspector');

    var {
      Button,
      Glyphicon,
      OverlayTrigger,
      Panel,
      Tooltip,
      Image,
      Carousel,
      Media,
      Jumbotron,
      Modal,
      FormGroup,
      ControlLabel,
      FormControl
    } = ReactBootstrap;

    var NouvPartitionPanel = React.createClass({displayName: "NouvPartitionPanel",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-NouvPartitionPanel')(this.props.controller, this);

        this.title = (
          React.createElement("h1", null, "Nouvelle partition")
        );
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);

        return (
          React.createElement(Panel, {
            collapsible: true,
            expanded: this.expanded,
            header: this.title,
            bsStyle: "primary"
          },

    "******************************"

          )
        );
      }
    });

    module.exports = NouvPartitionPanel;
    },{"./controller-NouvPartitionPanel":716,"react":618,"react-bootstrap":96,"react-json-inspector":413}],685:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var {
      Grid,
      Row,
      Col
    } = ReactBootstrap;

    var OverviewPanel = require('./OverviewPanel');

    var OverviewContainer = React.createClass({displayName: "OverviewContainer",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-OverviewContainer')(this.props.controller, this);
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);
        //console.log('OverviewContainer - this.hideContainer = ' + this.hideContainer);

        return (
          React.createElement(Grid, {
            fluid: true,
            className: this.hideContainer ? 'hidden' : ''
          },
            React.createElement(Row, null,
              React.createElement(Col, {md: 12},
                React.createElement(OverviewPanel, {
                  controller: this.controller}
                )
              )
            )
          )
        );
      }
    });

    module.exports = OverviewContainer;
    },{"./OverviewPanel":686,"./controller-OverviewContainer":717,"react":618,"react-bootstrap":96}],686:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var {
      Panel,
      Grid,
      Row,
      Col
    } = ReactBootstrap;

    var BuildDetails = require('./BuildDetails');
    var MasterProcessDetails = require('./MasterProcessDetails');
    var WorkerProcessDetailsTable = require('./WorkerProcessDetailsTable');

    var OverviewPanel = React.createClass({displayName: "OverviewPanel",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-OverviewPanel')(this.props.controller, this);
        this.title = (
          React.createElement("h1", null, "Overview ", this.serverName)
        );
      },

      componentWillUpdate: function() {
        this.title = (
          React.createElement("h1", null, "Overview ", this.serverName)
        );
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);

        if (this.state.status === 'initial') {
          return (
            React.createElement(Panel, {collapsible: true, expanded: this.expanded, header: this.title})
          );
        }
        else {
          return (
            React.createElement(Panel, {
              collapsible: true,
              expanded: this.expanded,
              header: this.title,
              bsStyle: "primary"
    	 },
              React.createElement(Grid, {
                fluid: true
              },
                React.createElement(Row, null,
                  React.createElement(Col, {md: 4},
                    React.createElement(BuildDetails, {
                      controller: this.controller}
                    )
                  ),
                  React.createElement(Col, {md: 3},
                    React.createElement(MasterProcessDetails, {
                      controller: this.controller}
                    )
                  ),
                  React.createElement(Col, {md: 5},
                    React.createElement(WorkerProcessDetailsTable, {
                      controller: this.controller}
                    )
                  )
                )
              )
            )
          );
        }
      }
    });

    module.exports = OverviewPanel;
    },{"./BuildDetails":671,"./MasterProcessDetails":680,"./WorkerProcessDetailsTable":697,"./controller-OverviewPanel":718,"react":618,"react-bootstrap":96}],687:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var Inspector = require('react-json-inspector');

    var {
      Button,
      Glyphicon,
      OverlayTrigger,
      Panel,
      Tooltip
    } = ReactBootstrap;

    var SessionDetails = React.createClass({displayName: "SessionDetails",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-SessionDetails')(this.props.controller, this);
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);

       //console.log('rendering SessionDetails - ' + JSON.stringify(this.data));

        if (!this.data) {
          return (
            React.createElement("div", null)
          );
        }

        // create a clone of data to ensure re-rendering
        var newData = {};
        Object.assign(newData, this.data);

        return (
          React.createElement(Panel, {
            collapsible: true,
            expanded: this.expanded,
            header: this.title,
            bsStyle: "info"
          },
            React.createElement(Inspector, {
              data: newData,
              isExpanded: this.isExpanded,
              onClick: this.nodeClicked,
              search: false}
            )
          )
        );
      }
    });

    module.exports = SessionDetails;
    },{"./controller-SessionDetails":719,"react":618,"react-bootstrap":96,"react-json-inspector":413}],688:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var moment = require('moment');
    var {
      Button,
      Glyphicon,
      OverlayTrigger,
      Popover,
      Table,
      Tooltip
    } = ReactBootstrap;

    var SessionTableRow = require('./SessionTableRow');

    var SessionTable = React.createClass({displayName: "SessionTable",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-SessionTable')(this.props.controller, this);
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //console.log('Rendering SessionTable');
        //var componentPath = this.controller.updateComponentPath(this);

        var rows = [];
        var row;
        var session;
        var expiry;
        //console.log('this.props.sessions = ' + JSON.stringify(this.props.sessions));
        for (var i = 0; i < this.props.sessions.length; i++) {
          session = this.props.sessions[i];
          expiry = moment(new Date(session.expiry * 1000)).format('DD MMM YY, h:mm:ss a');
          row = (
            React.createElement(SessionTableRow, {
              key: session.id,
              pid: session.id,
              application: session.application,
              token: session.token,
              expiry: expiry,
              disabled: session.disabled,
              controller: this.controller}
            )
          );
          rows.push(row);
        }

        //console.log('session rows: ' + JSON.stringify(rows));

        return (
            React.createElement(Table, {
              responsive: true,
              className: "overviewTable"
            },
            React.createElement("thead", null,
              React.createElement("tr", null,
                React.createElement("th", null, "Id"),
                React.createElement("th", null, "Application"),
                React.createElement("th", null, "Expiry"),
                React.createElement("th", null, " "),
                React.createElement("th", null, " ")
              )
            ),
            React.createElement("tbody", null,
              rows
            )
          )
        );
      }
    });

    module.exports = SessionTable;
    },{"./SessionTableRow":689,"./controller-SessionTable":720,"moment":9,"react":618,"react-bootstrap":96}],689:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var {
      Button,
      Glyphicon,
      OverlayTrigger,
      Popover,
      Table,
      Tooltip
    } = ReactBootstrap;

    var SessionTableRow = React.createClass({displayName: "SessionTableRow",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-SessionTableRow')(this.props.controller, this);
        var id = 'Session' + this.props.pid + 'StopBtn';
        this.stopTooltip = (
          React.createElement(Tooltip, {
            id: id
          },
            "Stop and Delete this Session"
          )
        );
        id = 'Session' + this.props.pid + 'ShowBtn';
        this.showTooltip = (
          React.createElement(Tooltip, {
            id: id
          },
            "Show Session Details"
          )
        );

      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //console.log('Rendering SessionTableRow');
        //var componentPath = this.controller.updateComponentPath(this);

        return (
          React.createElement("tr", null,
            React.createElement("td", null,
                this.props.pid
            ),
            React.createElement("td", null, this.props.application),
            React.createElement("td", null, this.props.expiry),
            React.createElement("td", null,
              React.createElement(OverlayTrigger, {
                placement: "top",
                overlay: this.stopTooltip
              },
                React.createElement(Button, {
                  bsStyle: "danger",
                  onClick: this.stopSession,
                  bsSize: "small",
                  disabled: this.props.disabled
                },
                  React.createElement(Glyphicon, {
                    glyph: "remove"}
                  )
                )
              )
            ),
            React.createElement("td", null,
              React.createElement(OverlayTrigger, {
                placement: "top",
                overlay: this.showTooltip
              },
                React.createElement(Button, {
                  bsStyle: "info",
                  onClick: this.showSession,
                  bsSize: "small"
                },
                  React.createElement(Glyphicon, {
                    glyph: "list-alt"}
                  )
                )
              )
            )
          )
        );
      }
    });

    module.exports = SessionTableRow;
    },{"./controller-SessionTableRow":721,"react":618,"react-bootstrap":96}],690:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var {
      Grid,
      Row,
      Col
    } = ReactBootstrap;

    var SessionsPanel = require('./SessionsPanel');

    var DocumentStoreContainer = React.createClass({displayName: "DocumentStoreContainer",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-SessionsContainer')(this.props.controller, this);
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);

        return (
          React.createElement(Grid, {
            fluid: true,
            className: this.hideContainer ? 'hidden' : ''
          },
            React.createElement(Row, null,
              React.createElement(Col, {md: 12},
                React.createElement(SessionsPanel, {
                  controller: this.controller}
                )
              )
            )
          )
        );

      }
    });

    module.exports = DocumentStoreContainer;
    },{"./SessionsPanel":691,"./controller-SessionsContainer":722,"react":618,"react-bootstrap":96}],691:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var Inspector = require('react-json-inspector');
    var SessionTable = require('./SessionTable');
    var SessionDetails = require('./SessionDetails');

    var {
      Button,
      Col,
      Glyphicon,
      Grid,
      OverlayTrigger,
      Panel,
      Row,
      Tooltip
    } = ReactBootstrap;

    var SessionsPanel = React.createClass({displayName: "SessionsPanel",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-SessionsPanel')(this.props.controller, this);

        this.tooltip = (
          React.createElement(Tooltip, {
            id: "SessionsRefreshBtn"
          },
            "Refresh"
          )
        );

        this.title = (
          React.createElement("span", null,
            React.createElement("b", null, "Sessions"),
            React.createElement(OverlayTrigger, {
              placement: "top",
                overlay: this.tooltip
                    },
              React.createElement(Button, {
                bsClass: "btn btn-success pull-right",
                onClick: this.refresh
              },
                React.createElement(Glyphicon, {
                  glyph: "refresh"}
                )
              )
            )
          )
        );
      },

      componentDidMount: function() {
        // fetch current session list
        this.refresh();
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);

       //console.log('rendering SessionsPanel: ' + JSON.stringify(this.sessionData));

        return (
          React.createElement(Panel, {
            collapsible: true,
            expanded: true,
            header: this.title,
            bsStyle: "primary"
          },
            React.createElement(Grid, {
              fluid: true
            },
              React.createElement(Row, null,
                React.createElement(Col, {md: 5},
                  React.createElement(SessionTable, {
                    controller: this.controller,
                    sessions: this.sessions}
                  )
                ),
                React.createElement(Col, {md: 7},
                  React.createElement(SessionDetails, {
                    controller: this.controller,
                    data: this.sessionData}
                  )
                )
              )
            )
          )
        );
      }
    });

    module.exports = SessionsPanel;
    },{"./SessionDetails":687,"./SessionTable":688,"./controller-SessionsPanel":723,"react":618,"react-bootstrap":96,"react-json-inspector":413}],692:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var {
      Button,
      Navbar
    } = ReactBootstrap;

    var controller;

    module.exports = React.createClass({displayName: "exports",

      startMonitor: function() {
        location.reload();
      },

      render: function() {
        return (
          React.createElement("div", null,
            React.createElement(Navbar, {inverse: true},
              React.createElement(Navbar.Brand, null,
                this.props.title
              )
            ),
            React.createElement(Button, {
              bsStyle: "success",
              onClick: this.startMonitor
            },
              "Redémarrer le moniteur"
            )
          )
        );
      }
    });
    },{"react":618,"react-bootstrap":96}],693:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var {
      Button,
      ButtonGroup,
      Glyphicon
    } = ReactBootstrap;

    var value;

    var Spinner = React.createClass({displayName: "Spinner",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {

        value = this.props.value;

        var component = this;

        this.increment = function() {
          value++;
          component.props.changeHandler(value);
          component.setState({
            status: 'update'
          });
        };

        this.decrement = function() {
          if (value > 1) {
            value--;
            component.props.changeHandler(value);
            component.setState({
              status: 'update'
            });
          }
        };
      },

      componentWillReceiveProps: function(newProps) {
        value = newProps.value;
      },

      render: function() {
        return (

            React.createElement(ButtonGroup, null,
              React.createElement(Button, null,
               value
              ),
              React.createElement(ButtonGroup, {
                vertical: true
              },
                React.createElement(Button, {
                  bsStyle: "default",
                  bsSize: "xsmall",
                  onClick: this.increment
                },
                  React.createElement(Glyphicon, {
                    glyph: "triangle-top"}
                  )
                ),
                React.createElement(Button, {
                  bsStyle: "default",
                  bsSize: "xsmall",
                  onClick: this.decrement
                },
                  React.createElement(Glyphicon, {
                    glyph: "triangle-bottom"}
                  )
                )
              )
            )

        );
      }

    });

    module.exports = Spinner;
    },{"react":618,"react-bootstrap":96}],694:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var {
      Grid,
      Row,
      Col
    } = ReactBootstrap;

    var TerminalPanel = require('./TerminalPanel');

    var TerminalContainer = React.createClass({displayName: "TerminalContainer",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-TerminalContainer')(this.props.controller, this);
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);

        return (
          React.createElement(Grid, {
            fluid: true,
            className: this.hideContainer ? 'hidden' : ''
          },
            React.createElement(Row, null,
              React.createElement(Col, {md: 12},
                React.createElement(TerminalPanel, {
                  controller: this.controller}
                )
              )
            )
          )
        );

      }
    });

    module.exports = TerminalContainer;
    },{"./TerminalPanel":695,"./controller-TerminalContainer":724,"react":618,"react-bootstrap":96}],695:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var Inspector = require('react-json-inspector');

    var {
      Panel,
      Grid,
      Row,
      Col,
      Image,
      ResponsiveEmbed
    } = ReactBootstrap;

    var AproposPanel = React.createClass({displayName: "AproposPanel",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-AproposPanel')(this.props.controller, this);

        this.title = (
          React.createElement("h1", null, "Terminal")
        );
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //var componentPath = this.controller.updateComponentPath(this);

        return (
          React.createElement(Panel, {
            collapsible: true,
            expanded: this.expanded,
            header: this.title,
            bsStyle: "primary"
          },

          React.createElement("div", {style: {width: 'auto', height: 'auto'}},
            React.createElement(ResponsiveEmbed, {a16by9: true},
              React.createElement("embed", {type: "text/html", src: "http://localhost:8081/yexpert-term/index.html"})
            )
          )

          )
        );
      }
    });

    module.exports = AproposPanel;

    /*
            {
            <Grid>
              <Row>
                <Col md={12}>
                  <iframe height="430px" width="710px" src="http://localhost:8081/yexpert-term/index.html" frameborder="0" allowfullscreen></iframe>
                </Col>
              </Row>
            </Grid>

            }
    */
    },{"./controller-AproposPanel":700,"react":618,"react-bootstrap":96,"react-json-inspector":413}],696:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var {
      Button,
      Glyphicon,
      OverlayTrigger,
      Popover,
      Table,
      Tooltip
    } = ReactBootstrap;

    var WorkerProcessDetails = React.createClass({displayName: "WorkerProcessDetails",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-WorkerProcessDetails')(this.props.controller, this);
        var id = 'worker' + this.props.pid + 'ShutdownBtn';
        this.tooltip = (
          React.createElement(Tooltip, {
            id: id
          },
            "Shutdown this Worker Process"
          )
        );
      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //console.log('Rendering WorkerProcessDetails Row!');
        //var componentPath = this.controller.updateComponentPath(this);

        var title = 'Worker ' + this.props.pid + ' Memory';

        var memoryPopover = (
          React.createElement(Popover, {id: "worker-process-memory", title: title},
            React.createElement(Table, null,
              React.createElement("tbody", null,
                React.createElement("tr", null,
                  React.createElement("td", null, "rss:"),
                  React.createElement("td", null, this.props.memory.rss)
                ),
                React.createElement("tr", null,
                  React.createElement("td", null, "heapTotal:"),
                  React.createElement("td", null, this.props.memory.heapTotal)
                ),
                React.createElement("tr", null,
                  React.createElement("td", null, "heapUsed:"),
                  React.createElement("td", null, this.props.memory.heapUsed)
                )
              )
            )
          )
        );

        return (
          React.createElement("tr", null,
            React.createElement("td", null,
              React.createElement(OverlayTrigger, {
                trigger: ['hover', 'focus'],
                placement: "left",
                overlay: memoryPopover
              },
                React.createElement("span", null, this.props.pid)
              )
            ),
            React.createElement("td", null, this.props.noOfRequests),
            React.createElement("td", null, this.props.available),
            React.createElement("td", {className: "pushRight"},
              React.createElement(OverlayTrigger, {
                placement: "top",
                overlay: this.tooltip
              },
                React.createElement(Button, {
                  bsStyle: "danger",
                  onClick: this.stopWorker
                },
                  React.createElement(Glyphicon, {
                    glyph: "remove"}
                  )
                )
              )
            )
          )
        );
      }
    });

    module.exports = WorkerProcessDetails;
    },{"./controller-WorkerProcessDetails":725,"react":618,"react-bootstrap":96}],697:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    "use strict"

    var React = require('react');
    var ReactBootstrap = require('react-bootstrap');
    var {
      Panel,
      Table,
      Button,
      Glyphicon,
      OverlayTrigger,
      Tooltip
    } = ReactBootstrap;

    var WorkerProcessDetails = require('./WorkerProcessDetails');
    var Spinner = require('./Spinner');

    var WorkerProcessDetailsTable = React.createClass({displayName: "WorkerProcessDetailsTable",

      getInitialState: function() {
        return {
          status: 'initial'
        }
      },

      componentWillMount: function() {
        this.controller = require('./controller-WorkerProcessDetailsTable')(this.props.controller, this);
        this.title = (
          React.createElement("h2", null, "Worker Process Details")
        );
        this.tooltip = (
          React.createElement(Tooltip, {
            id: "workerProcessShutdownBtn"
          },
            "Shutdown this Worker Process"
          )
        );

      },

      componentWillReceiveProps: function(newProps) {
        this.onNewProps(newProps);
      },

      render: function() {

        //console.log('Rendering WorkerProcessDetails Table!');
        //var componentPath = this.controller.updateComponentPath(this);

        var rows = [];
        var row;
        var details;
        for (var i = 0; i < this.workerDetails.length; i++) {
          details = this.workerDetails[i];
    	  //console.log('** details = ' + JSON.stringify(details));
          row = (
            React.createElement(WorkerProcessDetails, {
              key: details.pid,
              pid: details.pid,
              memory: details.memory,
              noOfRequests: details.noOfMessages,
              available: details.available.toString(),
              controller: this.controller,
              stopWorker: this.stopWorker}
            )
          );
          rows.push(row);
        }

        return (
          React.createElement(Panel, {
            header: this.title,
            bsStyle: "info"
          },
            React.createElement(Table, {
              responsive: true,
              className: "overviewTable"
            },
              React.createElement("thead", null,
                React.createElement("tr", null,
                  React.createElement("th", null, "PID"),
                  React.createElement("th", null, "Requests"),
                  React.createElement("th", null, "Available"),
                  React.createElement("th", {className: "pushRight"},
                    "PoolSize   ",
                    React.createElement(Spinner, {
                      value: this.poolSize,
                      changeHandler: this.setPoolSize}
                    )
                  )
                )
              ),
              React.createElement("tbody", null,
                rows
              )
            )
          )
        );
      }
    });

    module.exports = WorkerProcessDetailsTable;
    },{"./Spinner":693,"./WorkerProcessDetails":696,"./controller-WorkerProcessDetailsTable":726,"react":618,"react-bootstrap":96}],698:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    var reactLoader = require('ewd-xpress-react').loader;

    var params = {
      applicationName: 'ewd-xpress-monitor',
      MainPage: require('./MainPage')
    };

    reactLoader(params);
    },{"./MainPage":679,"ewd-xpress-react":4}],699:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.onNewProps = function(newProps) {
        component.hideContainer = (newProps.status !== 'apropos');
      };

      // N'affichez pas le panneau à propos lors du premier rendu après la connexion

      component.hideContainer = true;

      return controller;
    };
    },{}],700:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!
    *****************nettoyer
    */

    module.exports = function (controller, component) {

      component.refresh = function() {
        var message = {
          type: 'getGlobalDirectory'
        };
        controller.send(message, function(responseObj) {
          component.data = {};
          responseObj.message.forEach(function(name) {
            component.data[name] = expandText;
          });
          component.setState({status: 'globalDirectory'});
        });
      };

      component.onNewProps = function(newProps) {
      };

      component.expanded = true;

      var expandText = ' -->';
      component.expand = false;
      component.isExpanded = function(keypath, value) {
        return component.expand;
      };

      component.refresh();

      function index(obj,is, value) {
        if (typeof is == 'string') {
          return index(obj,is.split('.'), value);
        }
        else if (is.length==1 && value!==undefined) {
          return obj[is[0]] = value;
        }
        else if (is.length==0) {
          return obj;
        }
        else {
          return index(obj[is[0]],is.slice(1), value);
        }
      }

      component.nodeClicked = function(obj) {
        if (obj.value === expandText) {
          var message = {
            type: 'getNextSubscripts',
            params: {
              path: obj.path,
              expandText: expandText
            }
          };
          controller.send(message, function(responseObj) {
            index(component.data, obj.path, responseObj.message);
            component.expand = true;
            component.setState({status: 'nextSubscripts'});
          });
        }
      };

      return controller;
    };
    },{}],701:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.onNewProps = function(newProps) {
        component.hideContainer = (newProps.status !== 'bienvenue');
      };

      // Afficher le panneau de bienvenue lors du premier rendu après la connexion

      component.hideContainer = false;

      return controller;
    };
    },{}],702:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!
    *****************nettoyer
    */

    module.exports = function (controller, component) {

      component.refresh = function() {
        var message = {
          type: 'getGlobalDirectory'
        };
        controller.send(message, function(responseObj) {
          component.data = {};
          responseObj.message.forEach(function(name) {
            component.data[name] = expandText;
          });
          component.setState({status: 'globalDirectory'});
        });
      };

      component.onNewProps = function(newProps) {
      };

      component.expanded = true;

      var expandText = ' -->';
      component.expand = false;
      component.isExpanded = function(keypath, value) {
        return component.expand;
      };

      component.refresh();

      function index(obj,is, value) {
        if (typeof is == 'string') {
          return index(obj,is.split('.'), value);
        }
        else if (is.length==1 && value!==undefined) {
          return obj[is[0]] = value;
        }
        else if (is.length==0) {
          return obj;
        }
        else {
          return index(obj[is[0]],is.slice(1), value);
        }
      }

      component.nodeClicked = function(obj) {
        if (obj.value === expandText) {
          var message = {
            type: 'getNextSubscripts',
            params: {
              path: obj.path,
              expandText: expandText
            }
          };
          controller.send(message, function(responseObj) {
            index(component.data, obj.path, responseObj.message);
            component.expand = true;
            component.setState({status: 'nextSubscripts'});
          });
        }
      };

      return controller;
    };
    },{}],703:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.onNewProps = function(newProps) {
        //console.log('BuildDetails newProps: ' + JSON.stringify(newProps));
      };

      controller.on('getBuildDetails', function(messageObj) {
        var data = messageObj.message;
        component.nodejsBuild = data.nodejsBuild;
        var dbArr = data.dbInterface.split(';');
        component.dbInterface = dbArr[0];
        component.db = dbArr[1];
        component.qoper8Build = data.qoper8Build.no;
        component.docStoreBuild = data.docStoreBuild.no;
        component.qxBuild = data.qxBuild;
        component.xpressBuild = data.xpressBuild.no;
        component.setState({
          status: 'dataAvailable'
        });
      });

      component.nodejsBuild = '';
      component.dbInterface = '';
      component.db = '';
      component.qoper8Build = '';
      component.docStoreBuild = '';
      component.qxBuild = '';
      component.appRunnerBuild = '';

      controller.send({
        type: 'getBuildDetails'
      });

      return controller;
    };
    },{}],704:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.onNewProps = function(newProps) {
        //console.log('ConsoleContainer newProps: ' + JSON.stringify(newProps));
        component.hideContainer = (newProps.status !== 'console');
      };

      // N'affichez pas le panneau de la console lors du premier rendu après la connexion

      component.hideContainer = true;

      return controller;
    };
    },{}],705:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.onNewProps = function(newProps) {
        //console.log('ConsolePanel newProps: ' + JSON.stringify(newProps));
      };

      component.expanded = true;
    /*
    //----------------------------------------
      component.serverName = 'ewd-xpress';

      controller.on('getServerName', function(responseObj) {
        if (responseObj.message.serverName && responseObj.message.serverName !== '') {
          component.serverName = responseObj.message.serverName;
          component.setState({
            status: 'updated'
          });
        }
      });

      controller.send({
        type: 'getServerName'
      });
    //----------------------------------------
    */

      return controller;
    };
    },{}],706:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.onNewProps = function(newProps) {
        component.status = newProps.status;
      };

      component.status = 'initial';

      return controller;
    };
    },{}],707:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.onNewProps = function(newProps) {
        component.hideContainer = (newProps.status !== 'docstore');
      };

      // don't display the console panel when first rendered after login

      component.hideContainer = true;

      return controller;
    };
    },{}],708:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.refresh = function() {
        var message = {
          type: 'getGlobalDirectory'
        };
        controller.send(message, function(responseObj) {
          component.data = {};
          responseObj.message.forEach(function(name) {
            component.data[name] = expandText;
          });
          component.setState({status: 'globalDirectory'});
        });
      };

      component.onNewProps = function(newProps) {
      };

      component.expanded = true;

      var expandText = ' -->';
      component.expand = false;
      component.isExpanded = function(keypath, value) {
        return component.expand;
      };

      component.refresh();

      function index(obj,is, value) {
        if (typeof is == 'string') {
          return index(obj,is.split('.'), value);
        }
        else if (is.length==1 && value!==undefined) {
          return obj[is[0]] = value;
        }
        else if (is.length==0) {
          return obj;
        }
        else {
          return index(obj[is[0]],is.slice(1), value);
        }
      }

      component.nodeClicked = function(obj) {
        if (obj.value === expandText) {
          var message = {
            type: 'getNextSubscripts',
            params: {
              path: obj.path,
              expandText: expandText
            }
          };
          controller.send(message, function(responseObj) {
            index(component.data, obj.path, responseObj.message);
            component.expand = true;
            component.setState({status: 'nextSubscripts'});
          });
        }
      };

      return controller;
    };
    },{}],709:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.handleChange = function(e) {
        // Mise à jour de l'affichage du champ dans le composant d'entrée :

        var fieldName = component.props.fieldname;
        var value = e.target.value;

        component.setState({
          value: value
        });

        // Puis passer au composant parent LoginModal :

        controller.LoginModal.onLoginFieldChange({
          value: value,
          ref: fieldName
        });
      };

      component.validationState = function() {
        if (component.state.value.length === 0) return 'error';
      };

      return controller;
    };
    },{}],710:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.password = '';

      controller.LoginModal = {
        onLoginFieldChange: function(inputObj) {
          //console.log('onFieldChange - ' + inputObj.ref + '; ' + inputObj.value);
          component[inputObj.ref] = inputObj.value;
        }
      };

      component.handleKeyDown = function(e) {
        // enter key pressed
        if (e.charCode === 13) {
          component.handleLogin();
        }
      };

      component.handleLogin = function() {

        if (component.password === '') {
          controller.displayError("Vous devez entrer le mot de passe d'administration");
          return;
        }

        // send login message
        //   response handler subscription is in parent component (MainPage)

        controller.send({
          type: 'login',
          params: {
            password: component.password
          }
        });
      };

      return controller;
    };
    },{}],711:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      //controller.log = true;

      controller.toastr = function(type, text) {
        if (type && type !== '' && component.refs && component.refs.toastContainer && component.refs.toastContainer[type]) {
          component.refs.toastContainer[type](text);
        }
      };

      controller.displayError = function(error) {
        controller.toastr('error', error);
      };

      // Afficher générique EWD.js erreurs using toastr :

      controller.on('error', function(messageObj) {
        var error = messageObj.message.error || messageObj.message;
        controller.displayError(error);
      });

      // Publier le gestionnaire de réponses de connexion dans ce
      // composant pour forcer le rendu de la page principale

      controller.on('login', function(messageObj) {
        if (!messageObj.message.error && messageObj.message.ok) {
          // connecté
          component.showLoginModal = false;
          component.setState({
            status: 'loggedIn'
          });
        }
      });

      controller.on('stopMasterProcess', function(messageObj) {
        console.log('Le processus principal a été arrêté');
      });

      controller.stopTimers = function() {
        for (var name in controller.timers) {
          clearInterval(controller.timers[name]);
        }
        delete controller.timers;
      };

      controller.on('socketDisconnected', function() {
        controller.toastr('warning', 'EWD Back-end a été arrêté');
        //controller.emit('logout');
        controller.stopTimers();
      });

      controller.on('nouvpartition', function() {component.setState({status: 'nouvpartition'});});

      controller.on('bienvenue', function() {component.setState({status: 'bienvenue'});});
      controller.on('apropos', function() {component.setState({status: 'apropos'});});

      controller.on('logout', function() {
        // Arrêter tous les minuteries
        controller.stopTimers();
        // Affichage du commutateur pour se déconnecter / arrêter
        controller.disconnectSocket();
        component.setState({
          status: 'shutdown'
        });
      });

      controller.on('menustore', function() {
    	  component.setState({
            status: 'menustore'
          });
      });

      controller.on('terminal', function() {
    	  component.setState({
            status: 'terminal'
          });
      });

      controller.on('overview', function() {
    	  component.setState({
            status: 'overview'
          });
      });

      controller.on('docstore', function() {
    	  component.setState({
            status: 'docstore'
          });
      });

      controller.on('sessions', function() {
        component.setState({
          status: 'sessions'
        });
      });

      controller.on('console', function() {
        component.setState({
          status: 'console'
        });
      });

      controller.on('ewd-reregistered', function() {
        console.log('Réenregistré - redémarrer les minuteries');
        // Back-end est de retour - redémarrez tout
        controller.timers = {};
        controller.emit('startTimers');
        controller.toastr('warning', 'Le back-end EWD a été redémarré');
      });

      controller.navOptionSelected = function(eventKey) {
        controller.emit(eventKey);
      };

      controller.timers = {};

      component.showLoginModal = true;

      return controller;
    };
    },{}],712:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.onNewProps = function(newProps) {
        //console.log('MasterProcessDetails newProps: ' + JSON.stringify(newProps));
      };

      component.stopMasterProcess = function() {
        controller.send({type: 'stopMasterProcess'});
      };

      component.pid = '';
      component.started = '';
      component.upTime = '';
      component.master = {
        memory: {
          rss: 'Not available',
          heapTotal: 'Not available',
          heapUsed: 'Not available'
        }
      };

      controller.on('startTimers', function() {
        if (!controller.timers.masterProcess) {
          controller.timers.masterProcess = setInterval(function() {
            controller.send({type: 'getMasterProcessDetails'});
          },30000);
        }
      });

      controller.on('getMasterProcessDetails', function(messageObj) {
        component.pid = messageObj.message.pid;
        component.started = messageObj.message.startTime;
        component.upTime = messageObj.message.upTime;
        component.master.memory = messageObj.message.memory;

        controller.emit('startTimers');

        if (!controller.timers.masterProcess) {
          controller.timers.masterProcess = setInterval(function() {
            controller.send({type: 'getMasterProcessDetails'});
          },30000);
        }

        component.setState({
          status: 'dataAvailable'
        });
      });

      controller.send({type: 'getMasterProcessDetails'});

      return controller;
    };
    },{}],713:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.onNewProps = function(newProps) {
        component.hideContainer = (newProps.status !== 'menustore');
      };

      // N'affichez pas le panneau de menue général lors du premier rendu après la connexion

      component.hideContainer = true;

      return controller;
    };
    },{}],714:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.refresh = function() {
        var message = {
          type: 'getGlobalDirectory'
        };
        controller.send(message, function(responseObj) {
          component.data = {};
          responseObj.message.forEach(function(name) {
            component.data[name] = expandText;
          });
          component.setState({status: 'globalDirectory'});
        });
      };

      component.onNewProps = function(newProps) {
      };

      component.expanded = true;

      var expandText = ' -->';
      component.expand = false;
      component.isExpanded = function(keypath, value) {
        return component.expand;
      };

      component.refresh();

      function index(obj,is, value) {
        if (typeof is == 'string') {
          return index(obj,is.split('.'), value);
        }
        else if (is.length==1 && value!==undefined) {
          return obj[is[0]] = value;
        }
        else if (is.length==0) {
          return obj;
        }
        else {
          return index(obj[is[0]],is.slice(1), value);
        }
      }

      component.nodeClicked = function(obj) {
        if (obj.value === expandText) {
          var message = {
            type: 'getNextSubscripts',
            params: {
              path: obj.path,
              expandText: expandText
            }
          };
          controller.send(message, function(responseObj) {
            index(component.data, obj.path, responseObj.message);
            component.expand = true;
            component.setState({status: 'nextSubscripts'});
          });
        }
      };

      return controller;
    };
    },{}],715:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.onNewProps = function(newProps) {
        component.hideContainer = (newProps.status !== 'nouvpartition');
      };

      // N'affichez pas le panneau NouvPartition lors du premier rendu après la connexion

      component.hideContainer = true;

      return controller;
    };
    },{}],716:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!
    *****************nettoyer
    */

    module.exports = function (controller, component) {

      component.refresh = function() {
        var message = {
          type: 'getGlobalDirectory'
        };
        controller.send(message, function(responseObj) {
          component.data = {};
          responseObj.message.forEach(function(name) {
            component.data[name] = expandText;
          });
          component.setState({status: 'globalDirectory'});
        });
      };

      component.onNewProps = function(newProps) {
      };

      component.expanded = true;

      var expandText = ' -->';
      component.expand = false;
      component.isExpanded = function(keypath, value) {
        return component.expand;
      };

      component.refresh();

      function index(obj,is, value) {
        if (typeof is == 'string') {
          return index(obj,is.split('.'), value);
        }
        else if (is.length==1 && value!==undefined) {
          return obj[is[0]] = value;
        }
        else if (is.length==0) {
          return obj;
        }
        else {
          return index(obj[is[0]],is.slice(1), value);
        }
      }

      component.nodeClicked = function(obj) {
        if (obj.value === expandText) {
          var message = {
            type: 'getNextSubscripts',
            params: {
              path: obj.path,
              expandText: expandText
            }
          };
          controller.send(message, function(responseObj) {
            index(component.data, obj.path, responseObj.message);
            component.expand = true;
            component.setState({status: 'nextSubscripts'});
          });
        }
      };

      return controller;
    };
    },{}],717:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.onNewProps = function(newProps) {
        component.hideContainer = (newProps.status !== 'overview');
      };

      // N'affichez pas le panneau de vue d'ensemble lors du premier rendu après la connexion

      component.hideContainer = true;

      return controller;
    };
    },{}],718:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.onNewProps = function(newProps) {
        //console.log('OverviewPanel newProps: ' + JSON.stringify(newProps));
      };

      component.expanded = true;
      component.serverName = 'ewd-xpress';

      controller.on('getServerName', function(responseObj) {
        if (responseObj.message.serverName && responseObj.message.serverName !== '') {
          component.serverName = responseObj.message.serverName;
          component.setState({
            status: 'updated'
          });
        }
      });

      controller.send({
        type: 'getServerName'
      });

      return controller;
    };
    },{}],719:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.data = {};
      component.token = '';
      component.sessionId = '';

      component.title = 'Session Data';

      component.onNewProps = function(newProps) {
        //console.log('controller-SessionDetails newProps: ' + JSON.stringify(newProps));
        component.data = newProps.data.data || {};
        if (newProps.data.id && newProps.data.id !== '') {
          component.title = 'Session ' + newProps.data.id;
        }
        else {
          // previously-displayed session no longer exists
          component.title = 'Session Data';
          component.data = {};
        }
        if (newProps.data.token) component.token = newProps.data.token;
      };

      component.expanded = true;

      var expandText = ' -->';
      component.expand = false;
      component.isExpanded = function(keypath, value) {
        return component.expand;
      };

      function index(obj,is, value) {
        if (typeof is == 'string') {
          return index(obj,is.split('.'), value);
        }
        else if (is.length==1 && value!==undefined) {
          return obj[is[0]] = value;
        }
        else if (is.length==0) {
          return obj;
        }
        else {
          return index(obj[is[0]],is.slice(1), value);
        }
      }

      component.nodeClicked = function(obj) {
        if (obj.value === expandText) {
          var message = {
            type: 'getSessionSubscripts',
            params: {
              path: obj.path,
              expandText: expandText,
              token: component.token
            }
          };
          controller.send(message, function(responseObj) {
            if (responseObj.message.error) {
              // session no longer exists, so refresh the entire session display
              //console.log('session no longer exists so refresh session display');
              controller.emit('refreshSessionDisplay');
            }
            else {
              index(component.data, obj.path, responseObj.message.data);
              component.expand = true;
              component.setState({status: 'updated'});
            }
          });
        }
      };

      return controller;
    };
    },{}],720:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.onNewProps = function(newProps) {
      };

      component.sessions = [];

      return controller;
    };
    },{}],721:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.onNewProps = function(newProps) {
      };

      component.stopSession = function() {
        var message = {
          type: 'stopSession',
          params: {
            token: component.props.token
          }
        };
        controller.send(message);
      };

      component.showSession = function() {
        var message = {
          type: 'showSession',
          params: {
            token: component.props.token
          }
        };
        controller.send(message);
      };

      return controller;
    };
    },{}],722:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.onNewProps = function(newProps) {
        component.hideContainer = (newProps.status !== 'sessions');
      };

      // don't display the session panel when first rendered after login

      component.hideContainer = true;

      return controller;
    };
    },{}],723:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.refresh = function() {
        var message = {
          type: 'getSessions'
        };
        controller.send(message, function(responseObj) {
          component.sessions = responseObj.message;
          component.setState({status: 'gotSessions'});
        });
      };

      controller.on('stopSession', function(responseObj) {
        component.refresh();
      });

      controller.on('refreshSessionDisplay', function() {
        component.sessionData = {};
        component.refresh();
      });

      controller.on('showSession', function(responseObj) {

        if (responseObj.message.error) {
          // the selected session no longer exists, so refresh the session table
          component.sessionData = {};
          component.refresh();
        }
        else {
          component.sessionData = responseObj.message;
          component.setState({status: 'showSession'});
        }
      });

      component.onNewProps = function(newProps) {
      };

      component.sessions = [];
      component.sessionData = {};

      return controller;
    };
    },{}],724:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.onNewProps = function(newProps) {
        //console.log('TerminalContainer newProps: ' + JSON.stringify(newProps));
        component.hideContainer = (newProps.status !== 'terminal');
      };

      // N'affichez pas le panneau du Terminal lors du premier rendu après la connexion

      component.hideContainer = true;

      return controller;
    };
    },{}],725:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.onNewProps = function(newProps) {
        //console.log('WorkerProcessDetails newProps: ' + JSON.stringify(newProps));
      };

      component.stopWorker = function() {
        console.log('stop worker ' + component.props.pid);
        component.props.stopWorker(component.props.pid);
      };

      return controller;
    };
    },{}],726:[function(require,module,exports){
    /*

    !----------------------------------------------------------------------------!
    !                                                                            !
    ! Yexpert : (your) Système Expert sous Mumps GT.M et GNU/Linux               !
    ! Copyright (C) 2001-2015 by Hamid LOUAKED (HL).                             !
    !                                                                            !
    !----------------------------------------------------------------------------!

    */

    module.exports = function (controller, component) {

      component.workers = {};

      component.onNewProps = function(newProps) {
        //console.log('WorkerProcessDetailsTable newProps: ' + JSON.stringify(newProps));
      };

      controller.on('stopWorkerProcess', function(messageObj) {
        controller.send({type: 'getWorkerDetails'});
      });

      component.stopWorker = function(pid) {
        controller.send({
          type: 'stopWorkerProcess',
          params: {
            pid: pid
          }
        });
        controller.toastr('warning', 'Worker ' + pid + ' shut down');
      };

      component.poolSize = 1;

      controller.on('startTimers', function() {
        if (!controller.timers.poolSize) {
          controller.timers.poolSize = setInterval(function() {
            controller.send({type: 'getPoolSize'});
          },15000);
        }
        if (!controller.timers.workerDetails) {
          controller.timers.workerDetails = setInterval(function() {
            controller.send({type: 'getWorkerDetails'});
          },10000);
        }
      });

      controller.on('getPoolSize', function(messageObj) {
        component.poolSize = messageObj.message.poolSize;
        controller.emit('startTimers');
        component.setState({
          status: 'poolSizeAvailable'
        });
      });

      component.setPoolSize = function(poolSize) {
        controller.send({
          type: 'setPoolSize',
          params: {
            poolSize: poolSize
          }
        });
      };

      component.workerDetails = [];

      controller.on('getWorkerDetails', function(messageObj) {
        //console.log('getWorkerDetails: ' + JSON.stringify(messageObj));
        component.workerDetails = messageObj.results;
        controller.emit('startTimers');

        component.setState({
          status: 'dataAvailable'
        });
      });

      controller.send({type: 'getWorkerDetails'});
      controller.send({type: 'getPoolSize'});

      return controller;
    };
    },{}],727:[function(require,module,exports){

    },{}],728:[function(require,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; };

    },{}]},{},[698]);